Subversion Repositories SmartDukaan

Rev

Rev 9456 | Rev 9724 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
9253 rajveer 120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
9253 rajveer 128 
     - isAndroid
5944 mandeep.dh 129 
    """
130 
    pass
131 
 
132 
  def getAllItemsInRange(self, offset, limit):
133 
    """
134 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
135 
 
136 
    Parameters:
137 
     - offset
138 
     - limit
139 
    """
140 
    pass
141 
 
142 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
143 
    """
144 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
145 
 
146 
    Parameters:
147 
     - itemStatus
148 
     - offset
149 
     - limit
150 
    """
151 
    pass
152 
 
153 
  def getItemCountByStatus(self, useStatus, itemStatus):
154 
    """
155 
    Gets a count of all items by status
156 
 
157 
    Parameters:
158 
     - useStatus
159 
     - itemStatus
160 
    """
161 
    pass
162 
 
163 
  def getBestSellers(self, ):
164 
    pass
165 
 
166 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
167 
    """
168 
    Parameters:
169 
     - beginIndex
170 
     - totalItems
171 
     - brand
172 
     - category
173 
    """
174 
    pass
175 
 
176 
  def getBestSellersCount(self, ):
177 
    pass
178 
 
179 
  def getBestDeals(self, ):
180 
    pass
181 
 
182 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
183 
    """
184 
    Parameters:
185 
     - beginIndex
186 
     - totalItems
187 
     - brand
188 
     - category
189 
    """
190 
    pass
191 
 
192 
  def getBestDealsCount(self, ):
193 
    pass
194 
 
195 
  def getComingSoon(self, ):
196 
    pass
197 
 
198 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
199 
    """
200 
    Parameters:
201 
     - beginIndex
202 
     - totalItems
203 
     - brand
204 
     - category
205 
    """
206 
    pass
207 
 
208 
  def getComingSoonCount(self, ):
209 
    pass
210 
 
211 
  def getLatestArrivals(self, ):
212 
    """
213 
    Returns a list of items sorted in the descending order by start date.
214 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
215 
    """
216 
    pass
217 
 
218 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
219 
    """
220 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
221 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
222 
 
223 
    Parameters:
224 
     - beginIndex
225 
     - totalItems
226 
     - brand
227 
     - categories
228 
    """
229 
    pass
230 
 
231 
  def getLatestArrivalsCount(self, ):
232 
    """
233 
    Get the total number of latest arrivals we are willing to show.
234 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
235 
    """
236 
    pass
237 
 
238 
  def generateNewEntityID(self, ):
239 
    pass
240 
 
241 
  def addCategory(self, category):
242 
    """
243 
    All category related functions
244 
 
245 
    Parameters:
246 
     - category
247 
    """
248 
    pass
249 
 
250 
  def getCategory(self, id):
251 
    """
252 
    Parameters:
253 
     - id
254 
    """
255 
    pass
256 
 
257 
  def getAllCategories(self, ):
258 
    pass
259 
 
260 
  def getAllSimilarItems(self, itemId):
261 
    """
262 
    Returns the list of similar items.
263 
 
264 
    Parameters:
265 
     - itemId
266 
    """
267 
    pass
268 
 
269 
  def addSimilarItem(self, itemId, catalogItemId):
270 
    """
271 
    Adds similar item.
272 
 
273 
    Parameters:
274 
     - itemId
275 
     - catalogItemId
276 
    """
277 
    pass
278 
 
6512 kshitij.so 279 
  def addTag(self, displayName, itemId):
280 
    """
281 
    Tag Related
282 
 
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteEntityTag(self, displayName, itemId):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
     - itemId
294 
    """
295 
    pass
296 
 
297 
  def deleteTag(self, displayName):
298 
    """
299 
    Parameters:
300 
     - displayName
301 
    """
302 
    pass
303 
 
304 
  def getAllTags(self, ):
305 
    pass
306 
 
307 
  def getAllEntitiesByTagName(self, displayName):
308 
    """
309 
    Parameters:
310 
     - displayName
311 
    """
312 
    pass
313 
 
6845 amit.gupta 314 
  def getAllEntityTags(self, ):
315 
    pass
316 
 
8590 kshitij.so 317 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 318 
    """
8579 kshitij.so 319 
    Banner Related
320 
 
6850 kshitij.so 321 
    Parameters:
8590 kshitij.so 322 
     - bannerCongregate
6850 kshitij.so 323 
    """
324 
    pass
325 
 
8579 kshitij.so 326 
  def updateBanner(self, banner):
327 
    """
328 
    Parameters:
329 
     - banner
330 
    """
331 
    pass
332 
 
6850 kshitij.so 333 
  def getAllBanners(self, ):
334 
    pass
335 
 
9155 kshitij.so 336 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 337 
    """
338 
    Parameters:
339 
     - bannerName
9155 kshitij.so 340 
     - bannerType
6850 kshitij.so 341 
    """
342 
    pass
343 
 
9155 kshitij.so 344 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 345 
    """
346 
    Parameters:
347 
     - bannerName
9155 kshitij.so 348 
     - bannerType
6850 kshitij.so 349 
    """
350 
    pass
351 
 
352 
  def getActiveBanners(self, ):
353 
    pass
354 
 
8579 kshitij.so 355 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 356 
    """
357 
    Parameters:
8579 kshitij.so 358 
     - bannerMaps
6849 kshitij.so 359 
    """
360 
    pass
361 
 
8579 kshitij.so 362 
  def updateBannerMap(self, bannerMap):
363 
    """
364 
    Parameters:
365 
     - bannerMap
366 
    """
367 
    pass
368 
 
6849 kshitij.so 369 
  def deleteBannerMap(self, bannerName):
370 
    """
371 
    Parameters:
372 
     - bannerName
373 
    """
374 
    pass
375 
 
9155 kshitij.so 376 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 377 
    """
378 
    Parameters:
379 
     - bannerName
9155 kshitij.so 380 
     - bannerType
6849 kshitij.so 381 
    """
382 
    pass
383 
 
8579 kshitij.so 384 
  def addBannerUri(self, bannerUriMappings):
385 
    """
386 
    Parameters:
387 
     - bannerUriMappings
388 
    """
389 
    pass
390 
 
9155 kshitij.so 391 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 392 
    """
393 
    Parameters:
394 
     - bannerName
9155 kshitij.so 395 
     - bannerType
8579 kshitij.so 396 
    """
397 
    pass
398 
 
399 
  def addCampaign(self, campaign):
400 
    """
401 
    Parameters:
402 
     - campaign
403 
    """
404 
    pass
405 
 
406 
  def getCampaigns(self, campaignName):
407 
    """
408 
    Parameters:
409 
     - campaignName
410 
    """
411 
    pass
412 
 
413 
  def deleteCampaign(self, campaignId):
414 
    """
415 
    Parameters:
416 
     - campaignId
417 
    """
418 
    pass
419 
 
420 
  def getAllCampaigns(self, ):
421 
    pass
422 
 
9155 kshitij.so 423 
  def getActiveBannersForMobileSite(self, ):
424 
    pass
425 
 
5944 mandeep.dh 426 
  def deleteSimilarItem(self, itemId, catalogItemId):
427 
    """
428 
    Delete similar item.
429 
 
430 
    Parameters:
431 
     - itemId
432 
     - catalogItemId
433 
    """
434 
    pass
435 
 
436 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
437 
    """
438 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
439 
    If yes, returns the itemId else returns 0
440 
 
441 
    Parameters:
442 
     - brand
443 
     - modelNumber
444 
     - modelName
445 
     - color
446 
    """
447 
    pass
448 
 
449 
  def validateRiskyStatus(self, itemId):
450 
    """
451 
    Check wether item is risky and change status if inventory is not available for risky items
452 
 
453 
    Parameters:
454 
     - itemId
455 
    """
456 
    pass
457 
 
458 
  def changeItemRiskyFlag(self, itemId, risky):
459 
    """
460 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
461 
 
462 
    Parameters:
463 
     - itemId
464 
     - risky
465 
    """
466 
    pass
467 
 
468 
  def getItemsByRiskyFlag(self, ):
469 
    """
470 
    Returns list of items marked as risky.
471 
    """
472 
    pass
473 
 
474 
  def getItemsForMasterSheet(self, category, brand):
475 
    """
476 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
477 
 
478 
    Parameters:
479 
     - category
480 
     - brand
481 
    """
482 
    pass
483 
 
484 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
485 
    """
486 
    Returns list of catalog ids of items with same similarity index as of the given itemId
487 
 
488 
    Parameters:
489 
     - beginIndex
490 
     - totalItems
491 
     - itemId
492 
    """
493 
    pass
494 
 
495 
  def addProductNotification(self, itemId, email):
496 
    """
497 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
498 
 
499 
    Parameters:
500 
     - itemId
501 
     - email
502 
    """
503 
    pass
504 
 
505 
  def sendProductNotifications(self, ):
506 
    """
507 
    Send the product notifications to the users for items which has stock.
508 
    """
509 
    pass
510 
 
511 
  def getAllBrandsByCategory(self, categoryId):
512 
    """
513 
    Returns list of brand names for a given category Id
514 
 
515 
    Parameters:
516 
     - categoryId
517 
    """
518 
    pass
519 
 
520 
  def getAllBrands(self, ):
521 
    """
522 
    Returns list of brand names
523 
    """
524 
    pass
525 
 
526 
  def getAllSources(self, ):
527 
    """
528 
    Return list of all sources
529 
    """
530 
    pass
531 
 
532 
  def getItemPricingBySource(self, itemId, sourceId):
533 
    """
534 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
535 
 
536 
    Parameters:
537 
     - itemId
538 
     - sourceId
539 
    """
540 
    pass
541 
 
542 
  def addSourceItemPricing(self, sourceItemPricing):
543 
    """
544 
    Adds prices to be displayed corresponding to the item if user comes from a source.
545 
    If item is not found or source is not found, it will throw exception.
546 
 
547 
    Parameters:
548 
     - sourceItemPricing
549 
    """
550 
    pass
551 
 
552 
  def getAllSourcePricing(self, itemId):
553 
    """
554 
    Returns the list of source pricing information of an item.
555 
    Raises an exception if item not found corresponding to itemId
556 
 
557 
    Parameters:
558 
     - itemId
559 
    """
560 
    pass
561 
 
562 
  def getItemForSource(self, item_id, sourceId):
563 
    """
564 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
565 
 
566 
    Parameters:
567 
     - item_id
568 
     - sourceId
569 
    """
570 
    pass
571 
 
572 
  def searchItemsInRange(self, searchTerms, offset, limit):
573 
    """
574 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
575 
 
576 
    Parameters:
577 
     - searchTerms
578 
     - offset
579 
     - limit
580 
    """
581 
    pass
582 
 
583 
  def getSearchResultCount(self, searchTerms):
584 
    """
585 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
586 
 
587 
    Parameters:
588 
     - searchTerms
589 
    """
590 
    pass
591 
 
592 
  def getProductNotifications(self, startDateTime):
593 
    """
594 
    Returns a list of product notifications added after a supplied datetime
595 
 
596 
    Parameters:
597 
     - startDateTime
598 
    """
599 
    pass
600 
 
7897 amar.kumar 601 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 602 
    """
603 
    Returns a list of count of requests for product notification against each item
604 
 
605 
    Parameters:
606 
     - startDateTime
7897 amar.kumar 607 
     - categoryId
5944 mandeep.dh 608 
    """
609 
    pass
610 
 
611 
  def addAuthorizationLog(self, itemId, username, reason):
612 
    """
613 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
614 
 
615 
    Parameters:
616 
     - itemId
617 
     - username
618 
     - reason
619 
    """
620 
    pass
621 
 
622 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
623 
    """
624 
    Parameters:
625 
     - catalog_item_id
626 
     - voucherType
627 
     - voucherAmount
628 
    """
629 
    pass
630 
 
631 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
632 
    """
633 
    Parameters:
634 
     - catalog_item_id
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getVoucherAmount(self, itemId, voucherType):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
     - voucherType
644 
    """
645 
    pass
646 
 
647 
  def getAllItemVouchers(self, itemId):
648 
    """
649 
    Parameters:
650 
     - itemId
651 
    """
652 
    pass
653 
 
654 
  def isValidCatalogItemId(self, catalog_item_id):
655 
    """
656 
    Parameters:
657 
     - catalog_item_id
658 
    """
659 
    pass
660 
 
7330 amit.gupta 661 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 662 
    """
663 
    Parameters:
664 
     - itemId
7330 amit.gupta 665 
     - stateId
6039 amit.gupta 666 
     - price
667 
    """
668 
    pass
5944 mandeep.dh 669 
 
6039 amit.gupta 670 
  def getVatAmountForItem(self, itemId, price):
671 
    """
672 
    Parameters:
673 
     - itemId
674 
     - price
675 
    """
676 
    pass
677 
 
6531 vikram.rag 678 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
679 
    """
680 
    Parameters:
681 
     - offset
682 
     - limit
683 
    """
684 
    pass
6039 amit.gupta 685 
 
6821 amar.kumar 686 
  def getAllAliveItems(self, ):
687 
    pass
688 
 
6921 anupam.sin 689 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 690 
    """
691 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 692 
 
6805 anupam.sin 693 
    Parameters:
694 
     - itemId
6921 anupam.sin 695 
     - price
6805 anupam.sin 696 
     - insurerId
697 
     - quantity
698 
    """
699 
    pass
700 
 
701 
  def getInsurer(self, insurerId):
702 
    """
703 
    Parameters:
704 
     - insurerId
705 
    """
706 
    pass
707 
 
6838 vikram.rag 708 
  def getAllInsurers(self, ):
709 
    pass
6805 anupam.sin 710 
 
6962 rajveer 711 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
712 
    """
713 
    Parameters:
714 
     - insurerId
715 
     - amount
716 
    """
717 
    pass
6838 vikram.rag 718 
 
7190 amar.kumar 719 
  def getFreebieForItem(self, itemId):
720 
    """
721 
    Parameters:
722 
     - itemId
723 
    """
724 
    pass
6962 rajveer 725 
 
7190 amar.kumar 726 
  def addOrUpdateFreebieForItem(self, freebieItem):
727 
    """
728 
    Parameters:
729 
     - freebieItem
730 
    """
731 
    pass
732 
 
7272 amit.gupta 733 
  def addOrUpdateBrandInfo(self, brandInfo):
734 
    """
735 
    Parameters:
736 
     - brandInfo
737 
    """
738 
    pass
739 
 
740 
  def getBrandInfo(self, ):
741 
    pass
742 
 
7256 rajveer 743 
  def getStorePricing(self, itemId):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
    """
748 
    pass
7190 amar.kumar 749 
 
7306 rajveer 750 
  def getStorePricings(self, itemIds):
751 
    """
752 
    Parameters:
753 
     - itemIds
754 
    """
755 
    pass
756 
 
7382 rajveer 757 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 758 
    """
759 
    Parameters:
760 
     - sp
7382 rajveer 761 
     - allColors
7265 rajveer 762 
    """
763 
    pass
7256 rajveer 764 
 
7281 kshitij.so 765 
  def getAllAmazonListedItems(self, ):
766 
    pass
7265 rajveer 767 
 
8619 kshitij.so 768 
  def searchAmazonItems(self, searchTerm, offset, limit):
769 
    """
770 
    Parameters:
771 
     - searchTerm
772 
     - offset
773 
     - limit
774 
    """
775 
    pass
776 
 
777 
  def getAmazonSearchResultCount(self, searchTerm):
778 
    """
779 
    Parameters:
780 
     - searchTerm
781 
    """
782 
    pass
783 
 
784 
  def getCountForAmazonlistedItems(self, ):
785 
    pass
786 
 
7281 kshitij.so 787 
  def getAmazonItemDetails(self, itemId):
788 
    """
789 
    Parameters:
790 
     - itemId
791 
    """
792 
    pass
793 
 
8168 kshitij.so 794 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 795 
    """
796 
    Parameters:
8168 kshitij.so 797 
     - amazonlisted
7281 kshitij.so 798 
    """
799 
    pass
800 
 
801 
  def addAmazonItem(self, amazonlisted):
802 
    """
803 
    Parameters:
804 
     - amazonlisted
805 
    """
806 
    pass
807 
 
7291 vikram.rag 808 
  def getAsinItems(self, ):
809 
    pass
7281 kshitij.so 810 
 
7291 vikram.rag 811 
  def getAllFbaListedItems(self, ):
812 
    pass
813 
 
814 
  def getAllNonFbaListedItems(self, ):
815 
    pass
816 
 
7460 kshitij.so 817 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
818 
    """
819 
    Parameters:
820 
     - itemId
821 
     - holdInventory
822 
     - defaultInventory
823 
    """
824 
    pass
7291 vikram.rag 825 
 
7770 kshitij.so 826 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
827 
    """
828 
    Parameters:
829 
     - type
830 
     - sku
831 
     - timestamp
832 
    """
833 
    pass
7460 kshitij.so 834 
 
7897 amar.kumar 835 
  def getAllParentCategories(self, ):
836 
    pass
7770 kshitij.so 837 
 
7977 kshitij.so 838 
  def addPageViewEvent(self, pageViewEvents):
839 
    """
840 
    Parameters:
841 
     - pageViewEvents
842 
    """
843 
    pass
7897 amar.kumar 844 
 
7977 kshitij.so 845 
  def addCartEvent(self, cartEvents):
846 
    """
847 
    Parameters:
848 
     - cartEvents
849 
    """
850 
    pass
851 
 
8182 amar.kumar 852 
  def addEbayItem(self, ebayItem):
853 
    """
854 
    Parameters:
855 
     - ebayItem
856 
    """
857 
    pass
858 
 
859 
  def getEbayItem(self, listingId):
860 
    """
861 
    Parameters:
862 
     - listingId
863 
    """
864 
    pass
865 
 
866 
  def updateEbayItem(self, ebayItem):
867 
    """
868 
    Parameters:
869 
     - ebayItem
870 
    """
871 
    pass
872 
 
8139 kshitij.so 873 
  def getAmazonListedItems(self, offset, limit):
874 
    """
875 
    Parameters:
876 
     - offset
877 
     - limit
878 
    """
879 
    pass
7977 kshitij.so 880 
 
8168 kshitij.so 881 
  def updateAmazonAttributesInBulk(self, amazonlisted):
882 
    """
883 
    Parameters:
884 
     - amazonlisted
885 
    """
886 
    pass
8139 kshitij.so 887 
 
8379 vikram.rag 888 
  def getAllItemstoListOnFba(self, ):
889 
    pass
8168 kshitij.so 890 
 
8379 vikram.rag 891 
  def getAllItemstoListOnNonFba(self, ):
892 
    pass
893 
 
8619 kshitij.so 894 
  def updateAsin(self, item):
895 
    """
896 
    Parameters:
897 
     - item
898 
    """
899 
    pass
8616 vikram.rag 900 
 
8739 vikram.rag 901 
  def addOrUpdateSnapdealItem(self, snapdealitem):
902 
    """
903 
    Parameters:
904 
     - snapdealitem
905 
    """
906 
    pass
8619 kshitij.so 907 
 
8739 vikram.rag 908 
  def getSnapdealItem(self, item_id):
909 
    """
910 
    Parameters:
911 
     - item_id
912 
    """
913 
    pass
914 
 
9242 kshitij.so 915 
  def getSnapdealItemDetails(self, item_id):
916 
    """
917 
    Parameters:
918 
     - item_id
919 
    """
920 
    pass
921 
 
8739 vikram.rag 922 
  def getAllSnapdealItems(self, ):
923 
    pass
924 
 
9242 kshitij.so 925 
  def getSnapdealItems(self, offset, limit):
926 
    """
927 
    Parameters:
928 
     - offset
929 
     - limit
930 
    """
931 
    pass
8739 vikram.rag 932 
 
9242 kshitij.so 933 
  def searchSnapdealItems(self, searchTerm, offset, limit):
934 
    """
935 
    Parameters:
936 
     - searchTerm
937 
     - offset
938 
     - limit
939 
    """
940 
    pass
941 
 
942 
  def getCountForSnapdealItems(self, ):
943 
    pass
944 
 
945 
  def getSnapdealSearchResultCount(self, searchTerm):
946 
    """
947 
    Parameters:
948 
     - searchTerm
949 
    """
950 
    pass
951 
 
9299 kshitij.so 952 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
953 
    """
954 
    Parameters:
955 
     - itemId
956 
     - insurerType
957 
    """
958 
    pass
9242 kshitij.so 959 
 
9456 vikram.rag 960 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
961 
    """
962 
    Parameters:
963 
     - skuAtSnapdeal
964 
    """
965 
    pass
9299 kshitij.so 966 
 
9621 manish.sha 967 
  def getProductFeedSubmit(self, catalogItemId):
968 
    """
969 
    Parameters:
970 
     - catalogItemId
971 
    """
972 
    pass
9456 vikram.rag 973 
 
9621 manish.sha 974 
  def addProductFeedSubmit(self, productFeedSubmit):
975 
    """
976 
    Parameters:
977 
     - productFeedSubmit
978 
    """
979 
    pass
980 
 
981 
  def updateProductFeedSubmit(self, productFeedSubmit):
982 
    """
983 
    Parameters:
984 
     - productFeedSubmit
985 
    """
986 
    pass
987 
 
988 
  def deleteProductFeedSubmit(self, catalogItemId):
989 
    """
990 
    Parameters:
991 
     - catalogItemId
992 
    """
993 
    pass
994 
 
995 
  def getAllProductFeedSubmit(self, ):
996 
    pass
997 
 
998 
 
5944 mandeep.dh 999 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
1000 
  def __init__(self, iprot, oprot=None):
1001 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
1002 
 
1003 
  def addItem(self, item):
1004 
    """
1005 
    Availability and inventory attributes
1006 
 
1007 
    Parameters:
1008 
     - item
1009 
    """
1010 
    self.send_addItem(item)
1011 
    return self.recv_addItem()
1012 
 
1013 
  def send_addItem(self, item):
1014 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
1015 
    args = addItem_args()
1016 
    args.item = item
1017 
    args.write(self._oprot)
1018 
    self._oprot.writeMessageEnd()
1019 
    self._oprot.trans.flush()
1020 
 
1021 
  def recv_addItem(self, ):
1022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1023 
    if mtype == TMessageType.EXCEPTION:
1024 
      x = TApplicationException()
1025 
      x.read(self._iprot)
1026 
      self._iprot.readMessageEnd()
1027 
      raise x
1028 
    result = addItem_result()
1029 
    result.read(self._iprot)
1030 
    self._iprot.readMessageEnd()
1031 
    if result.success is not None:
1032 
      return result.success
1033 
    if result.cex is not None:
1034 
      raise result.cex
1035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
1036 
 
1037 
  def updateItem(self, item):
1038 
    """
1039 
    Parameters:
1040 
     - item
1041 
    """
1042 
    self.send_updateItem(item)
1043 
    return self.recv_updateItem()
1044 
 
1045 
  def send_updateItem(self, item):
1046 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1047 
    args = updateItem_args()
1048 
    args.item = item
1049 
    args.write(self._oprot)
1050 
    self._oprot.writeMessageEnd()
1051 
    self._oprot.trans.flush()
1052 
 
1053 
  def recv_updateItem(self, ):
1054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1055 
    if mtype == TMessageType.EXCEPTION:
1056 
      x = TApplicationException()
1057 
      x.read(self._iprot)
1058 
      self._iprot.readMessageEnd()
1059 
      raise x
1060 
    result = updateItem_result()
1061 
    result.read(self._iprot)
1062 
    self._iprot.readMessageEnd()
1063 
    if result.success is not None:
1064 
      return result.success
1065 
    if result.cex is not None:
1066 
      raise result.cex
1067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1068 
 
1069 
  def isActive(self, itemId):
1070 
    """
1071 
    Checks if the item given to the corresponding itemId is active. If it's active,
1072 
    whether it's risky and if it's risky, its inventory position.
1073 
 
1074 
    Parameters:
1075 
     - itemId
1076 
    """
1077 
    self.send_isActive(itemId)
1078 
    return self.recv_isActive()
1079 
 
1080 
  def send_isActive(self, itemId):
1081 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1082 
    args = isActive_args()
1083 
    args.itemId = itemId
1084 
    args.write(self._oprot)
1085 
    self._oprot.writeMessageEnd()
1086 
    self._oprot.trans.flush()
1087 
 
1088 
  def recv_isActive(self, ):
1089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1090 
    if mtype == TMessageType.EXCEPTION:
1091 
      x = TApplicationException()
1092 
      x.read(self._iprot)
1093 
      self._iprot.readMessageEnd()
1094 
      raise x
1095 
    result = isActive_result()
1096 
    result.read(self._iprot)
1097 
    self._iprot.readMessageEnd()
1098 
    if result.success is not None:
1099 
      return result.success
1100 
    if result.isex is not None:
1101 
      raise result.isex
1102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1103 
 
7438 amit.gupta 1104 
  def getItemsStatus(self, itemIds):
1105 
    """
1106 
    Parameters:
1107 
     - itemIds
1108 
    """
1109 
    self.send_getItemsStatus(itemIds)
1110 
    return self.recv_getItemsStatus()
1111 
 
1112 
  def send_getItemsStatus(self, itemIds):
1113 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1114 
    args = getItemsStatus_args()
1115 
    args.itemIds = itemIds
1116 
    args.write(self._oprot)
1117 
    self._oprot.writeMessageEnd()
1118 
    self._oprot.trans.flush()
1119 
 
1120 
  def recv_getItemsStatus(self, ):
1121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1122 
    if mtype == TMessageType.EXCEPTION:
1123 
      x = TApplicationException()
1124 
      x.read(self._iprot)
1125 
      self._iprot.readMessageEnd()
1126 
      raise x
1127 
    result = getItemsStatus_result()
1128 
    result.read(self._iprot)
1129 
    self._iprot.readMessageEnd()
1130 
    if result.success is not None:
1131 
      return result.success
1132 
    if result.isex is not None:
1133 
      raise result.isex
1134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1135 
 
5944 mandeep.dh 1136 
  def getItemStatusDescription(self, itemId):
1137 
    """
1138 
    Parameters:
1139 
     - itemId
1140 
    """
1141 
    self.send_getItemStatusDescription(itemId)
1142 
    return self.recv_getItemStatusDescription()
1143 
 
1144 
  def send_getItemStatusDescription(self, itemId):
1145 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1146 
    args = getItemStatusDescription_args()
1147 
    args.itemId = itemId
1148 
    args.write(self._oprot)
1149 
    self._oprot.writeMessageEnd()
1150 
    self._oprot.trans.flush()
1151 
 
1152 
  def recv_getItemStatusDescription(self, ):
1153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1154 
    if mtype == TMessageType.EXCEPTION:
1155 
      x = TApplicationException()
1156 
      x.read(self._iprot)
1157 
      self._iprot.readMessageEnd()
1158 
      raise x
1159 
    result = getItemStatusDescription_result()
1160 
    result.read(self._iprot)
1161 
    self._iprot.readMessageEnd()
1162 
    if result.success is not None:
1163 
      return result.success
1164 
    if result.isex is not None:
1165 
      raise result.isex
1166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1167 
 
1168 
  def startItemOn(self, item_id, timestamp):
1169 
    """
1170 
    Parameters:
1171 
     - item_id
1172 
     - timestamp
1173 
    """
1174 
    self.send_startItemOn(item_id, timestamp)
1175 
    self.recv_startItemOn()
1176 
 
1177 
  def send_startItemOn(self, item_id, timestamp):
1178 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1179 
    args = startItemOn_args()
1180 
    args.item_id = item_id
1181 
    args.timestamp = timestamp
1182 
    args.write(self._oprot)
1183 
    self._oprot.writeMessageEnd()
1184 
    self._oprot.trans.flush()
1185 
 
1186 
  def recv_startItemOn(self, ):
1187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1188 
    if mtype == TMessageType.EXCEPTION:
1189 
      x = TApplicationException()
1190 
      x.read(self._iprot)
1191 
      self._iprot.readMessageEnd()
1192 
      raise x
1193 
    result = startItemOn_result()
1194 
    result.read(self._iprot)
1195 
    self._iprot.readMessageEnd()
1196 
    if result.cex is not None:
1197 
      raise result.cex
1198 
    return
1199 
 
1200 
  def retireItemOn(self, item_id, timestamp):
1201 
    """
1202 
    Parameters:
1203 
     - item_id
1204 
     - timestamp
1205 
    """
1206 
    self.send_retireItemOn(item_id, timestamp)
1207 
    self.recv_retireItemOn()
1208 
 
1209 
  def send_retireItemOn(self, item_id, timestamp):
1210 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1211 
    args = retireItemOn_args()
1212 
    args.item_id = item_id
1213 
    args.timestamp = timestamp
1214 
    args.write(self._oprot)
1215 
    self._oprot.writeMessageEnd()
1216 
    self._oprot.trans.flush()
1217 
 
1218 
  def recv_retireItemOn(self, ):
1219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1220 
    if mtype == TMessageType.EXCEPTION:
1221 
      x = TApplicationException()
1222 
      x.read(self._iprot)
1223 
      self._iprot.readMessageEnd()
1224 
      raise x
1225 
    result = retireItemOn_result()
1226 
    result.read(self._iprot)
1227 
    self._iprot.readMessageEnd()
1228 
    if result.cex is not None:
1229 
      raise result.cex
1230 
    return
1231 
 
1232 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1233 
    """
1234 
    Parameters:
1235 
     - item_id
1236 
     - timestamp
1237 
     - newstatus
1238 
    """
1239 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1240 
    self.recv_changeItemStatus()
1241 
 
1242 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1243 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1244 
    args = changeItemStatus_args()
1245 
    args.item_id = item_id
1246 
    args.timestamp = timestamp
1247 
    args.newstatus = newstatus
1248 
    args.write(self._oprot)
1249 
    self._oprot.writeMessageEnd()
1250 
    self._oprot.trans.flush()
1251 
 
1252 
  def recv_changeItemStatus(self, ):
1253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1254 
    if mtype == TMessageType.EXCEPTION:
1255 
      x = TApplicationException()
1256 
      x.read(self._iprot)
1257 
      self._iprot.readMessageEnd()
1258 
      raise x
1259 
    result = changeItemStatus_result()
1260 
    result.read(self._iprot)
1261 
    self._iprot.readMessageEnd()
1262 
    if result.cex is not None:
1263 
      raise result.cex
1264 
    return
1265 
 
1266 
  def getItem(self, item_id):
1267 
    """
1268 
    Parameters:
1269 
     - item_id
1270 
    """
1271 
    self.send_getItem(item_id)
1272 
    return self.recv_getItem()
1273 
 
1274 
  def send_getItem(self, item_id):
1275 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1276 
    args = getItem_args()
1277 
    args.item_id = item_id
1278 
    args.write(self._oprot)
1279 
    self._oprot.writeMessageEnd()
1280 
    self._oprot.trans.flush()
1281 
 
1282 
  def recv_getItem(self, ):
1283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1284 
    if mtype == TMessageType.EXCEPTION:
1285 
      x = TApplicationException()
1286 
      x.read(self._iprot)
1287 
      self._iprot.readMessageEnd()
1288 
      raise x
1289 
    result = getItem_result()
1290 
    result.read(self._iprot)
1291 
    self._iprot.readMessageEnd()
1292 
    if result.success is not None:
1293 
      return result.success
1294 
    if result.cex is not None:
1295 
      raise result.cex
1296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1297 
 
1298 
  def getItemsByCatalogId(self, catalog_item_id):
1299 
    """
1300 
    Parameters:
1301 
     - catalog_item_id
1302 
    """
1303 
    self.send_getItemsByCatalogId(catalog_item_id)
1304 
    return self.recv_getItemsByCatalogId()
1305 
 
1306 
  def send_getItemsByCatalogId(self, catalog_item_id):
1307 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1308 
    args = getItemsByCatalogId_args()
1309 
    args.catalog_item_id = catalog_item_id
1310 
    args.write(self._oprot)
1311 
    self._oprot.writeMessageEnd()
1312 
    self._oprot.trans.flush()
1313 
 
1314 
  def recv_getItemsByCatalogId(self, ):
1315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1316 
    if mtype == TMessageType.EXCEPTION:
1317 
      x = TApplicationException()
1318 
      x.read(self._iprot)
1319 
      self._iprot.readMessageEnd()
1320 
      raise x
1321 
    result = getItemsByCatalogId_result()
1322 
    result.read(self._iprot)
1323 
    self._iprot.readMessageEnd()
1324 
    if result.success is not None:
1325 
      return result.success
1326 
    if result.cex is not None:
1327 
      raise result.cex
1328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1329 
 
1330 
  def getValidItemsByCatalogId(self, catalog_item_id):
1331 
    """
1332 
    Parameters:
1333 
     - catalog_item_id
1334 
    """
1335 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1336 
    return self.recv_getValidItemsByCatalogId()
1337 
 
1338 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1339 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1340 
    args = getValidItemsByCatalogId_args()
1341 
    args.catalog_item_id = catalog_item_id
1342 
    args.write(self._oprot)
1343 
    self._oprot.writeMessageEnd()
1344 
    self._oprot.trans.flush()
1345 
 
1346 
  def recv_getValidItemsByCatalogId(self, ):
1347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1348 
    if mtype == TMessageType.EXCEPTION:
1349 
      x = TApplicationException()
1350 
      x.read(self._iprot)
1351 
      self._iprot.readMessageEnd()
1352 
      raise x
1353 
    result = getValidItemsByCatalogId_result()
1354 
    result.read(self._iprot)
1355 
    self._iprot.readMessageEnd()
1356 
    if result.success is not None:
1357 
      return result.success
1358 
    if result.cex is not None:
1359 
      raise result.cex
1360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1361 
 
1362 
  def getAllItems(self, isActive):
1363 
    """
1364 
    Parameters:
1365 
     - isActive
1366 
    """
1367 
    self.send_getAllItems(isActive)
1368 
    return self.recv_getAllItems()
1369 
 
1370 
  def send_getAllItems(self, isActive):
1371 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1372 
    args = getAllItems_args()
1373 
    args.isActive = isActive
1374 
    args.write(self._oprot)
1375 
    self._oprot.writeMessageEnd()
1376 
    self._oprot.trans.flush()
1377 
 
1378 
  def recv_getAllItems(self, ):
1379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1380 
    if mtype == TMessageType.EXCEPTION:
1381 
      x = TApplicationException()
1382 
      x.read(self._iprot)
1383 
      self._iprot.readMessageEnd()
1384 
      raise x
1385 
    result = getAllItems_result()
1386 
    result.read(self._iprot)
1387 
    self._iprot.readMessageEnd()
1388 
    if result.success is not None:
1389 
      return result.success
1390 
    if result.cex is not None:
1391 
      raise result.cex
1392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1393 
 
1394 
  def getAllItemsByStatus(self, itemStatus):
1395 
    """
1396 
    Parameters:
1397 
     - itemStatus
1398 
    """
1399 
    self.send_getAllItemsByStatus(itemStatus)
1400 
    return self.recv_getAllItemsByStatus()
1401 
 
1402 
  def send_getAllItemsByStatus(self, itemStatus):
1403 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1404 
    args = getAllItemsByStatus_args()
1405 
    args.itemStatus = itemStatus
1406 
    args.write(self._oprot)
1407 
    self._oprot.writeMessageEnd()
1408 
    self._oprot.trans.flush()
1409 
 
1410 
  def recv_getAllItemsByStatus(self, ):
1411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1412 
    if mtype == TMessageType.EXCEPTION:
1413 
      x = TApplicationException()
1414 
      x.read(self._iprot)
1415 
      self._iprot.readMessageEnd()
1416 
      raise x
1417 
    result = getAllItemsByStatus_result()
1418 
    result.read(self._iprot)
1419 
    self._iprot.readMessageEnd()
1420 
    if result.success is not None:
1421 
      return result.success
1422 
    if result.cex is not None:
1423 
      raise result.cex
1424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1425 
 
9253 rajveer 1426 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1427 
    """
1428 
    Parameters:
1429 
     - entityId
1430 
     - category
1431 
     - brand
1432 
     - modelName
1433 
     - modelNumber
9253 rajveer 1434 
     - isAndroid
5944 mandeep.dh 1435 
    """
9253 rajveer 1436 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1437 
    return self.recv_markItemAsContentComplete()
1438 
 
9253 rajveer 1439 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1440 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1441 
    args = markItemAsContentComplete_args()
1442 
    args.entityId = entityId
1443 
    args.category = category
1444 
    args.brand = brand
1445 
    args.modelName = modelName
1446 
    args.modelNumber = modelNumber
9253 rajveer 1447 
    args.isAndroid = isAndroid
5944 mandeep.dh 1448 
    args.write(self._oprot)
1449 
    self._oprot.writeMessageEnd()
1450 
    self._oprot.trans.flush()
1451 
 
1452 
  def recv_markItemAsContentComplete(self, ):
1453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1454 
    if mtype == TMessageType.EXCEPTION:
1455 
      x = TApplicationException()
1456 
      x.read(self._iprot)
1457 
      self._iprot.readMessageEnd()
1458 
      raise x
1459 
    result = markItemAsContentComplete_result()
1460 
    result.read(self._iprot)
1461 
    self._iprot.readMessageEnd()
1462 
    if result.success is not None:
1463 
      return result.success
1464 
    if result.cex is not None:
1465 
      raise result.cex
1466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1467 
 
1468 
  def getAllItemsInRange(self, offset, limit):
1469 
    """
1470 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1471 
 
1472 
    Parameters:
1473 
     - offset
1474 
     - limit
1475 
    """
1476 
    self.send_getAllItemsInRange(offset, limit)
1477 
    return self.recv_getAllItemsInRange()
1478 
 
1479 
  def send_getAllItemsInRange(self, offset, limit):
1480 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1481 
    args = getAllItemsInRange_args()
1482 
    args.offset = offset
1483 
    args.limit = limit
1484 
    args.write(self._oprot)
1485 
    self._oprot.writeMessageEnd()
1486 
    self._oprot.trans.flush()
1487 
 
1488 
  def recv_getAllItemsInRange(self, ):
1489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1490 
    if mtype == TMessageType.EXCEPTION:
1491 
      x = TApplicationException()
1492 
      x.read(self._iprot)
1493 
      self._iprot.readMessageEnd()
1494 
      raise x
1495 
    result = getAllItemsInRange_result()
1496 
    result.read(self._iprot)
1497 
    self._iprot.readMessageEnd()
1498 
    if result.success is not None:
1499 
      return result.success
1500 
    if result.cex is not None:
1501 
      raise result.cex
1502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1503 
 
1504 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1505 
    """
1506 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
1507 
 
1508 
    Parameters:
1509 
     - itemStatus
1510 
     - offset
1511 
     - limit
1512 
    """
1513 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1514 
    return self.recv_getAllItemsByStatusInRange()
1515 
 
1516 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1517 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1518 
    args = getAllItemsByStatusInRange_args()
1519 
    args.itemStatus = itemStatus
1520 
    args.offset = offset
1521 
    args.limit = limit
1522 
    args.write(self._oprot)
1523 
    self._oprot.writeMessageEnd()
1524 
    self._oprot.trans.flush()
1525 
 
1526 
  def recv_getAllItemsByStatusInRange(self, ):
1527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1528 
    if mtype == TMessageType.EXCEPTION:
1529 
      x = TApplicationException()
1530 
      x.read(self._iprot)
1531 
      self._iprot.readMessageEnd()
1532 
      raise x
1533 
    result = getAllItemsByStatusInRange_result()
1534 
    result.read(self._iprot)
1535 
    self._iprot.readMessageEnd()
1536 
    if result.success is not None:
1537 
      return result.success
1538 
    if result.cex is not None:
1539 
      raise result.cex
1540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1541 
 
1542 
  def getItemCountByStatus(self, useStatus, itemStatus):
1543 
    """
1544 
    Gets a count of all items by status
1545 
 
1546 
    Parameters:
1547 
     - useStatus
1548 
     - itemStatus
1549 
    """
1550 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1551 
    return self.recv_getItemCountByStatus()
1552 
 
1553 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1554 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1555 
    args = getItemCountByStatus_args()
1556 
    args.useStatus = useStatus
1557 
    args.itemStatus = itemStatus
1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
1562 
  def recv_getItemCountByStatus(self, ):
1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
1569 
    result = getItemCountByStatus_result()
1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
1572 
    if result.success is not None:
1573 
      return result.success
1574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1575 
 
1576 
  def getBestSellers(self, ):
1577 
    self.send_getBestSellers()
1578 
    return self.recv_getBestSellers()
1579 
 
1580 
  def send_getBestSellers(self, ):
1581 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1582 
    args = getBestSellers_args()
1583 
    args.write(self._oprot)
1584 
    self._oprot.writeMessageEnd()
1585 
    self._oprot.trans.flush()
1586 
 
1587 
  def recv_getBestSellers(self, ):
1588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1589 
    if mtype == TMessageType.EXCEPTION:
1590 
      x = TApplicationException()
1591 
      x.read(self._iprot)
1592 
      self._iprot.readMessageEnd()
1593 
      raise x
1594 
    result = getBestSellers_result()
1595 
    result.read(self._iprot)
1596 
    self._iprot.readMessageEnd()
1597 
    if result.success is not None:
1598 
      return result.success
1599 
    if result.isex is not None:
1600 
      raise result.isex
1601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1602 
 
1603 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1604 
    """
1605 
    Parameters:
1606 
     - beginIndex
1607 
     - totalItems
1608 
     - brand
1609 
     - category
1610 
    """
1611 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1612 
    return self.recv_getBestSellersCatalogIds()
1613 
 
1614 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1615 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1616 
    args = getBestSellersCatalogIds_args()
1617 
    args.beginIndex = beginIndex
1618 
    args.totalItems = totalItems
1619 
    args.brand = brand
1620 
    args.category = category
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_getBestSellersCatalogIds(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = getBestSellersCatalogIds_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
1635 
    if result.success is not None:
1636 
      return result.success
1637 
    if result.cex is not None:
1638 
      raise result.cex
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1640 
 
1641 
  def getBestSellersCount(self, ):
1642 
    self.send_getBestSellersCount()
1643 
    return self.recv_getBestSellersCount()
1644 
 
1645 
  def send_getBestSellersCount(self, ):
1646 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1647 
    args = getBestSellersCount_args()
1648 
    args.write(self._oprot)
1649 
    self._oprot.writeMessageEnd()
1650 
    self._oprot.trans.flush()
1651 
 
1652 
  def recv_getBestSellersCount(self, ):
1653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1654 
    if mtype == TMessageType.EXCEPTION:
1655 
      x = TApplicationException()
1656 
      x.read(self._iprot)
1657 
      self._iprot.readMessageEnd()
1658 
      raise x
1659 
    result = getBestSellersCount_result()
1660 
    result.read(self._iprot)
1661 
    self._iprot.readMessageEnd()
1662 
    if result.success is not None:
1663 
      return result.success
1664 
    if result.cex is not None:
1665 
      raise result.cex
1666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1667 
 
1668 
  def getBestDeals(self, ):
1669 
    self.send_getBestDeals()
1670 
    return self.recv_getBestDeals()
1671 
 
1672 
  def send_getBestDeals(self, ):
1673 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1674 
    args = getBestDeals_args()
1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_getBestDeals(self, ):
1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
1686 
    result = getBestDeals_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
1689 
    if result.success is not None:
1690 
      return result.success
1691 
    if result.isex is not None:
1692 
      raise result.isex
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1694 
 
1695 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1696 
    """
1697 
    Parameters:
1698 
     - beginIndex
1699 
     - totalItems
1700 
     - brand
1701 
     - category
1702 
    """
1703 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1704 
    return self.recv_getBestDealsCatalogIds()
1705 
 
1706 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1707 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1708 
    args = getBestDealsCatalogIds_args()
1709 
    args.beginIndex = beginIndex
1710 
    args.totalItems = totalItems
1711 
    args.brand = brand
1712 
    args.category = category
1713 
    args.write(self._oprot)
1714 
    self._oprot.writeMessageEnd()
1715 
    self._oprot.trans.flush()
1716 
 
1717 
  def recv_getBestDealsCatalogIds(self, ):
1718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1719 
    if mtype == TMessageType.EXCEPTION:
1720 
      x = TApplicationException()
1721 
      x.read(self._iprot)
1722 
      self._iprot.readMessageEnd()
1723 
      raise x
1724 
    result = getBestDealsCatalogIds_result()
1725 
    result.read(self._iprot)
1726 
    self._iprot.readMessageEnd()
1727 
    if result.success is not None:
1728 
      return result.success
1729 
    if result.cex is not None:
1730 
      raise result.cex
1731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1732 
 
1733 
  def getBestDealsCount(self, ):
1734 
    self.send_getBestDealsCount()
1735 
    return self.recv_getBestDealsCount()
1736 
 
1737 
  def send_getBestDealsCount(self, ):
1738 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1739 
    args = getBestDealsCount_args()
1740 
    args.write(self._oprot)
1741 
    self._oprot.writeMessageEnd()
1742 
    self._oprot.trans.flush()
1743 
 
1744 
  def recv_getBestDealsCount(self, ):
1745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1746 
    if mtype == TMessageType.EXCEPTION:
1747 
      x = TApplicationException()
1748 
      x.read(self._iprot)
1749 
      self._iprot.readMessageEnd()
1750 
      raise x
1751 
    result = getBestDealsCount_result()
1752 
    result.read(self._iprot)
1753 
    self._iprot.readMessageEnd()
1754 
    if result.success is not None:
1755 
      return result.success
1756 
    if result.cex is not None:
1757 
      raise result.cex
1758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1759 
 
1760 
  def getComingSoon(self, ):
1761 
    self.send_getComingSoon()
1762 
    return self.recv_getComingSoon()
1763 
 
1764 
  def send_getComingSoon(self, ):
1765 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1766 
    args = getComingSoon_args()
1767 
    args.write(self._oprot)
1768 
    self._oprot.writeMessageEnd()
1769 
    self._oprot.trans.flush()
1770 
 
1771 
  def recv_getComingSoon(self, ):
1772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1773 
    if mtype == TMessageType.EXCEPTION:
1774 
      x = TApplicationException()
1775 
      x.read(self._iprot)
1776 
      self._iprot.readMessageEnd()
1777 
      raise x
1778 
    result = getComingSoon_result()
1779 
    result.read(self._iprot)
1780 
    self._iprot.readMessageEnd()
1781 
    if result.success is not None:
1782 
      return result.success
1783 
    if result.isex is not None:
1784 
      raise result.isex
1785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1786 
 
1787 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1788 
    """
1789 
    Parameters:
1790 
     - beginIndex
1791 
     - totalItems
1792 
     - brand
1793 
     - category
1794 
    """
1795 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1796 
    return self.recv_getComingSoonCatalogIds()
1797 
 
1798 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1799 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1800 
    args = getComingSoonCatalogIds_args()
1801 
    args.beginIndex = beginIndex
1802 
    args.totalItems = totalItems
1803 
    args.brand = brand
1804 
    args.category = category
1805 
    args.write(self._oprot)
1806 
    self._oprot.writeMessageEnd()
1807 
    self._oprot.trans.flush()
1808 
 
1809 
  def recv_getComingSoonCatalogIds(self, ):
1810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1811 
    if mtype == TMessageType.EXCEPTION:
1812 
      x = TApplicationException()
1813 
      x.read(self._iprot)
1814 
      self._iprot.readMessageEnd()
1815 
      raise x
1816 
    result = getComingSoonCatalogIds_result()
1817 
    result.read(self._iprot)
1818 
    self._iprot.readMessageEnd()
1819 
    if result.success is not None:
1820 
      return result.success
1821 
    if result.cex is not None:
1822 
      raise result.cex
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1824 
 
1825 
  def getComingSoonCount(self, ):
1826 
    self.send_getComingSoonCount()
1827 
    return self.recv_getComingSoonCount()
1828 
 
1829 
  def send_getComingSoonCount(self, ):
1830 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1831 
    args = getComingSoonCount_args()
1832 
    args.write(self._oprot)
1833 
    self._oprot.writeMessageEnd()
1834 
    self._oprot.trans.flush()
1835 
 
1836 
  def recv_getComingSoonCount(self, ):
1837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1838 
    if mtype == TMessageType.EXCEPTION:
1839 
      x = TApplicationException()
1840 
      x.read(self._iprot)
1841 
      self._iprot.readMessageEnd()
1842 
      raise x
1843 
    result = getComingSoonCount_result()
1844 
    result.read(self._iprot)
1845 
    self._iprot.readMessageEnd()
1846 
    if result.success is not None:
1847 
      return result.success
1848 
    if result.cex is not None:
1849 
      raise result.cex
1850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1851 
 
1852 
  def getLatestArrivals(self, ):
1853 
    """
1854 
    Returns a list of items sorted in the descending order by start date.
1855 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1856 
    """
1857 
    self.send_getLatestArrivals()
1858 
    return self.recv_getLatestArrivals()
1859 
 
1860 
  def send_getLatestArrivals(self, ):
1861 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1862 
    args = getLatestArrivals_args()
1863 
    args.write(self._oprot)
1864 
    self._oprot.writeMessageEnd()
1865 
    self._oprot.trans.flush()
1866 
 
1867 
  def recv_getLatestArrivals(self, ):
1868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1869 
    if mtype == TMessageType.EXCEPTION:
1870 
      x = TApplicationException()
1871 
      x.read(self._iprot)
1872 
      self._iprot.readMessageEnd()
1873 
      raise x
1874 
    result = getLatestArrivals_result()
1875 
    result.read(self._iprot)
1876 
    self._iprot.readMessageEnd()
1877 
    if result.success is not None:
1878 
      return result.success
1879 
    if result.isex is not None:
1880 
      raise result.isex
1881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1882 
 
1883 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1884 
    """
1885 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1886 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1887 
 
1888 
    Parameters:
1889 
     - beginIndex
1890 
     - totalItems
1891 
     - brand
1892 
     - categories
1893 
    """
1894 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1895 
    return self.recv_getLatestArrivalsCatalogIds()
1896 
 
1897 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1898 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1899 
    args = getLatestArrivalsCatalogIds_args()
1900 
    args.beginIndex = beginIndex
1901 
    args.totalItems = totalItems
1902 
    args.brand = brand
1903 
    args.categories = categories
1904 
    args.write(self._oprot)
1905 
    self._oprot.writeMessageEnd()
1906 
    self._oprot.trans.flush()
1907 
 
1908 
  def recv_getLatestArrivalsCatalogIds(self, ):
1909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1910 
    if mtype == TMessageType.EXCEPTION:
1911 
      x = TApplicationException()
1912 
      x.read(self._iprot)
1913 
      self._iprot.readMessageEnd()
1914 
      raise x
1915 
    result = getLatestArrivalsCatalogIds_result()
1916 
    result.read(self._iprot)
1917 
    self._iprot.readMessageEnd()
1918 
    if result.success is not None:
1919 
      return result.success
1920 
    if result.cex is not None:
1921 
      raise result.cex
1922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1923 
 
1924 
  def getLatestArrivalsCount(self, ):
1925 
    """
1926 
    Get the total number of latest arrivals we are willing to show.
1927 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1928 
    """
1929 
    self.send_getLatestArrivalsCount()
1930 
    return self.recv_getLatestArrivalsCount()
1931 
 
1932 
  def send_getLatestArrivalsCount(self, ):
1933 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1934 
    args = getLatestArrivalsCount_args()
1935 
    args.write(self._oprot)
1936 
    self._oprot.writeMessageEnd()
1937 
    self._oprot.trans.flush()
1938 
 
1939 
  def recv_getLatestArrivalsCount(self, ):
1940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1941 
    if mtype == TMessageType.EXCEPTION:
1942 
      x = TApplicationException()
1943 
      x.read(self._iprot)
1944 
      self._iprot.readMessageEnd()
1945 
      raise x
1946 
    result = getLatestArrivalsCount_result()
1947 
    result.read(self._iprot)
1948 
    self._iprot.readMessageEnd()
1949 
    if result.success is not None:
1950 
      return result.success
1951 
    if result.cex is not None:
1952 
      raise result.cex
1953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1954 
 
1955 
  def generateNewEntityID(self, ):
1956 
    self.send_generateNewEntityID()
1957 
    return self.recv_generateNewEntityID()
1958 
 
1959 
  def send_generateNewEntityID(self, ):
1960 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1961 
    args = generateNewEntityID_args()
1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
1966 
  def recv_generateNewEntityID(self, ):
1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
1973 
    result = generateNewEntityID_result()
1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
1976 
    if result.success is not None:
1977 
      return result.success
1978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1979 
 
1980 
  def addCategory(self, category):
1981 
    """
1982 
    All category related functions
1983 
 
1984 
    Parameters:
1985 
     - category
1986 
    """
1987 
    self.send_addCategory(category)
1988 
    return self.recv_addCategory()
1989 
 
1990 
  def send_addCategory(self, category):
1991 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1992 
    args = addCategory_args()
1993 
    args.category = category
1994 
    args.write(self._oprot)
1995 
    self._oprot.writeMessageEnd()
1996 
    self._oprot.trans.flush()
1997 
 
1998 
  def recv_addCategory(self, ):
1999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2000 
    if mtype == TMessageType.EXCEPTION:
2001 
      x = TApplicationException()
2002 
      x.read(self._iprot)
2003 
      self._iprot.readMessageEnd()
2004 
      raise x
2005 
    result = addCategory_result()
2006 
    result.read(self._iprot)
2007 
    self._iprot.readMessageEnd()
2008 
    if result.success is not None:
2009 
      return result.success
2010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
2011 
 
2012 
  def getCategory(self, id):
2013 
    """
2014 
    Parameters:
2015 
     - id
2016 
    """
2017 
    self.send_getCategory(id)
2018 
    return self.recv_getCategory()
2019 
 
2020 
  def send_getCategory(self, id):
2021 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
2022 
    args = getCategory_args()
2023 
    args.id = id
2024 
    args.write(self._oprot)
2025 
    self._oprot.writeMessageEnd()
2026 
    self._oprot.trans.flush()
2027 
 
2028 
  def recv_getCategory(self, ):
2029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2030 
    if mtype == TMessageType.EXCEPTION:
2031 
      x = TApplicationException()
2032 
      x.read(self._iprot)
2033 
      self._iprot.readMessageEnd()
2034 
      raise x
2035 
    result = getCategory_result()
2036 
    result.read(self._iprot)
2037 
    self._iprot.readMessageEnd()
2038 
    if result.success is not None:
2039 
      return result.success
2040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2041 
 
2042 
  def getAllCategories(self, ):
2043 
    self.send_getAllCategories()
2044 
    return self.recv_getAllCategories()
2045 
 
2046 
  def send_getAllCategories(self, ):
2047 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2048 
    args = getAllCategories_args()
2049 
    args.write(self._oprot)
2050 
    self._oprot.writeMessageEnd()
2051 
    self._oprot.trans.flush()
2052 
 
2053 
  def recv_getAllCategories(self, ):
2054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2055 
    if mtype == TMessageType.EXCEPTION:
2056 
      x = TApplicationException()
2057 
      x.read(self._iprot)
2058 
      self._iprot.readMessageEnd()
2059 
      raise x
2060 
    result = getAllCategories_result()
2061 
    result.read(self._iprot)
2062 
    self._iprot.readMessageEnd()
2063 
    if result.success is not None:
2064 
      return result.success
2065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2066 
 
2067 
  def getAllSimilarItems(self, itemId):
2068 
    """
2069 
    Returns the list of similar items.
2070 
 
2071 
    Parameters:
2072 
     - itemId
2073 
    """
2074 
    self.send_getAllSimilarItems(itemId)
2075 
    return self.recv_getAllSimilarItems()
2076 
 
2077 
  def send_getAllSimilarItems(self, itemId):
2078 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2079 
    args = getAllSimilarItems_args()
2080 
    args.itemId = itemId
2081 
    args.write(self._oprot)
2082 
    self._oprot.writeMessageEnd()
2083 
    self._oprot.trans.flush()
2084 
 
2085 
  def recv_getAllSimilarItems(self, ):
2086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2087 
    if mtype == TMessageType.EXCEPTION:
2088 
      x = TApplicationException()
2089 
      x.read(self._iprot)
2090 
      self._iprot.readMessageEnd()
2091 
      raise x
2092 
    result = getAllSimilarItems_result()
2093 
    result.read(self._iprot)
2094 
    self._iprot.readMessageEnd()
2095 
    if result.success is not None:
2096 
      return result.success
2097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2098 
 
2099 
  def addSimilarItem(self, itemId, catalogItemId):
2100 
    """
2101 
    Adds similar item.
2102 
 
2103 
    Parameters:
2104 
     - itemId
2105 
     - catalogItemId
2106 
    """
2107 
    self.send_addSimilarItem(itemId, catalogItemId)
2108 
    return self.recv_addSimilarItem()
2109 
 
2110 
  def send_addSimilarItem(self, itemId, catalogItemId):
2111 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2112 
    args = addSimilarItem_args()
2113 
    args.itemId = itemId
2114 
    args.catalogItemId = catalogItemId
2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
2119 
  def recv_addSimilarItem(self, ):
2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
2126 
    result = addSimilarItem_result()
2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
2129 
    if result.success is not None:
2130 
      return result.success
2131 
    if result.cex is not None:
2132 
      raise result.cex
2133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2134 
 
6512 kshitij.so 2135 
  def addTag(self, displayName, itemId):
2136 
    """
2137 
    Tag Related
2138 
 
2139 
    Parameters:
2140 
     - displayName
2141 
     - itemId
2142 
    """
2143 
    self.send_addTag(displayName, itemId)
2144 
    return self.recv_addTag()
2145 
 
2146 
  def send_addTag(self, displayName, itemId):
2147 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2148 
    args = addTag_args()
2149 
    args.displayName = displayName
2150 
    args.itemId = itemId
2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
2155 
  def recv_addTag(self, ):
2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
2162 
    result = addTag_result()
2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
2165 
    if result.success is not None:
2166 
      return result.success
2167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2168 
 
2169 
  def deleteEntityTag(self, displayName, itemId):
2170 
    """
2171 
    Parameters:
2172 
     - displayName
2173 
     - itemId
2174 
    """
2175 
    self.send_deleteEntityTag(displayName, itemId)
2176 
    return self.recv_deleteEntityTag()
2177 
 
2178 
  def send_deleteEntityTag(self, displayName, itemId):
2179 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2180 
    args = deleteEntityTag_args()
2181 
    args.displayName = displayName
2182 
    args.itemId = itemId
2183 
    args.write(self._oprot)
2184 
    self._oprot.writeMessageEnd()
2185 
    self._oprot.trans.flush()
2186 
 
2187 
  def recv_deleteEntityTag(self, ):
2188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2189 
    if mtype == TMessageType.EXCEPTION:
2190 
      x = TApplicationException()
2191 
      x.read(self._iprot)
2192 
      self._iprot.readMessageEnd()
2193 
      raise x
2194 
    result = deleteEntityTag_result()
2195 
    result.read(self._iprot)
2196 
    self._iprot.readMessageEnd()
2197 
    if result.success is not None:
2198 
      return result.success
2199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2200 
 
2201 
  def deleteTag(self, displayName):
2202 
    """
2203 
    Parameters:
2204 
     - displayName
2205 
    """
2206 
    self.send_deleteTag(displayName)
2207 
    return self.recv_deleteTag()
2208 
 
2209 
  def send_deleteTag(self, displayName):
2210 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2211 
    args = deleteTag_args()
2212 
    args.displayName = displayName
2213 
    args.write(self._oprot)
2214 
    self._oprot.writeMessageEnd()
2215 
    self._oprot.trans.flush()
2216 
 
2217 
  def recv_deleteTag(self, ):
2218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2219 
    if mtype == TMessageType.EXCEPTION:
2220 
      x = TApplicationException()
2221 
      x.read(self._iprot)
2222 
      self._iprot.readMessageEnd()
2223 
      raise x
2224 
    result = deleteTag_result()
2225 
    result.read(self._iprot)
2226 
    self._iprot.readMessageEnd()
2227 
    if result.success is not None:
2228 
      return result.success
2229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2230 
 
2231 
  def getAllTags(self, ):
2232 
    self.send_getAllTags()
2233 
    return self.recv_getAllTags()
2234 
 
2235 
  def send_getAllTags(self, ):
2236 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2237 
    args = getAllTags_args()
2238 
    args.write(self._oprot)
2239 
    self._oprot.writeMessageEnd()
2240 
    self._oprot.trans.flush()
2241 
 
2242 
  def recv_getAllTags(self, ):
2243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2244 
    if mtype == TMessageType.EXCEPTION:
2245 
      x = TApplicationException()
2246 
      x.read(self._iprot)
2247 
      self._iprot.readMessageEnd()
2248 
      raise x
2249 
    result = getAllTags_result()
2250 
    result.read(self._iprot)
2251 
    self._iprot.readMessageEnd()
2252 
    if result.success is not None:
2253 
      return result.success
2254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2255 
 
2256 
  def getAllEntitiesByTagName(self, displayName):
2257 
    """
2258 
    Parameters:
2259 
     - displayName
2260 
    """
2261 
    self.send_getAllEntitiesByTagName(displayName)
2262 
    return self.recv_getAllEntitiesByTagName()
2263 
 
2264 
  def send_getAllEntitiesByTagName(self, displayName):
2265 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2266 
    args = getAllEntitiesByTagName_args()
2267 
    args.displayName = displayName
2268 
    args.write(self._oprot)
2269 
    self._oprot.writeMessageEnd()
2270 
    self._oprot.trans.flush()
2271 
 
2272 
  def recv_getAllEntitiesByTagName(self, ):
2273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2274 
    if mtype == TMessageType.EXCEPTION:
2275 
      x = TApplicationException()
2276 
      x.read(self._iprot)
2277 
      self._iprot.readMessageEnd()
2278 
      raise x
2279 
    result = getAllEntitiesByTagName_result()
2280 
    result.read(self._iprot)
2281 
    self._iprot.readMessageEnd()
2282 
    if result.success is not None:
2283 
      return result.success
2284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2285 
 
6845 amit.gupta 2286 
  def getAllEntityTags(self, ):
2287 
    self.send_getAllEntityTags()
2288 
    return self.recv_getAllEntityTags()
2289 
 
2290 
  def send_getAllEntityTags(self, ):
2291 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2292 
    args = getAllEntityTags_args()
2293 
    args.write(self._oprot)
2294 
    self._oprot.writeMessageEnd()
2295 
    self._oprot.trans.flush()
2296 
 
2297 
  def recv_getAllEntityTags(self, ):
2298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2299 
    if mtype == TMessageType.EXCEPTION:
2300 
      x = TApplicationException()
2301 
      x.read(self._iprot)
2302 
      self._iprot.readMessageEnd()
2303 
      raise x
2304 
    result = getAllEntityTags_result()
2305 
    result.read(self._iprot)
2306 
    self._iprot.readMessageEnd()
2307 
    if result.success is not None:
2308 
      return result.success
2309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2310 
 
8590 kshitij.so 2311 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2312 
    """
8579 kshitij.so 2313 
    Banner Related
2314 
 
6850 kshitij.so 2315 
    Parameters:
8590 kshitij.so 2316 
     - bannerCongregate
6850 kshitij.so 2317 
    """
8590 kshitij.so 2318 
    self.send_addBanner(bannerCongregate)
2319 
    self.recv_addBanner()
6850 kshitij.so 2320 
 
8590 kshitij.so 2321 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2322 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2323 
    args = addBanner_args()
8590 kshitij.so 2324 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2325 
    args.write(self._oprot)
2326 
    self._oprot.writeMessageEnd()
2327 
    self._oprot.trans.flush()
2328 
 
2329 
  def recv_addBanner(self, ):
2330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2331 
    if mtype == TMessageType.EXCEPTION:
2332 
      x = TApplicationException()
2333 
      x.read(self._iprot)
2334 
      self._iprot.readMessageEnd()
2335 
      raise x
2336 
    result = addBanner_result()
2337 
    result.read(self._iprot)
2338 
    self._iprot.readMessageEnd()
8590 kshitij.so 2339 
    return
6850 kshitij.so 2340 
 
8579 kshitij.so 2341 
  def updateBanner(self, banner):
2342 
    """
2343 
    Parameters:
2344 
     - banner
2345 
    """
2346 
    self.send_updateBanner(banner)
2347 
    return self.recv_updateBanner()
2348 
 
2349 
  def send_updateBanner(self, banner):
2350 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2351 
    args = updateBanner_args()
2352 
    args.banner = banner
2353 
    args.write(self._oprot)
2354 
    self._oprot.writeMessageEnd()
2355 
    self._oprot.trans.flush()
2356 
 
2357 
  def recv_updateBanner(self, ):
2358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2359 
    if mtype == TMessageType.EXCEPTION:
2360 
      x = TApplicationException()
2361 
      x.read(self._iprot)
2362 
      self._iprot.readMessageEnd()
2363 
      raise x
2364 
    result = updateBanner_result()
2365 
    result.read(self._iprot)
2366 
    self._iprot.readMessageEnd()
2367 
    if result.success is not None:
2368 
      return result.success
2369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2370 
 
6850 kshitij.so 2371 
  def getAllBanners(self, ):
2372 
    self.send_getAllBanners()
2373 
    return self.recv_getAllBanners()
2374 
 
2375 
  def send_getAllBanners(self, ):
2376 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2377 
    args = getAllBanners_args()
2378 
    args.write(self._oprot)
2379 
    self._oprot.writeMessageEnd()
2380 
    self._oprot.trans.flush()
2381 
 
2382 
  def recv_getAllBanners(self, ):
2383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2384 
    if mtype == TMessageType.EXCEPTION:
2385 
      x = TApplicationException()
2386 
      x.read(self._iprot)
2387 
      self._iprot.readMessageEnd()
2388 
      raise x
2389 
    result = getAllBanners_result()
2390 
    result.read(self._iprot)
2391 
    self._iprot.readMessageEnd()
2392 
    if result.success is not None:
2393 
      return result.success
2394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2395 
 
9155 kshitij.so 2396 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2397 
    """
2398 
    Parameters:
2399 
     - bannerName
9155 kshitij.so 2400 
     - bannerType
6850 kshitij.so 2401 
    """
9155 kshitij.so 2402 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2403 
    return self.recv_deleteBanner()
2404 
 
9155 kshitij.so 2405 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2406 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2407 
    args = deleteBanner_args()
2408 
    args.bannerName = bannerName
9155 kshitij.so 2409 
    args.bannerType = bannerType
6850 kshitij.so 2410 
    args.write(self._oprot)
2411 
    self._oprot.writeMessageEnd()
2412 
    self._oprot.trans.flush()
2413 
 
2414 
  def recv_deleteBanner(self, ):
2415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2416 
    if mtype == TMessageType.EXCEPTION:
2417 
      x = TApplicationException()
2418 
      x.read(self._iprot)
2419 
      self._iprot.readMessageEnd()
2420 
      raise x
2421 
    result = deleteBanner_result()
2422 
    result.read(self._iprot)
2423 
    self._iprot.readMessageEnd()
2424 
    if result.success is not None:
2425 
      return result.success
2426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2427 
 
9155 kshitij.so 2428 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2429 
    """
2430 
    Parameters:
2431 
     - bannerName
9155 kshitij.so 2432 
     - bannerType
6850 kshitij.so 2433 
    """
9155 kshitij.so 2434 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2435 
    return self.recv_getBannerDetails()
2436 
 
9155 kshitij.so 2437 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2438 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2439 
    args = getBannerDetails_args()
2440 
    args.bannerName = bannerName
9155 kshitij.so 2441 
    args.bannerType = bannerType
6850 kshitij.so 2442 
    args.write(self._oprot)
2443 
    self._oprot.writeMessageEnd()
2444 
    self._oprot.trans.flush()
2445 
 
2446 
  def recv_getBannerDetails(self, ):
2447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2448 
    if mtype == TMessageType.EXCEPTION:
2449 
      x = TApplicationException()
2450 
      x.read(self._iprot)
2451 
      self._iprot.readMessageEnd()
2452 
      raise x
2453 
    result = getBannerDetails_result()
2454 
    result.read(self._iprot)
2455 
    self._iprot.readMessageEnd()
2456 
    if result.success is not None:
2457 
      return result.success
2458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2459 
 
2460 
  def getActiveBanners(self, ):
2461 
    self.send_getActiveBanners()
2462 
    return self.recv_getActiveBanners()
2463 
 
2464 
  def send_getActiveBanners(self, ):
2465 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2466 
    args = getActiveBanners_args()
2467 
    args.write(self._oprot)
2468 
    self._oprot.writeMessageEnd()
2469 
    self._oprot.trans.flush()
2470 
 
2471 
  def recv_getActiveBanners(self, ):
2472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2473 
    if mtype == TMessageType.EXCEPTION:
2474 
      x = TApplicationException()
2475 
      x.read(self._iprot)
2476 
      self._iprot.readMessageEnd()
2477 
      raise x
2478 
    result = getActiveBanners_result()
2479 
    result.read(self._iprot)
2480 
    self._iprot.readMessageEnd()
2481 
    if result.success is not None:
2482 
      return result.success
2483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2484 
 
8579 kshitij.so 2485 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2486 
    """
2487 
    Parameters:
8579 kshitij.so 2488 
     - bannerMaps
6849 kshitij.so 2489 
    """
8579 kshitij.so 2490 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2491 
    return self.recv_addBannerMap()
2492 
 
8579 kshitij.so 2493 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2494 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2495 
    args = addBannerMap_args()
8579 kshitij.so 2496 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
2501 
  def recv_addBannerMap(self, ):
2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
2508 
    result = addBannerMap_result()
2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
2511 
    if result.success is not None:
2512 
      return result.success
2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2514 
 
8579 kshitij.so 2515 
  def updateBannerMap(self, bannerMap):
2516 
    """
2517 
    Parameters:
2518 
     - bannerMap
2519 
    """
2520 
    self.send_updateBannerMap(bannerMap)
2521 
    return self.recv_updateBannerMap()
2522 
 
2523 
  def send_updateBannerMap(self, bannerMap):
2524 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2525 
    args = updateBannerMap_args()
2526 
    args.bannerMap = bannerMap
2527 
    args.write(self._oprot)
2528 
    self._oprot.writeMessageEnd()
2529 
    self._oprot.trans.flush()
2530 
 
2531 
  def recv_updateBannerMap(self, ):
2532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2533 
    if mtype == TMessageType.EXCEPTION:
2534 
      x = TApplicationException()
2535 
      x.read(self._iprot)
2536 
      self._iprot.readMessageEnd()
2537 
      raise x
2538 
    result = updateBannerMap_result()
2539 
    result.read(self._iprot)
2540 
    self._iprot.readMessageEnd()
2541 
    if result.success is not None:
2542 
      return result.success
2543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2544 
 
6849 kshitij.so 2545 
  def deleteBannerMap(self, bannerName):
2546 
    """
2547 
    Parameters:
2548 
     - bannerName
2549 
    """
2550 
    self.send_deleteBannerMap(bannerName)
2551 
    return self.recv_deleteBannerMap()
2552 
 
2553 
  def send_deleteBannerMap(self, bannerName):
2554 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2555 
    args = deleteBannerMap_args()
2556 
    args.bannerName = bannerName
2557 
    args.write(self._oprot)
2558 
    self._oprot.writeMessageEnd()
2559 
    self._oprot.trans.flush()
2560 
 
2561 
  def recv_deleteBannerMap(self, ):
2562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2563 
    if mtype == TMessageType.EXCEPTION:
2564 
      x = TApplicationException()
2565 
      x.read(self._iprot)
2566 
      self._iprot.readMessageEnd()
2567 
      raise x
2568 
    result = deleteBannerMap_result()
2569 
    result.read(self._iprot)
2570 
    self._iprot.readMessageEnd()
2571 
    if result.success is not None:
2572 
      return result.success
2573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2574 
 
9155 kshitij.so 2575 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2576 
    """
2577 
    Parameters:
2578 
     - bannerName
9155 kshitij.so 2579 
     - bannerType
6849 kshitij.so 2580 
    """
9155 kshitij.so 2581 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2582 
    return self.recv_getBannerMapDetails()
2583 
 
9155 kshitij.so 2584 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2585 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2586 
    args = getBannerMapDetails_args()
2587 
    args.bannerName = bannerName
9155 kshitij.so 2588 
    args.bannerType = bannerType
6849 kshitij.so 2589 
    args.write(self._oprot)
2590 
    self._oprot.writeMessageEnd()
2591 
    self._oprot.trans.flush()
2592 
 
2593 
  def recv_getBannerMapDetails(self, ):
2594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2595 
    if mtype == TMessageType.EXCEPTION:
2596 
      x = TApplicationException()
2597 
      x.read(self._iprot)
2598 
      self._iprot.readMessageEnd()
2599 
      raise x
2600 
    result = getBannerMapDetails_result()
2601 
    result.read(self._iprot)
2602 
    self._iprot.readMessageEnd()
2603 
    if result.success is not None:
2604 
      return result.success
2605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2606 
 
8579 kshitij.so 2607 
  def addBannerUri(self, bannerUriMappings):
2608 
    """
2609 
    Parameters:
2610 
     - bannerUriMappings
2611 
    """
2612 
    self.send_addBannerUri(bannerUriMappings)
2613 
    self.recv_addBannerUri()
2614 
 
2615 
  def send_addBannerUri(self, bannerUriMappings):
2616 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2617 
    args = addBannerUri_args()
2618 
    args.bannerUriMappings = bannerUriMappings
2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2623 
  def recv_addBannerUri(self, ):
2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2630 
    result = addBannerUri_result()
2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
2633 
    return
2634 
 
9155 kshitij.so 2635 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2636 
    """
2637 
    Parameters:
2638 
     - bannerName
9155 kshitij.so 2639 
     - bannerType
8579 kshitij.so 2640 
    """
9155 kshitij.so 2641 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2642 
    return self.recv_getUriMapping()
2643 
 
9155 kshitij.so 2644 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2645 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2646 
    args = getUriMapping_args()
2647 
    args.bannerName = bannerName
9155 kshitij.so 2648 
    args.bannerType = bannerType
8579 kshitij.so 2649 
    args.write(self._oprot)
2650 
    self._oprot.writeMessageEnd()
2651 
    self._oprot.trans.flush()
2652 
 
2653 
  def recv_getUriMapping(self, ):
2654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2655 
    if mtype == TMessageType.EXCEPTION:
2656 
      x = TApplicationException()
2657 
      x.read(self._iprot)
2658 
      self._iprot.readMessageEnd()
2659 
      raise x
2660 
    result = getUriMapping_result()
2661 
    result.read(self._iprot)
2662 
    self._iprot.readMessageEnd()
2663 
    if result.success is not None:
2664 
      return result.success
2665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2666 
 
2667 
  def addCampaign(self, campaign):
2668 
    """
2669 
    Parameters:
2670 
     - campaign
2671 
    """
2672 
    self.send_addCampaign(campaign)
2673 
    self.recv_addCampaign()
2674 
 
2675 
  def send_addCampaign(self, campaign):
2676 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2677 
    args = addCampaign_args()
2678 
    args.campaign = campaign
2679 
    args.write(self._oprot)
2680 
    self._oprot.writeMessageEnd()
2681 
    self._oprot.trans.flush()
2682 
 
2683 
  def recv_addCampaign(self, ):
2684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2685 
    if mtype == TMessageType.EXCEPTION:
2686 
      x = TApplicationException()
2687 
      x.read(self._iprot)
2688 
      self._iprot.readMessageEnd()
2689 
      raise x
2690 
    result = addCampaign_result()
2691 
    result.read(self._iprot)
2692 
    self._iprot.readMessageEnd()
2693 
    return
2694 
 
2695 
  def getCampaigns(self, campaignName):
2696 
    """
2697 
    Parameters:
2698 
     - campaignName
2699 
    """
2700 
    self.send_getCampaigns(campaignName)
2701 
    return self.recv_getCampaigns()
2702 
 
2703 
  def send_getCampaigns(self, campaignName):
2704 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2705 
    args = getCampaigns_args()
2706 
    args.campaignName = campaignName
2707 
    args.write(self._oprot)
2708 
    self._oprot.writeMessageEnd()
2709 
    self._oprot.trans.flush()
2710 
 
2711 
  def recv_getCampaigns(self, ):
2712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2713 
    if mtype == TMessageType.EXCEPTION:
2714 
      x = TApplicationException()
2715 
      x.read(self._iprot)
2716 
      self._iprot.readMessageEnd()
2717 
      raise x
2718 
    result = getCampaigns_result()
2719 
    result.read(self._iprot)
2720 
    self._iprot.readMessageEnd()
2721 
    if result.success is not None:
2722 
      return result.success
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2724 
 
2725 
  def deleteCampaign(self, campaignId):
2726 
    """
2727 
    Parameters:
2728 
     - campaignId
2729 
    """
2730 
    self.send_deleteCampaign(campaignId)
2731 
    self.recv_deleteCampaign()
2732 
 
2733 
  def send_deleteCampaign(self, campaignId):
2734 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2735 
    args = deleteCampaign_args()
2736 
    args.campaignId = campaignId
2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
2741 
  def recv_deleteCampaign(self, ):
2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
2748 
    result = deleteCampaign_result()
2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
2751 
    return
2752 
 
2753 
  def getAllCampaigns(self, ):
2754 
    self.send_getAllCampaigns()
2755 
    return self.recv_getAllCampaigns()
2756 
 
2757 
  def send_getAllCampaigns(self, ):
2758 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2759 
    args = getAllCampaigns_args()
2760 
    args.write(self._oprot)
2761 
    self._oprot.writeMessageEnd()
2762 
    self._oprot.trans.flush()
2763 
 
2764 
  def recv_getAllCampaigns(self, ):
2765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2766 
    if mtype == TMessageType.EXCEPTION:
2767 
      x = TApplicationException()
2768 
      x.read(self._iprot)
2769 
      self._iprot.readMessageEnd()
2770 
      raise x
2771 
    result = getAllCampaigns_result()
2772 
    result.read(self._iprot)
2773 
    self._iprot.readMessageEnd()
2774 
    if result.success is not None:
2775 
      return result.success
2776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2777 
 
9155 kshitij.so 2778 
  def getActiveBannersForMobileSite(self, ):
2779 
    self.send_getActiveBannersForMobileSite()
2780 
    return self.recv_getActiveBannersForMobileSite()
2781 
 
2782 
  def send_getActiveBannersForMobileSite(self, ):
2783 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2784 
    args = getActiveBannersForMobileSite_args()
2785 
    args.write(self._oprot)
2786 
    self._oprot.writeMessageEnd()
2787 
    self._oprot.trans.flush()
2788 
 
2789 
  def recv_getActiveBannersForMobileSite(self, ):
2790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2791 
    if mtype == TMessageType.EXCEPTION:
2792 
      x = TApplicationException()
2793 
      x.read(self._iprot)
2794 
      self._iprot.readMessageEnd()
2795 
      raise x
2796 
    result = getActiveBannersForMobileSite_result()
2797 
    result.read(self._iprot)
2798 
    self._iprot.readMessageEnd()
2799 
    if result.success is not None:
2800 
      return result.success
2801 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2802 
 
5944 mandeep.dh 2803 
  def deleteSimilarItem(self, itemId, catalogItemId):
2804 
    """
2805 
    Delete similar item.
2806 
 
2807 
    Parameters:
2808 
     - itemId
2809 
     - catalogItemId
2810 
    """
2811 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2812 
    return self.recv_deleteSimilarItem()
2813 
 
2814 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2815 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2816 
    args = deleteSimilarItem_args()
2817 
    args.itemId = itemId
2818 
    args.catalogItemId = catalogItemId
2819 
    args.write(self._oprot)
2820 
    self._oprot.writeMessageEnd()
2821 
    self._oprot.trans.flush()
2822 
 
2823 
  def recv_deleteSimilarItem(self, ):
2824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2825 
    if mtype == TMessageType.EXCEPTION:
2826 
      x = TApplicationException()
2827 
      x.read(self._iprot)
2828 
      self._iprot.readMessageEnd()
2829 
      raise x
2830 
    result = deleteSimilarItem_result()
2831 
    result.read(self._iprot)
2832 
    self._iprot.readMessageEnd()
2833 
    if result.success is not None:
2834 
      return result.success
2835 
    if result.cex is not None:
2836 
      raise result.cex
2837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2838 
 
2839 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2840 
    """
2841 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2842 
    If yes, returns the itemId else returns 0
2843 
 
2844 
    Parameters:
2845 
     - brand
2846 
     - modelNumber
2847 
     - modelName
2848 
     - color
2849 
    """
2850 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2851 
    return self.recv_checkSimilarItem()
2852 
 
2853 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2854 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2855 
    args = checkSimilarItem_args()
2856 
    args.brand = brand
2857 
    args.modelNumber = modelNumber
2858 
    args.modelName = modelName
2859 
    args.color = color
2860 
    args.write(self._oprot)
2861 
    self._oprot.writeMessageEnd()
2862 
    self._oprot.trans.flush()
2863 
 
2864 
  def recv_checkSimilarItem(self, ):
2865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2866 
    if mtype == TMessageType.EXCEPTION:
2867 
      x = TApplicationException()
2868 
      x.read(self._iprot)
2869 
      self._iprot.readMessageEnd()
2870 
      raise x
2871 
    result = checkSimilarItem_result()
2872 
    result.read(self._iprot)
2873 
    self._iprot.readMessageEnd()
2874 
    if result.success is not None:
2875 
      return result.success
2876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2877 
 
2878 
  def validateRiskyStatus(self, itemId):
2879 
    """
2880 
    Check wether item is risky and change status if inventory is not available for risky items
2881 
 
2882 
    Parameters:
2883 
     - itemId
2884 
    """
2885 
    self.send_validateRiskyStatus(itemId)
2886 
    self.recv_validateRiskyStatus()
2887 
 
2888 
  def send_validateRiskyStatus(self, itemId):
2889 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2890 
    args = validateRiskyStatus_args()
2891 
    args.itemId = itemId
2892 
    args.write(self._oprot)
2893 
    self._oprot.writeMessageEnd()
2894 
    self._oprot.trans.flush()
2895 
 
2896 
  def recv_validateRiskyStatus(self, ):
2897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2898 
    if mtype == TMessageType.EXCEPTION:
2899 
      x = TApplicationException()
2900 
      x.read(self._iprot)
2901 
      self._iprot.readMessageEnd()
2902 
      raise x
2903 
    result = validateRiskyStatus_result()
2904 
    result.read(self._iprot)
2905 
    self._iprot.readMessageEnd()
2906 
    return
2907 
 
2908 
  def changeItemRiskyFlag(self, itemId, risky):
2909 
    """
2910 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2911 
 
2912 
    Parameters:
2913 
     - itemId
2914 
     - risky
2915 
    """
2916 
    self.send_changeItemRiskyFlag(itemId, risky)
2917 
    self.recv_changeItemRiskyFlag()
2918 
 
2919 
  def send_changeItemRiskyFlag(self, itemId, risky):
2920 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2921 
    args = changeItemRiskyFlag_args()
2922 
    args.itemId = itemId
2923 
    args.risky = risky
2924 
    args.write(self._oprot)
2925 
    self._oprot.writeMessageEnd()
2926 
    self._oprot.trans.flush()
2927 
 
2928 
  def recv_changeItemRiskyFlag(self, ):
2929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2930 
    if mtype == TMessageType.EXCEPTION:
2931 
      x = TApplicationException()
2932 
      x.read(self._iprot)
2933 
      self._iprot.readMessageEnd()
2934 
      raise x
2935 
    result = changeItemRiskyFlag_result()
2936 
    result.read(self._iprot)
2937 
    self._iprot.readMessageEnd()
2938 
    return
2939 
 
2940 
  def getItemsByRiskyFlag(self, ):
2941 
    """
2942 
    Returns list of items marked as risky.
2943 
    """
2944 
    self.send_getItemsByRiskyFlag()
2945 
    return self.recv_getItemsByRiskyFlag()
2946 
 
2947 
  def send_getItemsByRiskyFlag(self, ):
2948 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2949 
    args = getItemsByRiskyFlag_args()
2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
2954 
  def recv_getItemsByRiskyFlag(self, ):
2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
2961 
    result = getItemsByRiskyFlag_result()
2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
2964 
    if result.success is not None:
2965 
      return result.success
2966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2967 
 
2968 
  def getItemsForMasterSheet(self, category, brand):
2969 
    """
2970 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2971 
 
2972 
    Parameters:
2973 
     - category
2974 
     - brand
2975 
    """
2976 
    self.send_getItemsForMasterSheet(category, brand)
2977 
    return self.recv_getItemsForMasterSheet()
2978 
 
2979 
  def send_getItemsForMasterSheet(self, category, brand):
2980 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2981 
    args = getItemsForMasterSheet_args()
2982 
    args.category = category
2983 
    args.brand = brand
2984 
    args.write(self._oprot)
2985 
    self._oprot.writeMessageEnd()
2986 
    self._oprot.trans.flush()
2987 
 
2988 
  def recv_getItemsForMasterSheet(self, ):
2989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2990 
    if mtype == TMessageType.EXCEPTION:
2991 
      x = TApplicationException()
2992 
      x.read(self._iprot)
2993 
      self._iprot.readMessageEnd()
2994 
      raise x
2995 
    result = getItemsForMasterSheet_result()
2996 
    result.read(self._iprot)
2997 
    self._iprot.readMessageEnd()
2998 
    if result.success is not None:
2999 
      return result.success
3000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
3001 
 
3002 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3003 
    """
3004 
    Returns list of catalog ids of items with same similarity index as of the given itemId
3005 
 
3006 
    Parameters:
3007 
     - beginIndex
3008 
     - totalItems
3009 
     - itemId
3010 
    """
3011 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
3012 
    return self.recv_getSimilarItemsCatalogIds()
3013 
 
3014 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
3015 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
3016 
    args = getSimilarItemsCatalogIds_args()
3017 
    args.beginIndex = beginIndex
3018 
    args.totalItems = totalItems
3019 
    args.itemId = itemId
3020 
    args.write(self._oprot)
3021 
    self._oprot.writeMessageEnd()
3022 
    self._oprot.trans.flush()
3023 
 
3024 
  def recv_getSimilarItemsCatalogIds(self, ):
3025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3026 
    if mtype == TMessageType.EXCEPTION:
3027 
      x = TApplicationException()
3028 
      x.read(self._iprot)
3029 
      self._iprot.readMessageEnd()
3030 
      raise x
3031 
    result = getSimilarItemsCatalogIds_result()
3032 
    result.read(self._iprot)
3033 
    self._iprot.readMessageEnd()
3034 
    if result.success is not None:
3035 
      return result.success
3036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
3037 
 
3038 
  def addProductNotification(self, itemId, email):
3039 
    """
3040 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3041 
 
3042 
    Parameters:
3043 
     - itemId
3044 
     - email
3045 
    """
3046 
    self.send_addProductNotification(itemId, email)
3047 
    return self.recv_addProductNotification()
3048 
 
3049 
  def send_addProductNotification(self, itemId, email):
3050 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3051 
    args = addProductNotification_args()
3052 
    args.itemId = itemId
3053 
    args.email = email
3054 
    args.write(self._oprot)
3055 
    self._oprot.writeMessageEnd()
3056 
    self._oprot.trans.flush()
3057 
 
3058 
  def recv_addProductNotification(self, ):
3059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3060 
    if mtype == TMessageType.EXCEPTION:
3061 
      x = TApplicationException()
3062 
      x.read(self._iprot)
3063 
      self._iprot.readMessageEnd()
3064 
      raise x
3065 
    result = addProductNotification_result()
3066 
    result.read(self._iprot)
3067 
    self._iprot.readMessageEnd()
3068 
    if result.success is not None:
3069 
      return result.success
3070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3071 
 
3072 
  def sendProductNotifications(self, ):
3073 
    """
3074 
    Send the product notifications to the users for items which has stock.
3075 
    """
3076 
    self.send_sendProductNotifications()
3077 
    return self.recv_sendProductNotifications()
3078 
 
3079 
  def send_sendProductNotifications(self, ):
3080 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3081 
    args = sendProductNotifications_args()
3082 
    args.write(self._oprot)
3083 
    self._oprot.writeMessageEnd()
3084 
    self._oprot.trans.flush()
3085 
 
3086 
  def recv_sendProductNotifications(self, ):
3087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3088 
    if mtype == TMessageType.EXCEPTION:
3089 
      x = TApplicationException()
3090 
      x.read(self._iprot)
3091 
      self._iprot.readMessageEnd()
3092 
      raise x
3093 
    result = sendProductNotifications_result()
3094 
    result.read(self._iprot)
3095 
    self._iprot.readMessageEnd()
3096 
    if result.success is not None:
3097 
      return result.success
3098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3099 
 
3100 
  def getAllBrandsByCategory(self, categoryId):
3101 
    """
3102 
    Returns list of brand names for a given category Id
3103 
 
3104 
    Parameters:
3105 
     - categoryId
3106 
    """
3107 
    self.send_getAllBrandsByCategory(categoryId)
3108 
    return self.recv_getAllBrandsByCategory()
3109 
 
3110 
  def send_getAllBrandsByCategory(self, categoryId):
3111 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3112 
    args = getAllBrandsByCategory_args()
3113 
    args.categoryId = categoryId
3114 
    args.write(self._oprot)
3115 
    self._oprot.writeMessageEnd()
3116 
    self._oprot.trans.flush()
3117 
 
3118 
  def recv_getAllBrandsByCategory(self, ):
3119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3120 
    if mtype == TMessageType.EXCEPTION:
3121 
      x = TApplicationException()
3122 
      x.read(self._iprot)
3123 
      self._iprot.readMessageEnd()
3124 
      raise x
3125 
    result = getAllBrandsByCategory_result()
3126 
    result.read(self._iprot)
3127 
    self._iprot.readMessageEnd()
3128 
    if result.success is not None:
3129 
      return result.success
3130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3131 
 
3132 
  def getAllBrands(self, ):
3133 
    """
3134 
    Returns list of brand names
3135 
    """
3136 
    self.send_getAllBrands()
3137 
    return self.recv_getAllBrands()
3138 
 
3139 
  def send_getAllBrands(self, ):
3140 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3141 
    args = getAllBrands_args()
3142 
    args.write(self._oprot)
3143 
    self._oprot.writeMessageEnd()
3144 
    self._oprot.trans.flush()
3145 
 
3146 
  def recv_getAllBrands(self, ):
3147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3148 
    if mtype == TMessageType.EXCEPTION:
3149 
      x = TApplicationException()
3150 
      x.read(self._iprot)
3151 
      self._iprot.readMessageEnd()
3152 
      raise x
3153 
    result = getAllBrands_result()
3154 
    result.read(self._iprot)
3155 
    self._iprot.readMessageEnd()
3156 
    if result.success is not None:
3157 
      return result.success
3158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3159 
 
3160 
  def getAllSources(self, ):
3161 
    """
3162 
    Return list of all sources
3163 
    """
3164 
    self.send_getAllSources()
3165 
    return self.recv_getAllSources()
3166 
 
3167 
  def send_getAllSources(self, ):
3168 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3169 
    args = getAllSources_args()
3170 
    args.write(self._oprot)
3171 
    self._oprot.writeMessageEnd()
3172 
    self._oprot.trans.flush()
3173 
 
3174 
  def recv_getAllSources(self, ):
3175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3176 
    if mtype == TMessageType.EXCEPTION:
3177 
      x = TApplicationException()
3178 
      x.read(self._iprot)
3179 
      self._iprot.readMessageEnd()
3180 
      raise x
3181 
    result = getAllSources_result()
3182 
    result.read(self._iprot)
3183 
    self._iprot.readMessageEnd()
3184 
    if result.success is not None:
3185 
      return result.success
3186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3187 
 
3188 
  def getItemPricingBySource(self, itemId, sourceId):
3189 
    """
3190 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3191 
 
3192 
    Parameters:
3193 
     - itemId
3194 
     - sourceId
3195 
    """
3196 
    self.send_getItemPricingBySource(itemId, sourceId)
3197 
    return self.recv_getItemPricingBySource()
3198 
 
3199 
  def send_getItemPricingBySource(self, itemId, sourceId):
3200 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3201 
    args = getItemPricingBySource_args()
3202 
    args.itemId = itemId
3203 
    args.sourceId = sourceId
3204 
    args.write(self._oprot)
3205 
    self._oprot.writeMessageEnd()
3206 
    self._oprot.trans.flush()
3207 
 
3208 
  def recv_getItemPricingBySource(self, ):
3209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3210 
    if mtype == TMessageType.EXCEPTION:
3211 
      x = TApplicationException()
3212 
      x.read(self._iprot)
3213 
      self._iprot.readMessageEnd()
3214 
      raise x
3215 
    result = getItemPricingBySource_result()
3216 
    result.read(self._iprot)
3217 
    self._iprot.readMessageEnd()
3218 
    if result.success is not None:
3219 
      return result.success
3220 
    if result.cex is not None:
3221 
      raise result.cex
3222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3223 
 
3224 
  def addSourceItemPricing(self, sourceItemPricing):
3225 
    """
3226 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3227 
    If item is not found or source is not found, it will throw exception.
3228 
 
3229 
    Parameters:
3230 
     - sourceItemPricing
3231 
    """
3232 
    self.send_addSourceItemPricing(sourceItemPricing)
3233 
    self.recv_addSourceItemPricing()
3234 
 
3235 
  def send_addSourceItemPricing(self, sourceItemPricing):
3236 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3237 
    args = addSourceItemPricing_args()
3238 
    args.sourceItemPricing = sourceItemPricing
3239 
    args.write(self._oprot)
3240 
    self._oprot.writeMessageEnd()
3241 
    self._oprot.trans.flush()
3242 
 
3243 
  def recv_addSourceItemPricing(self, ):
3244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3245 
    if mtype == TMessageType.EXCEPTION:
3246 
      x = TApplicationException()
3247 
      x.read(self._iprot)
3248 
      self._iprot.readMessageEnd()
3249 
      raise x
3250 
    result = addSourceItemPricing_result()
3251 
    result.read(self._iprot)
3252 
    self._iprot.readMessageEnd()
3253 
    if result.cex is not None:
3254 
      raise result.cex
3255 
    return
3256 
 
3257 
  def getAllSourcePricing(self, itemId):
3258 
    """
3259 
    Returns the list of source pricing information of an item.
3260 
    Raises an exception if item not found corresponding to itemId
3261 
 
3262 
    Parameters:
3263 
     - itemId
3264 
    """
3265 
    self.send_getAllSourcePricing(itemId)
3266 
    return self.recv_getAllSourcePricing()
3267 
 
3268 
  def send_getAllSourcePricing(self, itemId):
3269 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3270 
    args = getAllSourcePricing_args()
3271 
    args.itemId = itemId
3272 
    args.write(self._oprot)
3273 
    self._oprot.writeMessageEnd()
3274 
    self._oprot.trans.flush()
3275 
 
3276 
  def recv_getAllSourcePricing(self, ):
3277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3278 
    if mtype == TMessageType.EXCEPTION:
3279 
      x = TApplicationException()
3280 
      x.read(self._iprot)
3281 
      self._iprot.readMessageEnd()
3282 
      raise x
3283 
    result = getAllSourcePricing_result()
3284 
    result.read(self._iprot)
3285 
    self._iprot.readMessageEnd()
3286 
    if result.success is not None:
3287 
      return result.success
3288 
    if result.cex is not None:
3289 
      raise result.cex
3290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3291 
 
3292 
  def getItemForSource(self, item_id, sourceId):
3293 
    """
3294 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3295 
 
3296 
    Parameters:
3297 
     - item_id
3298 
     - sourceId
3299 
    """
3300 
    self.send_getItemForSource(item_id, sourceId)
3301 
    return self.recv_getItemForSource()
3302 
 
3303 
  def send_getItemForSource(self, item_id, sourceId):
3304 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3305 
    args = getItemForSource_args()
3306 
    args.item_id = item_id
3307 
    args.sourceId = sourceId
3308 
    args.write(self._oprot)
3309 
    self._oprot.writeMessageEnd()
3310 
    self._oprot.trans.flush()
3311 
 
3312 
  def recv_getItemForSource(self, ):
3313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3314 
    if mtype == TMessageType.EXCEPTION:
3315 
      x = TApplicationException()
3316 
      x.read(self._iprot)
3317 
      self._iprot.readMessageEnd()
3318 
      raise x
3319 
    result = getItemForSource_result()
3320 
    result.read(self._iprot)
3321 
    self._iprot.readMessageEnd()
3322 
    if result.success is not None:
3323 
      return result.success
3324 
    if result.cex is not None:
3325 
      raise result.cex
3326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3327 
 
3328 
  def searchItemsInRange(self, searchTerms, offset, limit):
3329 
    """
3330 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3331 
 
3332 
    Parameters:
3333 
     - searchTerms
3334 
     - offset
3335 
     - limit
3336 
    """
3337 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3338 
    return self.recv_searchItemsInRange()
3339 
 
3340 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3341 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3342 
    args = searchItemsInRange_args()
3343 
    args.searchTerms = searchTerms
3344 
    args.offset = offset
3345 
    args.limit = limit
3346 
    args.write(self._oprot)
3347 
    self._oprot.writeMessageEnd()
3348 
    self._oprot.trans.flush()
3349 
 
3350 
  def recv_searchItemsInRange(self, ):
3351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3352 
    if mtype == TMessageType.EXCEPTION:
3353 
      x = TApplicationException()
3354 
      x.read(self._iprot)
3355 
      self._iprot.readMessageEnd()
3356 
      raise x
3357 
    result = searchItemsInRange_result()
3358 
    result.read(self._iprot)
3359 
    self._iprot.readMessageEnd()
3360 
    if result.success is not None:
3361 
      return result.success
3362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3363 
 
3364 
  def getSearchResultCount(self, searchTerms):
3365 
    """
3366 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3367 
 
3368 
    Parameters:
3369 
     - searchTerms
3370 
    """
3371 
    self.send_getSearchResultCount(searchTerms)
3372 
    return self.recv_getSearchResultCount()
3373 
 
3374 
  def send_getSearchResultCount(self, searchTerms):
3375 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3376 
    args = getSearchResultCount_args()
3377 
    args.searchTerms = searchTerms
3378 
    args.write(self._oprot)
3379 
    self._oprot.writeMessageEnd()
3380 
    self._oprot.trans.flush()
3381 
 
3382 
  def recv_getSearchResultCount(self, ):
3383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3384 
    if mtype == TMessageType.EXCEPTION:
3385 
      x = TApplicationException()
3386 
      x.read(self._iprot)
3387 
      self._iprot.readMessageEnd()
3388 
      raise x
3389 
    result = getSearchResultCount_result()
3390 
    result.read(self._iprot)
3391 
    self._iprot.readMessageEnd()
3392 
    if result.success is not None:
3393 
      return result.success
3394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3395 
 
3396 
  def getProductNotifications(self, startDateTime):
3397 
    """
3398 
    Returns a list of product notifications added after a supplied datetime
3399 
 
3400 
    Parameters:
3401 
     - startDateTime
3402 
    """
3403 
    self.send_getProductNotifications(startDateTime)
3404 
    return self.recv_getProductNotifications()
3405 
 
3406 
  def send_getProductNotifications(self, startDateTime):
3407 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3408 
    args = getProductNotifications_args()
3409 
    args.startDateTime = startDateTime
3410 
    args.write(self._oprot)
3411 
    self._oprot.writeMessageEnd()
3412 
    self._oprot.trans.flush()
3413 
 
3414 
  def recv_getProductNotifications(self, ):
3415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3416 
    if mtype == TMessageType.EXCEPTION:
3417 
      x = TApplicationException()
3418 
      x.read(self._iprot)
3419 
      self._iprot.readMessageEnd()
3420 
      raise x
3421 
    result = getProductNotifications_result()
3422 
    result.read(self._iprot)
3423 
    self._iprot.readMessageEnd()
3424 
    if result.success is not None:
3425 
      return result.success
3426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3427 
 
7897 amar.kumar 3428 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3429 
    """
3430 
    Returns a list of count of requests for product notification against each item
3431 
 
3432 
    Parameters:
3433 
     - startDateTime
7897 amar.kumar 3434 
     - categoryId
5944 mandeep.dh 3435 
    """
7897 amar.kumar 3436 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3437 
    return self.recv_getProductNotificationRequestCount()
3438 
 
7897 amar.kumar 3439 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3440 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3441 
    args = getProductNotificationRequestCount_args()
3442 
    args.startDateTime = startDateTime
7897 amar.kumar 3443 
    args.categoryId = categoryId
5944 mandeep.dh 3444 
    args.write(self._oprot)
3445 
    self._oprot.writeMessageEnd()
3446 
    self._oprot.trans.flush()
3447 
 
3448 
  def recv_getProductNotificationRequestCount(self, ):
3449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3450 
    if mtype == TMessageType.EXCEPTION:
3451 
      x = TApplicationException()
3452 
      x.read(self._iprot)
3453 
      self._iprot.readMessageEnd()
3454 
      raise x
3455 
    result = getProductNotificationRequestCount_result()
3456 
    result.read(self._iprot)
3457 
    self._iprot.readMessageEnd()
3458 
    if result.success is not None:
3459 
      return result.success
3460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3461 
 
3462 
  def addAuthorizationLog(self, itemId, username, reason):
3463 
    """
3464 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3465 
 
3466 
    Parameters:
3467 
     - itemId
3468 
     - username
3469 
     - reason
3470 
    """
3471 
    self.send_addAuthorizationLog(itemId, username, reason)
3472 
    return self.recv_addAuthorizationLog()
3473 
 
3474 
  def send_addAuthorizationLog(self, itemId, username, reason):
3475 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3476 
    args = addAuthorizationLog_args()
3477 
    args.itemId = itemId
3478 
    args.username = username
3479 
    args.reason = reason
3480 
    args.write(self._oprot)
3481 
    self._oprot.writeMessageEnd()
3482 
    self._oprot.trans.flush()
3483 
 
3484 
  def recv_addAuthorizationLog(self, ):
3485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3486 
    if mtype == TMessageType.EXCEPTION:
3487 
      x = TApplicationException()
3488 
      x.read(self._iprot)
3489 
      self._iprot.readMessageEnd()
3490 
      raise x
3491 
    result = addAuthorizationLog_result()
3492 
    result.read(self._iprot)
3493 
    self._iprot.readMessageEnd()
3494 
    if result.success is not None:
3495 
      return result.success
3496 
    if result.cex is not None:
3497 
      raise result.cex
3498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3499 
 
3500 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3501 
    """
3502 
    Parameters:
3503 
     - catalog_item_id
3504 
     - voucherType
3505 
     - voucherAmount
3506 
    """
3507 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3508 
    return self.recv_addupdateVoucherForItem()
3509 
 
3510 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3511 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3512 
    args = addupdateVoucherForItem_args()
3513 
    args.catalog_item_id = catalog_item_id
3514 
    args.voucherType = voucherType
3515 
    args.voucherAmount = voucherAmount
3516 
    args.write(self._oprot)
3517 
    self._oprot.writeMessageEnd()
3518 
    self._oprot.trans.flush()
3519 
 
3520 
  def recv_addupdateVoucherForItem(self, ):
3521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3522 
    if mtype == TMessageType.EXCEPTION:
3523 
      x = TApplicationException()
3524 
      x.read(self._iprot)
3525 
      self._iprot.readMessageEnd()
3526 
      raise x
3527 
    result = addupdateVoucherForItem_result()
3528 
    result.read(self._iprot)
3529 
    self._iprot.readMessageEnd()
3530 
    if result.success is not None:
3531 
      return result.success
3532 
    if result.cex is not None:
3533 
      raise result.cex
3534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3535 
 
3536 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3537 
    """
3538 
    Parameters:
3539 
     - catalog_item_id
3540 
     - voucherType
3541 
    """
3542 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3543 
    return self.recv_deleteVoucherForItem()
3544 
 
3545 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3546 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3547 
    args = deleteVoucherForItem_args()
3548 
    args.catalog_item_id = catalog_item_id
3549 
    args.voucherType = voucherType
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_deleteVoucherForItem(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = deleteVoucherForItem_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
3564 
    if result.success is not None:
3565 
      return result.success
3566 
    if result.cex is not None:
3567 
      raise result.cex
3568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3569 
 
3570 
  def getVoucherAmount(self, itemId, voucherType):
3571 
    """
3572 
    Parameters:
3573 
     - itemId
3574 
     - voucherType
3575 
    """
3576 
    self.send_getVoucherAmount(itemId, voucherType)
3577 
    return self.recv_getVoucherAmount()
3578 
 
3579 
  def send_getVoucherAmount(self, itemId, voucherType):
3580 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3581 
    args = getVoucherAmount_args()
3582 
    args.itemId = itemId
3583 
    args.voucherType = voucherType
3584 
    args.write(self._oprot)
3585 
    self._oprot.writeMessageEnd()
3586 
    self._oprot.trans.flush()
3587 
 
3588 
  def recv_getVoucherAmount(self, ):
3589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3590 
    if mtype == TMessageType.EXCEPTION:
3591 
      x = TApplicationException()
3592 
      x.read(self._iprot)
3593 
      self._iprot.readMessageEnd()
3594 
      raise x
3595 
    result = getVoucherAmount_result()
3596 
    result.read(self._iprot)
3597 
    self._iprot.readMessageEnd()
3598 
    if result.success is not None:
3599 
      return result.success
3600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3601 
 
3602 
  def getAllItemVouchers(self, itemId):
3603 
    """
3604 
    Parameters:
3605 
     - itemId
3606 
    """
3607 
    self.send_getAllItemVouchers(itemId)
3608 
    return self.recv_getAllItemVouchers()
3609 
 
3610 
  def send_getAllItemVouchers(self, itemId):
3611 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3612 
    args = getAllItemVouchers_args()
3613 
    args.itemId = itemId
3614 
    args.write(self._oprot)
3615 
    self._oprot.writeMessageEnd()
3616 
    self._oprot.trans.flush()
3617 
 
3618 
  def recv_getAllItemVouchers(self, ):
3619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3620 
    if mtype == TMessageType.EXCEPTION:
3621 
      x = TApplicationException()
3622 
      x.read(self._iprot)
3623 
      self._iprot.readMessageEnd()
3624 
      raise x
3625 
    result = getAllItemVouchers_result()
3626 
    result.read(self._iprot)
3627 
    self._iprot.readMessageEnd()
3628 
    if result.success is not None:
3629 
      return result.success
3630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3631 
 
3632 
  def isValidCatalogItemId(self, catalog_item_id):
3633 
    """
3634 
    Parameters:
3635 
     - catalog_item_id
3636 
    """
3637 
    self.send_isValidCatalogItemId(catalog_item_id)
3638 
    return self.recv_isValidCatalogItemId()
3639 
 
3640 
  def send_isValidCatalogItemId(self, catalog_item_id):
3641 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3642 
    args = isValidCatalogItemId_args()
3643 
    args.catalog_item_id = catalog_item_id
3644 
    args.write(self._oprot)
3645 
    self._oprot.writeMessageEnd()
3646 
    self._oprot.trans.flush()
3647 
 
3648 
  def recv_isValidCatalogItemId(self, ):
3649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3650 
    if mtype == TMessageType.EXCEPTION:
3651 
      x = TApplicationException()
3652 
      x.read(self._iprot)
3653 
      self._iprot.readMessageEnd()
3654 
      raise x
3655 
    result = isValidCatalogItemId_result()
3656 
    result.read(self._iprot)
3657 
    self._iprot.readMessageEnd()
3658 
    if result.success is not None:
3659 
      return result.success
3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3661 
 
7330 amit.gupta 3662 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3663 
    """
3664 
    Parameters:
3665 
     - itemId
7330 amit.gupta 3666 
     - stateId
6039 amit.gupta 3667 
     - price
3668 
    """
7330 amit.gupta 3669 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3670 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3671 
 
7330 amit.gupta 3672 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3673 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3674 
    args = getVatPercentageForItem_args()
3675 
    args.itemId = itemId
7330 amit.gupta 3676 
    args.stateId = stateId
6039 amit.gupta 3677 
    args.price = price
3678 
    args.write(self._oprot)
3679 
    self._oprot.writeMessageEnd()
3680 
    self._oprot.trans.flush()
3681 
 
3682 
  def recv_getVatPercentageForItem(self, ):
3683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3684 
    if mtype == TMessageType.EXCEPTION:
3685 
      x = TApplicationException()
3686 
      x.read(self._iprot)
3687 
      self._iprot.readMessageEnd()
3688 
      raise x
3689 
    result = getVatPercentageForItem_result()
3690 
    result.read(self._iprot)
3691 
    self._iprot.readMessageEnd()
3692 
    if result.success is not None:
3693 
      return result.success
7340 amit.gupta 3694 
    if result.cex is not None:
3695 
      raise result.cex
6039 amit.gupta 3696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3697 
 
3698 
  def getVatAmountForItem(self, itemId, price):
3699 
    """
3700 
    Parameters:
3701 
     - itemId
3702 
     - price
3703 
    """
3704 
    self.send_getVatAmountForItem(itemId, price)
3705 
    return self.recv_getVatAmountForItem()
3706 
 
3707 
  def send_getVatAmountForItem(self, itemId, price):
3708 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3709 
    args = getVatAmountForItem_args()
3710 
    args.itemId = itemId
3711 
    args.price = price
3712 
    args.write(self._oprot)
3713 
    self._oprot.writeMessageEnd()
3714 
    self._oprot.trans.flush()
3715 
 
3716 
  def recv_getVatAmountForItem(self, ):
3717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3718 
    if mtype == TMessageType.EXCEPTION:
3719 
      x = TApplicationException()
3720 
      x.read(self._iprot)
3721 
      self._iprot.readMessageEnd()
3722 
      raise x
3723 
    result = getVatAmountForItem_result()
3724 
    result.read(self._iprot)
3725 
    self._iprot.readMessageEnd()
3726 
    if result.success is not None:
3727 
      return result.success
3728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3729 
 
6531 vikram.rag 3730 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3731 
    """
3732 
    Parameters:
3733 
     - offset
3734 
     - limit
3735 
    """
3736 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3737 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3738 
 
6531 vikram.rag 3739 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3740 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3741 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3742 
    args.offset = offset
3743 
    args.limit = limit
3744 
    args.write(self._oprot)
3745 
    self._oprot.writeMessageEnd()
3746 
    self._oprot.trans.flush()
3747 
 
3748 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3750 
    if mtype == TMessageType.EXCEPTION:
3751 
      x = TApplicationException()
3752 
      x.read(self._iprot)
3753 
      self._iprot.readMessageEnd()
3754 
      raise x
3755 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3756 
    result.read(self._iprot)
3757 
    self._iprot.readMessageEnd()
3758 
    if result.success is not None:
3759 
      return result.success
3760 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3761 
 
6821 amar.kumar 3762 
  def getAllAliveItems(self, ):
3763 
    self.send_getAllAliveItems()
3764 
    return self.recv_getAllAliveItems()
3765 
 
3766 
  def send_getAllAliveItems(self, ):
3767 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3768 
    args = getAllAliveItems_args()
3769 
    args.write(self._oprot)
3770 
    self._oprot.writeMessageEnd()
3771 
    self._oprot.trans.flush()
3772 
 
3773 
  def recv_getAllAliveItems(self, ):
3774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3775 
    if mtype == TMessageType.EXCEPTION:
3776 
      x = TApplicationException()
3777 
      x.read(self._iprot)
3778 
      self._iprot.readMessageEnd()
3779 
      raise x
3780 
    result = getAllAliveItems_result()
3781 
    result.read(self._iprot)
3782 
    self._iprot.readMessageEnd()
3783 
    if result.success is not None:
3784 
      return result.success
3785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3786 
 
6921 anupam.sin 3787 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3788 
    """
3789 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3790 
 
6805 anupam.sin 3791 
    Parameters:
3792 
     - itemId
6921 anupam.sin 3793 
     - price
6805 anupam.sin 3794 
     - insurerId
3795 
     - quantity
3796 
    """
6921 anupam.sin 3797 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3798 
    return self.recv_getInsuranceAmount()
3799 
 
6921 anupam.sin 3800 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3801 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3802 
    args = getInsuranceAmount_args()
3803 
    args.itemId = itemId
6921 anupam.sin 3804 
    args.price = price
6805 anupam.sin 3805 
    args.insurerId = insurerId
3806 
    args.quantity = quantity
3807 
    args.write(self._oprot)
3808 
    self._oprot.writeMessageEnd()
3809 
    self._oprot.trans.flush()
3810 
 
3811 
  def recv_getInsuranceAmount(self, ):
3812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3813 
    if mtype == TMessageType.EXCEPTION:
3814 
      x = TApplicationException()
3815 
      x.read(self._iprot)
3816 
      self._iprot.readMessageEnd()
3817 
      raise x
3818 
    result = getInsuranceAmount_result()
3819 
    result.read(self._iprot)
3820 
    self._iprot.readMessageEnd()
3821 
    if result.success is not None:
3822 
      return result.success
3823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3824 
 
3825 
  def getInsurer(self, insurerId):
3826 
    """
3827 
    Parameters:
3828 
     - insurerId
3829 
    """
3830 
    self.send_getInsurer(insurerId)
3831 
    return self.recv_getInsurer()
3832 
 
3833 
  def send_getInsurer(self, insurerId):
3834 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3835 
    args = getInsurer_args()
3836 
    args.insurerId = insurerId
3837 
    args.write(self._oprot)
3838 
    self._oprot.writeMessageEnd()
3839 
    self._oprot.trans.flush()
3840 
 
3841 
  def recv_getInsurer(self, ):
3842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3843 
    if mtype == TMessageType.EXCEPTION:
3844 
      x = TApplicationException()
3845 
      x.read(self._iprot)
3846 
      self._iprot.readMessageEnd()
3847 
      raise x
3848 
    result = getInsurer_result()
3849 
    result.read(self._iprot)
3850 
    self._iprot.readMessageEnd()
3851 
    if result.success is not None:
3852 
      return result.success
3853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3854 
 
6838 vikram.rag 3855 
  def getAllInsurers(self, ):
3856 
    self.send_getAllInsurers()
3857 
    return self.recv_getAllInsurers()
6805 anupam.sin 3858 
 
6838 vikram.rag 3859 
  def send_getAllInsurers(self, ):
3860 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3861 
    args = getAllInsurers_args()
3862 
    args.write(self._oprot)
3863 
    self._oprot.writeMessageEnd()
3864 
    self._oprot.trans.flush()
3865 
 
3866 
  def recv_getAllInsurers(self, ):
3867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3868 
    if mtype == TMessageType.EXCEPTION:
3869 
      x = TApplicationException()
3870 
      x.read(self._iprot)
3871 
      self._iprot.readMessageEnd()
3872 
      raise x
3873 
    result = getAllInsurers_result()
3874 
    result.read(self._iprot)
3875 
    self._iprot.readMessageEnd()
3876 
    if result.success is not None:
3877 
      return result.success
3878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3879 
 
6962 rajveer 3880 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3881 
    """
3882 
    Parameters:
3883 
     - insurerId
3884 
     - amount
3885 
    """
3886 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3887 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3888 
 
6962 rajveer 3889 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3890 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3891 
    args = updateInsuranceDeclaredAmount_args()
3892 
    args.insurerId = insurerId
3893 
    args.amount = amount
3894 
    args.write(self._oprot)
3895 
    self._oprot.writeMessageEnd()
3896 
    self._oprot.trans.flush()
3897 
 
3898 
  def recv_updateInsuranceDeclaredAmount(self, ):
3899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3900 
    if mtype == TMessageType.EXCEPTION:
3901 
      x = TApplicationException()
3902 
      x.read(self._iprot)
3903 
      self._iprot.readMessageEnd()
3904 
      raise x
3905 
    result = updateInsuranceDeclaredAmount_result()
3906 
    result.read(self._iprot)
3907 
    self._iprot.readMessageEnd()
3908 
    return
3909 
 
7190 amar.kumar 3910 
  def getFreebieForItem(self, itemId):
3911 
    """
3912 
    Parameters:
3913 
     - itemId
3914 
    """
3915 
    self.send_getFreebieForItem(itemId)
3916 
    return self.recv_getFreebieForItem()
6962 rajveer 3917 
 
7190 amar.kumar 3918 
  def send_getFreebieForItem(self, itemId):
3919 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3920 
    args = getFreebieForItem_args()
3921 
    args.itemId = itemId
3922 
    args.write(self._oprot)
3923 
    self._oprot.writeMessageEnd()
3924 
    self._oprot.trans.flush()
3925 
 
3926 
  def recv_getFreebieForItem(self, ):
3927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3928 
    if mtype == TMessageType.EXCEPTION:
3929 
      x = TApplicationException()
3930 
      x.read(self._iprot)
3931 
      self._iprot.readMessageEnd()
3932 
      raise x
3933 
    result = getFreebieForItem_result()
3934 
    result.read(self._iprot)
3935 
    self._iprot.readMessageEnd()
3936 
    if result.success is not None:
3937 
      return result.success
3938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3939 
 
3940 
  def addOrUpdateFreebieForItem(self, freebieItem):
3941 
    """
3942 
    Parameters:
3943 
     - freebieItem
3944 
    """
3945 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3946 
    self.recv_addOrUpdateFreebieForItem()
3947 
 
3948 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3949 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3950 
    args = addOrUpdateFreebieForItem_args()
3951 
    args.freebieItem = freebieItem
3952 
    args.write(self._oprot)
3953 
    self._oprot.writeMessageEnd()
3954 
    self._oprot.trans.flush()
3955 
 
3956 
  def recv_addOrUpdateFreebieForItem(self, ):
3957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3958 
    if mtype == TMessageType.EXCEPTION:
3959 
      x = TApplicationException()
3960 
      x.read(self._iprot)
3961 
      self._iprot.readMessageEnd()
3962 
      raise x
3963 
    result = addOrUpdateFreebieForItem_result()
3964 
    result.read(self._iprot)
3965 
    self._iprot.readMessageEnd()
3966 
    return
3967 
 
7272 amit.gupta 3968 
  def addOrUpdateBrandInfo(self, brandInfo):
3969 
    """
3970 
    Parameters:
3971 
     - brandInfo
3972 
    """
3973 
    self.send_addOrUpdateBrandInfo(brandInfo)
3974 
    self.recv_addOrUpdateBrandInfo()
3975 
 
3976 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3977 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3978 
    args = addOrUpdateBrandInfo_args()
3979 
    args.brandInfo = brandInfo
3980 
    args.write(self._oprot)
3981 
    self._oprot.writeMessageEnd()
3982 
    self._oprot.trans.flush()
3983 
 
3984 
  def recv_addOrUpdateBrandInfo(self, ):
3985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3986 
    if mtype == TMessageType.EXCEPTION:
3987 
      x = TApplicationException()
3988 
      x.read(self._iprot)
3989 
      self._iprot.readMessageEnd()
3990 
      raise x
3991 
    result = addOrUpdateBrandInfo_result()
3992 
    result.read(self._iprot)
3993 
    self._iprot.readMessageEnd()
3994 
    return
3995 
 
3996 
  def getBrandInfo(self, ):
3997 
    self.send_getBrandInfo()
3998 
    return self.recv_getBrandInfo()
3999 
 
4000 
  def send_getBrandInfo(self, ):
4001 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
4002 
    args = getBrandInfo_args()
4003 
    args.write(self._oprot)
4004 
    self._oprot.writeMessageEnd()
4005 
    self._oprot.trans.flush()
4006 
 
4007 
  def recv_getBrandInfo(self, ):
4008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4009 
    if mtype == TMessageType.EXCEPTION:
4010 
      x = TApplicationException()
4011 
      x.read(self._iprot)
4012 
      self._iprot.readMessageEnd()
4013 
      raise x
4014 
    result = getBrandInfo_result()
4015 
    result.read(self._iprot)
4016 
    self._iprot.readMessageEnd()
4017 
    if result.success is not None:
4018 
      return result.success
4019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
4020 
 
7256 rajveer 4021 
  def getStorePricing(self, itemId):
4022 
    """
4023 
    Parameters:
4024 
     - itemId
4025 
    """
4026 
    self.send_getStorePricing(itemId)
4027 
    return self.recv_getStorePricing()
7190 amar.kumar 4028 
 
7256 rajveer 4029 
  def send_getStorePricing(self, itemId):
4030 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
4031 
    args = getStorePricing_args()
4032 
    args.itemId = itemId
4033 
    args.write(self._oprot)
4034 
    self._oprot.writeMessageEnd()
4035 
    self._oprot.trans.flush()
4036 
 
4037 
  def recv_getStorePricing(self, ):
4038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4039 
    if mtype == TMessageType.EXCEPTION:
4040 
      x = TApplicationException()
4041 
      x.read(self._iprot)
4042 
      self._iprot.readMessageEnd()
4043 
      raise x
4044 
    result = getStorePricing_result()
4045 
    result.read(self._iprot)
4046 
    self._iprot.readMessageEnd()
4047 
    if result.success is not None:
4048 
      return result.success
4049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4050 
 
7306 rajveer 4051 
  def getStorePricings(self, itemIds):
4052 
    """
4053 
    Parameters:
4054 
     - itemIds
4055 
    """
4056 
    self.send_getStorePricings(itemIds)
4057 
    return self.recv_getStorePricings()
4058 
 
4059 
  def send_getStorePricings(self, itemIds):
4060 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4061 
    args = getStorePricings_args()
4062 
    args.itemIds = itemIds
4063 
    args.write(self._oprot)
4064 
    self._oprot.writeMessageEnd()
4065 
    self._oprot.trans.flush()
4066 
 
4067 
  def recv_getStorePricings(self, ):
4068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4069 
    if mtype == TMessageType.EXCEPTION:
4070 
      x = TApplicationException()
4071 
      x.read(self._iprot)
4072 
      self._iprot.readMessageEnd()
4073 
      raise x
4074 
    result = getStorePricings_result()
4075 
    result.read(self._iprot)
4076 
    self._iprot.readMessageEnd()
4077 
    if result.success is not None:
4078 
      return result.success
4079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4080 
 
7382 rajveer 4081 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4082 
    """
4083 
    Parameters:
4084 
     - sp
7382 rajveer 4085 
     - allColors
7265 rajveer 4086 
    """
7382 rajveer 4087 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4088 
    self.recv_updateStorePricing()
7256 rajveer 4089 
 
7382 rajveer 4090 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4091 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4092 
    args = updateStorePricing_args()
4093 
    args.sp = sp
7382 rajveer 4094 
    args.allColors = allColors
7265 rajveer 4095 
    args.write(self._oprot)
4096 
    self._oprot.writeMessageEnd()
4097 
    self._oprot.trans.flush()
4098 
 
4099 
  def recv_updateStorePricing(self, ):
4100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4101 
    if mtype == TMessageType.EXCEPTION:
4102 
      x = TApplicationException()
4103 
      x.read(self._iprot)
4104 
      self._iprot.readMessageEnd()
4105 
      raise x
4106 
    result = updateStorePricing_result()
4107 
    result.read(self._iprot)
4108 
    self._iprot.readMessageEnd()
4109 
    return
4110 
 
7281 kshitij.so 4111 
  def getAllAmazonListedItems(self, ):
4112 
    self.send_getAllAmazonListedItems()
4113 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4114 
 
7281 kshitij.so 4115 
  def send_getAllAmazonListedItems(self, ):
4116 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4117 
    args = getAllAmazonListedItems_args()
4118 
    args.write(self._oprot)
4119 
    self._oprot.writeMessageEnd()
4120 
    self._oprot.trans.flush()
4121 
 
4122 
  def recv_getAllAmazonListedItems(self, ):
4123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4124 
    if mtype == TMessageType.EXCEPTION:
4125 
      x = TApplicationException()
4126 
      x.read(self._iprot)
4127 
      self._iprot.readMessageEnd()
4128 
      raise x
4129 
    result = getAllAmazonListedItems_result()
4130 
    result.read(self._iprot)
4131 
    self._iprot.readMessageEnd()
4132 
    if result.success is not None:
4133 
      return result.success
4134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4135 
 
8619 kshitij.so 4136 
  def searchAmazonItems(self, searchTerm, offset, limit):
4137 
    """
4138 
    Parameters:
4139 
     - searchTerm
4140 
     - offset
4141 
     - limit
4142 
    """
4143 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4144 
    return self.recv_searchAmazonItems()
4145 
 
4146 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4147 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4148 
    args = searchAmazonItems_args()
4149 
    args.searchTerm = searchTerm
4150 
    args.offset = offset
4151 
    args.limit = limit
4152 
    args.write(self._oprot)
4153 
    self._oprot.writeMessageEnd()
4154 
    self._oprot.trans.flush()
4155 
 
4156 
  def recv_searchAmazonItems(self, ):
4157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4158 
    if mtype == TMessageType.EXCEPTION:
4159 
      x = TApplicationException()
4160 
      x.read(self._iprot)
4161 
      self._iprot.readMessageEnd()
4162 
      raise x
4163 
    result = searchAmazonItems_result()
4164 
    result.read(self._iprot)
4165 
    self._iprot.readMessageEnd()
4166 
    if result.success is not None:
4167 
      return result.success
4168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4169 
 
4170 
  def getAmazonSearchResultCount(self, searchTerm):
4171 
    """
4172 
    Parameters:
4173 
     - searchTerm
4174 
    """
4175 
    self.send_getAmazonSearchResultCount(searchTerm)
4176 
    return self.recv_getAmazonSearchResultCount()
4177 
 
4178 
  def send_getAmazonSearchResultCount(self, searchTerm):
4179 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4180 
    args = getAmazonSearchResultCount_args()
4181 
    args.searchTerm = searchTerm
4182 
    args.write(self._oprot)
4183 
    self._oprot.writeMessageEnd()
4184 
    self._oprot.trans.flush()
4185 
 
4186 
  def recv_getAmazonSearchResultCount(self, ):
4187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4188 
    if mtype == TMessageType.EXCEPTION:
4189 
      x = TApplicationException()
4190 
      x.read(self._iprot)
4191 
      self._iprot.readMessageEnd()
4192 
      raise x
4193 
    result = getAmazonSearchResultCount_result()
4194 
    result.read(self._iprot)
4195 
    self._iprot.readMessageEnd()
4196 
    if result.success is not None:
4197 
      return result.success
4198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4199 
 
4200 
  def getCountForAmazonlistedItems(self, ):
4201 
    self.send_getCountForAmazonlistedItems()
4202 
    return self.recv_getCountForAmazonlistedItems()
4203 
 
4204 
  def send_getCountForAmazonlistedItems(self, ):
4205 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4206 
    args = getCountForAmazonlistedItems_args()
4207 
    args.write(self._oprot)
4208 
    self._oprot.writeMessageEnd()
4209 
    self._oprot.trans.flush()
4210 
 
4211 
  def recv_getCountForAmazonlistedItems(self, ):
4212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4213 
    if mtype == TMessageType.EXCEPTION:
4214 
      x = TApplicationException()
4215 
      x.read(self._iprot)
4216 
      self._iprot.readMessageEnd()
4217 
      raise x
4218 
    result = getCountForAmazonlistedItems_result()
4219 
    result.read(self._iprot)
4220 
    self._iprot.readMessageEnd()
4221 
    if result.success is not None:
4222 
      return result.success
4223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4224 
 
7281 kshitij.so 4225 
  def getAmazonItemDetails(self, itemId):
4226 
    """
4227 
    Parameters:
4228 
     - itemId
4229 
    """
4230 
    self.send_getAmazonItemDetails(itemId)
4231 
    return self.recv_getAmazonItemDetails()
4232 
 
4233 
  def send_getAmazonItemDetails(self, itemId):
4234 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4235 
    args = getAmazonItemDetails_args()
4236 
    args.itemId = itemId
4237 
    args.write(self._oprot)
4238 
    self._oprot.writeMessageEnd()
4239 
    self._oprot.trans.flush()
4240 
 
4241 
  def recv_getAmazonItemDetails(self, ):
4242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4243 
    if mtype == TMessageType.EXCEPTION:
4244 
      x = TApplicationException()
4245 
      x.read(self._iprot)
4246 
      self._iprot.readMessageEnd()
4247 
      raise x
4248 
    result = getAmazonItemDetails_result()
4249 
    result.read(self._iprot)
4250 
    self._iprot.readMessageEnd()
4251 
    if result.success is not None:
4252 
      return result.success
4253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4254 
 
8168 kshitij.so 4255 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4256 
    """
4257 
    Parameters:
8168 kshitij.so 4258 
     - amazonlisted
7281 kshitij.so 4259 
    """
8168 kshitij.so 4260 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4261 
    self.recv_updateAmazonItemDetails()
4262 
 
8168 kshitij.so 4263 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4264 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4265 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4266 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4267 
    args.write(self._oprot)
4268 
    self._oprot.writeMessageEnd()
4269 
    self._oprot.trans.flush()
4270 
 
4271 
  def recv_updateAmazonItemDetails(self, ):
4272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4273 
    if mtype == TMessageType.EXCEPTION:
4274 
      x = TApplicationException()
4275 
      x.read(self._iprot)
4276 
      self._iprot.readMessageEnd()
4277 
      raise x
4278 
    result = updateAmazonItemDetails_result()
4279 
    result.read(self._iprot)
4280 
    self._iprot.readMessageEnd()
4281 
    return
4282 
 
4283 
  def addAmazonItem(self, amazonlisted):
4284 
    """
4285 
    Parameters:
4286 
     - amazonlisted
4287 
    """
4288 
    self.send_addAmazonItem(amazonlisted)
4289 
    self.recv_addAmazonItem()
4290 
 
4291 
  def send_addAmazonItem(self, amazonlisted):
4292 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4293 
    args = addAmazonItem_args()
4294 
    args.amazonlisted = amazonlisted
4295 
    args.write(self._oprot)
4296 
    self._oprot.writeMessageEnd()
4297 
    self._oprot.trans.flush()
4298 
 
4299 
  def recv_addAmazonItem(self, ):
4300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4301 
    if mtype == TMessageType.EXCEPTION:
4302 
      x = TApplicationException()
4303 
      x.read(self._iprot)
4304 
      self._iprot.readMessageEnd()
4305 
      raise x
4306 
    result = addAmazonItem_result()
4307 
    result.read(self._iprot)
4308 
    self._iprot.readMessageEnd()
4309 
    return
4310 
 
7291 vikram.rag 4311 
  def getAsinItems(self, ):
4312 
    self.send_getAsinItems()
4313 
    return self.recv_getAsinItems()
7281 kshitij.so 4314 
 
7291 vikram.rag 4315 
  def send_getAsinItems(self, ):
4316 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4317 
    args = getAsinItems_args()
4318 
    args.write(self._oprot)
4319 
    self._oprot.writeMessageEnd()
4320 
    self._oprot.trans.flush()
4321 
 
4322 
  def recv_getAsinItems(self, ):
4323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4324 
    if mtype == TMessageType.EXCEPTION:
4325 
      x = TApplicationException()
4326 
      x.read(self._iprot)
4327 
      self._iprot.readMessageEnd()
4328 
      raise x
4329 
    result = getAsinItems_result()
4330 
    result.read(self._iprot)
4331 
    self._iprot.readMessageEnd()
4332 
    if result.success is not None:
4333 
      return result.success
4334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4335 
 
4336 
  def getAllFbaListedItems(self, ):
4337 
    self.send_getAllFbaListedItems()
4338 
    return self.recv_getAllFbaListedItems()
4339 
 
4340 
  def send_getAllFbaListedItems(self, ):
4341 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4342 
    args = getAllFbaListedItems_args()
4343 
    args.write(self._oprot)
4344 
    self._oprot.writeMessageEnd()
4345 
    self._oprot.trans.flush()
4346 
 
4347 
  def recv_getAllFbaListedItems(self, ):
4348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4349 
    if mtype == TMessageType.EXCEPTION:
4350 
      x = TApplicationException()
4351 
      x.read(self._iprot)
4352 
      self._iprot.readMessageEnd()
4353 
      raise x
4354 
    result = getAllFbaListedItems_result()
4355 
    result.read(self._iprot)
4356 
    self._iprot.readMessageEnd()
4357 
    if result.success is not None:
4358 
      return result.success
4359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4360 
 
4361 
  def getAllNonFbaListedItems(self, ):
4362 
    self.send_getAllNonFbaListedItems()
4363 
    return self.recv_getAllNonFbaListedItems()
4364 
 
4365 
  def send_getAllNonFbaListedItems(self, ):
4366 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4367 
    args = getAllNonFbaListedItems_args()
4368 
    args.write(self._oprot)
4369 
    self._oprot.writeMessageEnd()
4370 
    self._oprot.trans.flush()
4371 
 
4372 
  def recv_getAllNonFbaListedItems(self, ):
4373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4374 
    if mtype == TMessageType.EXCEPTION:
4375 
      x = TApplicationException()
4376 
      x.read(self._iprot)
4377 
      self._iprot.readMessageEnd()
4378 
      raise x
4379 
    result = getAllNonFbaListedItems_result()
4380 
    result.read(self._iprot)
4381 
    self._iprot.readMessageEnd()
4382 
    if result.success is not None:
4383 
      return result.success
4384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4385 
 
7460 kshitij.so 4386 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4387 
    """
4388 
    Parameters:
4389 
     - itemId
4390 
     - holdInventory
4391 
     - defaultInventory
4392 
    """
4393 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4394 
    return self.recv_updateItemInventory()
7291 vikram.rag 4395 
 
7460 kshitij.so 4396 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4397 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4398 
    args = updateItemInventory_args()
4399 
    args.itemId = itemId
4400 
    args.holdInventory = holdInventory
4401 
    args.defaultInventory = defaultInventory
4402 
    args.write(self._oprot)
4403 
    self._oprot.writeMessageEnd()
4404 
    self._oprot.trans.flush()
4405 
 
4406 
  def recv_updateItemInventory(self, ):
4407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4408 
    if mtype == TMessageType.EXCEPTION:
4409 
      x = TApplicationException()
4410 
      x.read(self._iprot)
4411 
      self._iprot.readMessageEnd()
4412 
      raise x
4413 
    result = updateItemInventory_result()
4414 
    result.read(self._iprot)
4415 
    self._iprot.readMessageEnd()
4416 
    if result.success is not None:
4417 
      return result.success
4418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4419 
 
7770 kshitij.so 4420 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4421 
    """
4422 
    Parameters:
4423 
     - type
4424 
     - sku
4425 
     - timestamp
4426 
    """
4427 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4428 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4429 
 
7770 kshitij.so 4430 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4431 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4432 
    args = updateTimestampForAmazonFeeds_args()
4433 
    args.type = type
4434 
    args.sku = sku
4435 
    args.timestamp = timestamp
4436 
    args.write(self._oprot)
4437 
    self._oprot.writeMessageEnd()
4438 
    self._oprot.trans.flush()
4439 
 
4440 
  def recv_updateTimestampForAmazonFeeds(self, ):
4441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4442 
    if mtype == TMessageType.EXCEPTION:
4443 
      x = TApplicationException()
4444 
      x.read(self._iprot)
4445 
      self._iprot.readMessageEnd()
4446 
      raise x
4447 
    result = updateTimestampForAmazonFeeds_result()
4448 
    result.read(self._iprot)
4449 
    self._iprot.readMessageEnd()
4450 
    if result.success is not None:
4451 
      return result.success
4452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4453 
 
7897 amar.kumar 4454 
  def getAllParentCategories(self, ):
4455 
    self.send_getAllParentCategories()
4456 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4457 
 
7897 amar.kumar 4458 
  def send_getAllParentCategories(self, ):
4459 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4460 
    args = getAllParentCategories_args()
4461 
    args.write(self._oprot)
4462 
    self._oprot.writeMessageEnd()
4463 
    self._oprot.trans.flush()
4464 
 
4465 
  def recv_getAllParentCategories(self, ):
4466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4467 
    if mtype == TMessageType.EXCEPTION:
4468 
      x = TApplicationException()
4469 
      x.read(self._iprot)
4470 
      self._iprot.readMessageEnd()
4471 
      raise x
4472 
    result = getAllParentCategories_result()
4473 
    result.read(self._iprot)
4474 
    self._iprot.readMessageEnd()
4475 
    if result.success is not None:
4476 
      return result.success
4477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4478 
 
7977 kshitij.so 4479 
  def addPageViewEvent(self, pageViewEvents):
4480 
    """
4481 
    Parameters:
4482 
     - pageViewEvents
4483 
    """
4484 
    self.send_addPageViewEvent(pageViewEvents)
4485 
    self.recv_addPageViewEvent()
7897 amar.kumar 4486 
 
7977 kshitij.so 4487 
  def send_addPageViewEvent(self, pageViewEvents):
4488 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4489 
    args = addPageViewEvent_args()
4490 
    args.pageViewEvents = pageViewEvents
4491 
    args.write(self._oprot)
4492 
    self._oprot.writeMessageEnd()
4493 
    self._oprot.trans.flush()
4494 
 
4495 
  def recv_addPageViewEvent(self, ):
4496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4497 
    if mtype == TMessageType.EXCEPTION:
4498 
      x = TApplicationException()
4499 
      x.read(self._iprot)
4500 
      self._iprot.readMessageEnd()
4501 
      raise x
4502 
    result = addPageViewEvent_result()
4503 
    result.read(self._iprot)
4504 
    self._iprot.readMessageEnd()
4505 
    return
4506 
 
4507 
  def addCartEvent(self, cartEvents):
4508 
    """
4509 
    Parameters:
4510 
     - cartEvents
4511 
    """
4512 
    self.send_addCartEvent(cartEvents)
4513 
    self.recv_addCartEvent()
4514 
 
4515 
  def send_addCartEvent(self, cartEvents):
4516 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4517 
    args = addCartEvent_args()
4518 
    args.cartEvents = cartEvents
4519 
    args.write(self._oprot)
4520 
    self._oprot.writeMessageEnd()
4521 
    self._oprot.trans.flush()
4522 
 
4523 
  def recv_addCartEvent(self, ):
4524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4525 
    if mtype == TMessageType.EXCEPTION:
4526 
      x = TApplicationException()
4527 
      x.read(self._iprot)
4528 
      self._iprot.readMessageEnd()
4529 
      raise x
4530 
    result = addCartEvent_result()
4531 
    result.read(self._iprot)
4532 
    self._iprot.readMessageEnd()
4533 
    return
4534 
 
8182 amar.kumar 4535 
  def addEbayItem(self, ebayItem):
4536 
    """
4537 
    Parameters:
4538 
     - ebayItem
4539 
    """
4540 
    self.send_addEbayItem(ebayItem)
4541 
    self.recv_addEbayItem()
4542 
 
4543 
  def send_addEbayItem(self, ebayItem):
4544 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4545 
    args = addEbayItem_args()
4546 
    args.ebayItem = ebayItem
4547 
    args.write(self._oprot)
4548 
    self._oprot.writeMessageEnd()
4549 
    self._oprot.trans.flush()
4550 
 
4551 
  def recv_addEbayItem(self, ):
4552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4553 
    if mtype == TMessageType.EXCEPTION:
4554 
      x = TApplicationException()
4555 
      x.read(self._iprot)
4556 
      self._iprot.readMessageEnd()
4557 
      raise x
4558 
    result = addEbayItem_result()
4559 
    result.read(self._iprot)
4560 
    self._iprot.readMessageEnd()
4561 
    return
4562 
 
4563 
  def getEbayItem(self, listingId):
4564 
    """
4565 
    Parameters:
4566 
     - listingId
4567 
    """
4568 
    self.send_getEbayItem(listingId)
4569 
    return self.recv_getEbayItem()
4570 
 
4571 
  def send_getEbayItem(self, listingId):
4572 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4573 
    args = getEbayItem_args()
4574 
    args.listingId = listingId
4575 
    args.write(self._oprot)
4576 
    self._oprot.writeMessageEnd()
4577 
    self._oprot.trans.flush()
4578 
 
4579 
  def recv_getEbayItem(self, ):
4580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4581 
    if mtype == TMessageType.EXCEPTION:
4582 
      x = TApplicationException()
4583 
      x.read(self._iprot)
4584 
      self._iprot.readMessageEnd()
4585 
      raise x
4586 
    result = getEbayItem_result()
4587 
    result.read(self._iprot)
4588 
    self._iprot.readMessageEnd()
4589 
    if result.success is not None:
4590 
      return result.success
4591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4592 
 
4593 
  def updateEbayItem(self, ebayItem):
4594 
    """
4595 
    Parameters:
4596 
     - ebayItem
4597 
    """
4598 
    self.send_updateEbayItem(ebayItem)
4599 
    self.recv_updateEbayItem()
4600 
 
4601 
  def send_updateEbayItem(self, ebayItem):
4602 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4603 
    args = updateEbayItem_args()
4604 
    args.ebayItem = ebayItem
4605 
    args.write(self._oprot)
4606 
    self._oprot.writeMessageEnd()
4607 
    self._oprot.trans.flush()
4608 
 
4609 
  def recv_updateEbayItem(self, ):
4610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4611 
    if mtype == TMessageType.EXCEPTION:
4612 
      x = TApplicationException()
4613 
      x.read(self._iprot)
4614 
      self._iprot.readMessageEnd()
4615 
      raise x
4616 
    result = updateEbayItem_result()
4617 
    result.read(self._iprot)
4618 
    self._iprot.readMessageEnd()
4619 
    return
4620 
 
8139 kshitij.so 4621 
  def getAmazonListedItems(self, offset, limit):
4622 
    """
4623 
    Parameters:
4624 
     - offset
4625 
     - limit
4626 
    """
4627 
    self.send_getAmazonListedItems(offset, limit)
4628 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4629 
 
8139 kshitij.so 4630 
  def send_getAmazonListedItems(self, offset, limit):
4631 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4632 
    args = getAmazonListedItems_args()
4633 
    args.offset = offset
4634 
    args.limit = limit
4635 
    args.write(self._oprot)
4636 
    self._oprot.writeMessageEnd()
4637 
    self._oprot.trans.flush()
4638 
 
4639 
  def recv_getAmazonListedItems(self, ):
4640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4641 
    if mtype == TMessageType.EXCEPTION:
4642 
      x = TApplicationException()
4643 
      x.read(self._iprot)
4644 
      self._iprot.readMessageEnd()
4645 
      raise x
4646 
    result = getAmazonListedItems_result()
4647 
    result.read(self._iprot)
4648 
    self._iprot.readMessageEnd()
4649 
    if result.success is not None:
4650 
      return result.success
4651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4652 
 
8168 kshitij.so 4653 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4654 
    """
4655 
    Parameters:
4656 
     - amazonlisted
4657 
    """
4658 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4659 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4660 
 
8168 kshitij.so 4661 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4662 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4663 
    args = updateAmazonAttributesInBulk_args()
4664 
    args.amazonlisted = amazonlisted
4665 
    args.write(self._oprot)
4666 
    self._oprot.writeMessageEnd()
4667 
    self._oprot.trans.flush()
4668 
 
4669 
  def recv_updateAmazonAttributesInBulk(self, ):
4670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4671 
    if mtype == TMessageType.EXCEPTION:
4672 
      x = TApplicationException()
4673 
      x.read(self._iprot)
4674 
      self._iprot.readMessageEnd()
4675 
      raise x
4676 
    result = updateAmazonAttributesInBulk_result()
4677 
    result.read(self._iprot)
4678 
    self._iprot.readMessageEnd()
4679 
    if result.success is not None:
4680 
      return result.success
4681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4682 
 
8379 vikram.rag 4683 
  def getAllItemstoListOnFba(self, ):
4684 
    self.send_getAllItemstoListOnFba()
4685 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4686 
 
8379 vikram.rag 4687 
  def send_getAllItemstoListOnFba(self, ):
4688 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4689 
    args = getAllItemstoListOnFba_args()
4690 
    args.write(self._oprot)
4691 
    self._oprot.writeMessageEnd()
4692 
    self._oprot.trans.flush()
4693 
 
4694 
  def recv_getAllItemstoListOnFba(self, ):
4695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4696 
    if mtype == TMessageType.EXCEPTION:
4697 
      x = TApplicationException()
4698 
      x.read(self._iprot)
4699 
      self._iprot.readMessageEnd()
4700 
      raise x
4701 
    result = getAllItemstoListOnFba_result()
4702 
    result.read(self._iprot)
4703 
    self._iprot.readMessageEnd()
4704 
    if result.success is not None:
4705 
      return result.success
4706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4707 
 
4708 
  def getAllItemstoListOnNonFba(self, ):
4709 
    self.send_getAllItemstoListOnNonFba()
4710 
    return self.recv_getAllItemstoListOnNonFba()
4711 
 
4712 
  def send_getAllItemstoListOnNonFba(self, ):
4713 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4714 
    args = getAllItemstoListOnNonFba_args()
4715 
    args.write(self._oprot)
4716 
    self._oprot.writeMessageEnd()
4717 
    self._oprot.trans.flush()
4718 
 
4719 
  def recv_getAllItemstoListOnNonFba(self, ):
4720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4721 
    if mtype == TMessageType.EXCEPTION:
4722 
      x = TApplicationException()
4723 
      x.read(self._iprot)
4724 
      self._iprot.readMessageEnd()
4725 
      raise x
4726 
    result = getAllItemstoListOnNonFba_result()
4727 
    result.read(self._iprot)
4728 
    self._iprot.readMessageEnd()
4729 
    if result.success is not None:
4730 
      return result.success
4731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4732 
 
8619 kshitij.so 4733 
  def updateAsin(self, item):
4734 
    """
4735 
    Parameters:
4736 
     - item
4737 
    """
4738 
    self.send_updateAsin(item)
4739 
    self.recv_updateAsin()
8616 vikram.rag 4740 
 
8619 kshitij.so 4741 
  def send_updateAsin(self, item):
4742 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4743 
    args = updateAsin_args()
4744 
    args.item = item
4745 
    args.write(self._oprot)
4746 
    self._oprot.writeMessageEnd()
4747 
    self._oprot.trans.flush()
4748 
 
4749 
  def recv_updateAsin(self, ):
4750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4751 
    if mtype == TMessageType.EXCEPTION:
4752 
      x = TApplicationException()
4753 
      x.read(self._iprot)
4754 
      self._iprot.readMessageEnd()
4755 
      raise x
4756 
    result = updateAsin_result()
4757 
    result.read(self._iprot)
4758 
    self._iprot.readMessageEnd()
4759 
    return
4760 
 
8739 vikram.rag 4761 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4762 
    """
4763 
    Parameters:
4764 
     - snapdealitem
4765 
    """
4766 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4767 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4768 
 
8739 vikram.rag 4769 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4770 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4771 
    args = addOrUpdateSnapdealItem_args()
4772 
    args.snapdealitem = snapdealitem
4773 
    args.write(self._oprot)
4774 
    self._oprot.writeMessageEnd()
4775 
    self._oprot.trans.flush()
4776 
 
4777 
  def recv_addOrUpdateSnapdealItem(self, ):
4778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4779 
    if mtype == TMessageType.EXCEPTION:
4780 
      x = TApplicationException()
4781 
      x.read(self._iprot)
4782 
      self._iprot.readMessageEnd()
4783 
      raise x
4784 
    result = addOrUpdateSnapdealItem_result()
4785 
    result.read(self._iprot)
4786 
    self._iprot.readMessageEnd()
4787 
    if result.success is not None:
4788 
      return result.success
4789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4790 
 
4791 
  def getSnapdealItem(self, item_id):
4792 
    """
4793 
    Parameters:
4794 
     - item_id
4795 
    """
4796 
    self.send_getSnapdealItem(item_id)
4797 
    return self.recv_getSnapdealItem()
4798 
 
4799 
  def send_getSnapdealItem(self, item_id):
4800 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4801 
    args = getSnapdealItem_args()
4802 
    args.item_id = item_id
4803 
    args.write(self._oprot)
4804 
    self._oprot.writeMessageEnd()
4805 
    self._oprot.trans.flush()
4806 
 
4807 
  def recv_getSnapdealItem(self, ):
4808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4809 
    if mtype == TMessageType.EXCEPTION:
4810 
      x = TApplicationException()
4811 
      x.read(self._iprot)
4812 
      self._iprot.readMessageEnd()
4813 
      raise x
4814 
    result = getSnapdealItem_result()
4815 
    result.read(self._iprot)
4816 
    self._iprot.readMessageEnd()
4817 
    if result.success is not None:
4818 
      return result.success
4819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4820 
 
9242 kshitij.so 4821 
  def getSnapdealItemDetails(self, item_id):
4822 
    """
4823 
    Parameters:
4824 
     - item_id
4825 
    """
4826 
    self.send_getSnapdealItemDetails(item_id)
4827 
    return self.recv_getSnapdealItemDetails()
4828 
 
4829 
  def send_getSnapdealItemDetails(self, item_id):
4830 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4831 
    args = getSnapdealItemDetails_args()
4832 
    args.item_id = item_id
4833 
    args.write(self._oprot)
4834 
    self._oprot.writeMessageEnd()
4835 
    self._oprot.trans.flush()
4836 
 
4837 
  def recv_getSnapdealItemDetails(self, ):
4838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4839 
    if mtype == TMessageType.EXCEPTION:
4840 
      x = TApplicationException()
4841 
      x.read(self._iprot)
4842 
      self._iprot.readMessageEnd()
4843 
      raise x
4844 
    result = getSnapdealItemDetails_result()
4845 
    result.read(self._iprot)
4846 
    self._iprot.readMessageEnd()
4847 
    if result.success is not None:
4848 
      return result.success
4849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4850 
 
8739 vikram.rag 4851 
  def getAllSnapdealItems(self, ):
4852 
    self.send_getAllSnapdealItems()
4853 
    return self.recv_getAllSnapdealItems()
4854 
 
4855 
  def send_getAllSnapdealItems(self, ):
4856 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4857 
    args = getAllSnapdealItems_args()
4858 
    args.write(self._oprot)
4859 
    self._oprot.writeMessageEnd()
4860 
    self._oprot.trans.flush()
4861 
 
4862 
  def recv_getAllSnapdealItems(self, ):
4863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4864 
    if mtype == TMessageType.EXCEPTION:
4865 
      x = TApplicationException()
4866 
      x.read(self._iprot)
4867 
      self._iprot.readMessageEnd()
4868 
      raise x
4869 
    result = getAllSnapdealItems_result()
4870 
    result.read(self._iprot)
4871 
    self._iprot.readMessageEnd()
4872 
    if result.success is not None:
4873 
      return result.success
4874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4875 
 
9242 kshitij.so 4876 
  def getSnapdealItems(self, offset, limit):
4877 
    """
4878 
    Parameters:
4879 
     - offset
4880 
     - limit
4881 
    """
4882 
    self.send_getSnapdealItems(offset, limit)
4883 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4884 
 
9242 kshitij.so 4885 
  def send_getSnapdealItems(self, offset, limit):
4886 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4887 
    args = getSnapdealItems_args()
4888 
    args.offset = offset
4889 
    args.limit = limit
4890 
    args.write(self._oprot)
4891 
    self._oprot.writeMessageEnd()
4892 
    self._oprot.trans.flush()
4893 
 
4894 
  def recv_getSnapdealItems(self, ):
4895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4896 
    if mtype == TMessageType.EXCEPTION:
4897 
      x = TApplicationException()
4898 
      x.read(self._iprot)
4899 
      self._iprot.readMessageEnd()
4900 
      raise x
4901 
    result = getSnapdealItems_result()
4902 
    result.read(self._iprot)
4903 
    self._iprot.readMessageEnd()
4904 
    if result.success is not None:
4905 
      return result.success
4906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4907 
 
4908 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4909 
    """
4910 
    Parameters:
4911 
     - searchTerm
4912 
     - offset
4913 
     - limit
4914 
    """
4915 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4916 
    return self.recv_searchSnapdealItems()
4917 
 
4918 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4919 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4920 
    args = searchSnapdealItems_args()
4921 
    args.searchTerm = searchTerm
4922 
    args.offset = offset
4923 
    args.limit = limit
4924 
    args.write(self._oprot)
4925 
    self._oprot.writeMessageEnd()
4926 
    self._oprot.trans.flush()
4927 
 
4928 
  def recv_searchSnapdealItems(self, ):
4929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4930 
    if mtype == TMessageType.EXCEPTION:
4931 
      x = TApplicationException()
4932 
      x.read(self._iprot)
4933 
      self._iprot.readMessageEnd()
4934 
      raise x
4935 
    result = searchSnapdealItems_result()
4936 
    result.read(self._iprot)
4937 
    self._iprot.readMessageEnd()
4938 
    if result.success is not None:
4939 
      return result.success
4940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4941 
 
4942 
  def getCountForSnapdealItems(self, ):
4943 
    self.send_getCountForSnapdealItems()
4944 
    return self.recv_getCountForSnapdealItems()
4945 
 
4946 
  def send_getCountForSnapdealItems(self, ):
4947 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
4948 
    args = getCountForSnapdealItems_args()
4949 
    args.write(self._oprot)
4950 
    self._oprot.writeMessageEnd()
4951 
    self._oprot.trans.flush()
4952 
 
4953 
  def recv_getCountForSnapdealItems(self, ):
4954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4955 
    if mtype == TMessageType.EXCEPTION:
4956 
      x = TApplicationException()
4957 
      x.read(self._iprot)
4958 
      self._iprot.readMessageEnd()
4959 
      raise x
4960 
    result = getCountForSnapdealItems_result()
4961 
    result.read(self._iprot)
4962 
    self._iprot.readMessageEnd()
4963 
    if result.success is not None:
4964 
      return result.success
4965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
4966 
 
4967 
  def getSnapdealSearchResultCount(self, searchTerm):
4968 
    """
4969 
    Parameters:
4970 
     - searchTerm
4971 
    """
4972 
    self.send_getSnapdealSearchResultCount(searchTerm)
4973 
    return self.recv_getSnapdealSearchResultCount()
4974 
 
4975 
  def send_getSnapdealSearchResultCount(self, searchTerm):
4976 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
4977 
    args = getSnapdealSearchResultCount_args()
4978 
    args.searchTerm = searchTerm
4979 
    args.write(self._oprot)
4980 
    self._oprot.writeMessageEnd()
4981 
    self._oprot.trans.flush()
4982 
 
4983 
  def recv_getSnapdealSearchResultCount(self, ):
4984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4985 
    if mtype == TMessageType.EXCEPTION:
4986 
      x = TApplicationException()
4987 
      x.read(self._iprot)
4988 
      self._iprot.readMessageEnd()
4989 
      raise x
4990 
    result = getSnapdealSearchResultCount_result()
4991 
    result.read(self._iprot)
4992 
    self._iprot.readMessageEnd()
4993 
    if result.success is not None:
4994 
      return result.success
4995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
4996 
 
9299 kshitij.so 4997 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
4998 
    """
4999 
    Parameters:
5000 
     - itemId
5001 
     - insurerType
5002 
    """
5003 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
5004 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 5005 
 
9299 kshitij.so 5006 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
5007 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
5008 
    args = getPrefferedInsurerForItem_args()
5009 
    args.itemId = itemId
5010 
    args.insurerType = insurerType
5011 
    args.write(self._oprot)
5012 
    self._oprot.writeMessageEnd()
5013 
    self._oprot.trans.flush()
5014 
 
5015 
  def recv_getPrefferedInsurerForItem(self, ):
5016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5017 
    if mtype == TMessageType.EXCEPTION:
5018 
      x = TApplicationException()
5019 
      x.read(self._iprot)
5020 
      self._iprot.readMessageEnd()
5021 
      raise x
5022 
    result = getPrefferedInsurerForItem_result()
5023 
    result.read(self._iprot)
5024 
    self._iprot.readMessageEnd()
5025 
    if result.success is not None:
5026 
      return result.success
5027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
5028 
 
9456 vikram.rag 5029 
  def getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5030 
    """
5031 
    Parameters:
5032 
     - skuAtSnapdeal
5033 
    """
5034 
    self.send_getSnapdealItembySkuAtSnapdeal(skuAtSnapdeal)
5035 
    return self.recv_getSnapdealItembySkuAtSnapdeal()
9299 kshitij.so 5036 
 
9456 vikram.rag 5037 
  def send_getSnapdealItembySkuAtSnapdeal(self, skuAtSnapdeal):
5038 
    self._oprot.writeMessageBegin('getSnapdealItembySkuAtSnapdeal', TMessageType.CALL, self._seqid)
5039 
    args = getSnapdealItembySkuAtSnapdeal_args()
5040 
    args.skuAtSnapdeal = skuAtSnapdeal
5041 
    args.write(self._oprot)
5042 
    self._oprot.writeMessageEnd()
5043 
    self._oprot.trans.flush()
5044 
 
5045 
  def recv_getSnapdealItembySkuAtSnapdeal(self, ):
5046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5047 
    if mtype == TMessageType.EXCEPTION:
5048 
      x = TApplicationException()
5049 
      x.read(self._iprot)
5050 
      self._iprot.readMessageEnd()
5051 
      raise x
5052 
    result = getSnapdealItembySkuAtSnapdeal_result()
5053 
    result.read(self._iprot)
5054 
    self._iprot.readMessageEnd()
5055 
    if result.success is not None:
5056 
      return result.success
5057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItembySkuAtSnapdeal failed: unknown result");
5058 
 
9621 manish.sha 5059 
  def getProductFeedSubmit(self, catalogItemId):
5060 
    """
5061 
    Parameters:
5062 
     - catalogItemId
5063 
    """
5064 
    self.send_getProductFeedSubmit(catalogItemId)
5065 
    return self.recv_getProductFeedSubmit()
9456 vikram.rag 5066 
 
9621 manish.sha 5067 
  def send_getProductFeedSubmit(self, catalogItemId):
5068 
    self._oprot.writeMessageBegin('getProductFeedSubmit', TMessageType.CALL, self._seqid)
5069 
    args = getProductFeedSubmit_args()
5070 
    args.catalogItemId = catalogItemId
5071 
    args.write(self._oprot)
5072 
    self._oprot.writeMessageEnd()
5073 
    self._oprot.trans.flush()
5074 
 
5075 
  def recv_getProductFeedSubmit(self, ):
5076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5077 
    if mtype == TMessageType.EXCEPTION:
5078 
      x = TApplicationException()
5079 
      x.read(self._iprot)
5080 
      self._iprot.readMessageEnd()
5081 
      raise x
5082 
    result = getProductFeedSubmit_result()
5083 
    result.read(self._iprot)
5084 
    self._iprot.readMessageEnd()
5085 
    if result.success is not None:
5086 
      return result.success
5087 
    if result.cex is not None:
5088 
      raise result.cex
5089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductFeedSubmit failed: unknown result");
5090 
 
5091 
  def addProductFeedSubmit(self, productFeedSubmit):
5092 
    """
5093 
    Parameters:
5094 
     - productFeedSubmit
5095 
    """
5096 
    self.send_addProductFeedSubmit(productFeedSubmit)
5097 
    return self.recv_addProductFeedSubmit()
5098 
 
5099 
  def send_addProductFeedSubmit(self, productFeedSubmit):
5100 
    self._oprot.writeMessageBegin('addProductFeedSubmit', TMessageType.CALL, self._seqid)
5101 
    args = addProductFeedSubmit_args()
5102 
    args.productFeedSubmit = productFeedSubmit
5103 
    args.write(self._oprot)
5104 
    self._oprot.writeMessageEnd()
5105 
    self._oprot.trans.flush()
5106 
 
5107 
  def recv_addProductFeedSubmit(self, ):
5108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5109 
    if mtype == TMessageType.EXCEPTION:
5110 
      x = TApplicationException()
5111 
      x.read(self._iprot)
5112 
      self._iprot.readMessageEnd()
5113 
      raise x
5114 
    result = addProductFeedSubmit_result()
5115 
    result.read(self._iprot)
5116 
    self._iprot.readMessageEnd()
5117 
    if result.success is not None:
5118 
      return result.success
5119 
    if result.cex is not None:
5120 
      raise result.cex
5121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductFeedSubmit failed: unknown result");
5122 
 
5123 
  def updateProductFeedSubmit(self, productFeedSubmit):
5124 
    """
5125 
    Parameters:
5126 
     - productFeedSubmit
5127 
    """
5128 
    self.send_updateProductFeedSubmit(productFeedSubmit)
5129 
    return self.recv_updateProductFeedSubmit()
5130 
 
5131 
  def send_updateProductFeedSubmit(self, productFeedSubmit):
5132 
    self._oprot.writeMessageBegin('updateProductFeedSubmit', TMessageType.CALL, self._seqid)
5133 
    args = updateProductFeedSubmit_args()
5134 
    args.productFeedSubmit = productFeedSubmit
5135 
    args.write(self._oprot)
5136 
    self._oprot.writeMessageEnd()
5137 
    self._oprot.trans.flush()
5138 
 
5139 
  def recv_updateProductFeedSubmit(self, ):
5140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5141 
    if mtype == TMessageType.EXCEPTION:
5142 
      x = TApplicationException()
5143 
      x.read(self._iprot)
5144 
      self._iprot.readMessageEnd()
5145 
      raise x
5146 
    result = updateProductFeedSubmit_result()
5147 
    result.read(self._iprot)
5148 
    self._iprot.readMessageEnd()
5149 
    if result.success is not None:
5150 
      return result.success
5151 
    if result.cex is not None:
5152 
      raise result.cex
5153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateProductFeedSubmit failed: unknown result");
5154 
 
5155 
  def deleteProductFeedSubmit(self, catalogItemId):
5156 
    """
5157 
    Parameters:
5158 
     - catalogItemId
5159 
    """
5160 
    self.send_deleteProductFeedSubmit(catalogItemId)
5161 
    return self.recv_deleteProductFeedSubmit()
5162 
 
5163 
  def send_deleteProductFeedSubmit(self, catalogItemId):
5164 
    self._oprot.writeMessageBegin('deleteProductFeedSubmit', TMessageType.CALL, self._seqid)
5165 
    args = deleteProductFeedSubmit_args()
5166 
    args.catalogItemId = catalogItemId
5167 
    args.write(self._oprot)
5168 
    self._oprot.writeMessageEnd()
5169 
    self._oprot.trans.flush()
5170 
 
5171 
  def recv_deleteProductFeedSubmit(self, ):
5172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5173 
    if mtype == TMessageType.EXCEPTION:
5174 
      x = TApplicationException()
5175 
      x.read(self._iprot)
5176 
      self._iprot.readMessageEnd()
5177 
      raise x
5178 
    result = deleteProductFeedSubmit_result()
5179 
    result.read(self._iprot)
5180 
    self._iprot.readMessageEnd()
5181 
    if result.success is not None:
5182 
      return result.success
5183 
    if result.cex is not None:
5184 
      raise result.cex
5185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteProductFeedSubmit failed: unknown result");
5186 
 
5187 
  def getAllProductFeedSubmit(self, ):
5188 
    self.send_getAllProductFeedSubmit()
5189 
    return self.recv_getAllProductFeedSubmit()
5190 
 
5191 
  def send_getAllProductFeedSubmit(self, ):
5192 
    self._oprot.writeMessageBegin('getAllProductFeedSubmit', TMessageType.CALL, self._seqid)
5193 
    args = getAllProductFeedSubmit_args()
5194 
    args.write(self._oprot)
5195 
    self._oprot.writeMessageEnd()
5196 
    self._oprot.trans.flush()
5197 
 
5198 
  def recv_getAllProductFeedSubmit(self, ):
5199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5200 
    if mtype == TMessageType.EXCEPTION:
5201 
      x = TApplicationException()
5202 
      x.read(self._iprot)
5203 
      self._iprot.readMessageEnd()
5204 
      raise x
5205 
    result = getAllProductFeedSubmit_result()
5206 
    result.read(self._iprot)
5207 
    self._iprot.readMessageEnd()
5208 
    if result.success is not None:
5209 
      return result.success
5210 
    if result.cex is not None:
5211 
      raise result.cex
5212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllProductFeedSubmit failed: unknown result");
5213 
 
5214 
 
5944 mandeep.dh 5215 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
5216 
  def __init__(self, handler):
5217 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
5218 
    self._processMap["addItem"] = Processor.process_addItem
5219 
    self._processMap["updateItem"] = Processor.process_updateItem
5220 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 5221 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 5222 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5223 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5224 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5225 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5226 
    self._processMap["getItem"] = Processor.process_getItem
5227 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5228 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5229 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5230 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5231 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5232 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5233 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5234 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5235 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5236 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5237 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5238 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5239 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5240 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5241 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5242 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5243 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5244 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5245 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5246 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5247 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5248 
    self._processMap["addCategory"] = Processor.process_addCategory
5249 
    self._processMap["getCategory"] = Processor.process_getCategory
5250 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5251 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5252 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5253 
    self._processMap["addTag"] = Processor.process_addTag
5254 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5255 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5256 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5257 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5258 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5259 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5260 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5261 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5262 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5263 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5264 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5265 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5266 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5267 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5268 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5269 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5270 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5271 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5272 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5273 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5274 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5275 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5276 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5277 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5278 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5279 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5280 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5281 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5282 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5283 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5284 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5285 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5286 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5287 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5288 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5289 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5290 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5291 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5292 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5293 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5294 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5295 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5296 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5297 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5298 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5299 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5300 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5301 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5302 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5303 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5304 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5305 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5306 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5307 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5308 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5309 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5310 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5311 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5312 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5313 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5314 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5315 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5316 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5317 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5318 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5319 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5320 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5321 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5322 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5323 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5324 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5325 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5326 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5327 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5328 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5329 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5330 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5331 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5332 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5333 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5334 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5335 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5336 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5337 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5338 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5339 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5340 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5341 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5342 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5343 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5344 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5345 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5346 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5347 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5348 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
9456 vikram.rag 5349 
    self._processMap["getSnapdealItembySkuAtSnapdeal"] = Processor.process_getSnapdealItembySkuAtSnapdeal
9621 manish.sha 5350 
    self._processMap["getProductFeedSubmit"] = Processor.process_getProductFeedSubmit
5351 
    self._processMap["addProductFeedSubmit"] = Processor.process_addProductFeedSubmit
5352 
    self._processMap["updateProductFeedSubmit"] = Processor.process_updateProductFeedSubmit
5353 
    self._processMap["deleteProductFeedSubmit"] = Processor.process_deleteProductFeedSubmit
5354 
    self._processMap["getAllProductFeedSubmit"] = Processor.process_getAllProductFeedSubmit
5944 mandeep.dh 5355 
 
5356 
  def process(self, iprot, oprot):
5357 
    (name, type, seqid) = iprot.readMessageBegin()
5358 
    if name not in self._processMap:
5359 
      iprot.skip(TType.STRUCT)
5360 
      iprot.readMessageEnd()
5361 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5362 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5363 
      x.write(oprot)
5364 
      oprot.writeMessageEnd()
5365 
      oprot.trans.flush()
5366 
      return
5367 
    else:
5368 
      self._processMap[name](self, seqid, iprot, oprot)
5369 
    return True
5370 
 
5371 
  def process_addItem(self, seqid, iprot, oprot):
5372 
    args = addItem_args()
5373 
    args.read(iprot)
5374 
    iprot.readMessageEnd()
5375 
    result = addItem_result()
5376 
    try:
5377 
      result.success = self._handler.addItem(args.item)
5378 
    except CatalogServiceException, cex:
5379 
      result.cex = cex
5380 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5381 
    result.write(oprot)
5382 
    oprot.writeMessageEnd()
5383 
    oprot.trans.flush()
5384 
 
5385 
  def process_updateItem(self, seqid, iprot, oprot):
5386 
    args = updateItem_args()
5387 
    args.read(iprot)
5388 
    iprot.readMessageEnd()
5389 
    result = updateItem_result()
5390 
    try:
5391 
      result.success = self._handler.updateItem(args.item)
5392 
    except CatalogServiceException, cex:
5393 
      result.cex = cex
5394 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5395 
    result.write(oprot)
5396 
    oprot.writeMessageEnd()
5397 
    oprot.trans.flush()
5398 
 
5399 
  def process_isActive(self, seqid, iprot, oprot):
5400 
    args = isActive_args()
5401 
    args.read(iprot)
5402 
    iprot.readMessageEnd()
5403 
    result = isActive_result()
5404 
    try:
5405 
      result.success = self._handler.isActive(args.itemId)
5406 
    except CatalogServiceException, isex:
5407 
      result.isex = isex
5408 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5409 
    result.write(oprot)
5410 
    oprot.writeMessageEnd()
5411 
    oprot.trans.flush()
5412 
 
7438 amit.gupta 5413 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5414 
    args = getItemsStatus_args()
5415 
    args.read(iprot)
5416 
    iprot.readMessageEnd()
5417 
    result = getItemsStatus_result()
5418 
    try:
5419 
      result.success = self._handler.getItemsStatus(args.itemIds)
5420 
    except CatalogServiceException, isex:
5421 
      result.isex = isex
5422 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5423 
    result.write(oprot)
5424 
    oprot.writeMessageEnd()
5425 
    oprot.trans.flush()
5426 
 
5944 mandeep.dh 5427 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5428 
    args = getItemStatusDescription_args()
5429 
    args.read(iprot)
5430 
    iprot.readMessageEnd()
5431 
    result = getItemStatusDescription_result()
5432 
    try:
5433 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5434 
    except CatalogServiceException, isex:
5435 
      result.isex = isex
5436 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5437 
    result.write(oprot)
5438 
    oprot.writeMessageEnd()
5439 
    oprot.trans.flush()
5440 
 
5441 
  def process_startItemOn(self, seqid, iprot, oprot):
5442 
    args = startItemOn_args()
5443 
    args.read(iprot)
5444 
    iprot.readMessageEnd()
5445 
    result = startItemOn_result()
5446 
    try:
5447 
      self._handler.startItemOn(args.item_id, args.timestamp)
5448 
    except CatalogServiceException, cex:
5449 
      result.cex = cex
5450 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5451 
    result.write(oprot)
5452 
    oprot.writeMessageEnd()
5453 
    oprot.trans.flush()
5454 
 
5455 
  def process_retireItemOn(self, seqid, iprot, oprot):
5456 
    args = retireItemOn_args()
5457 
    args.read(iprot)
5458 
    iprot.readMessageEnd()
5459 
    result = retireItemOn_result()
5460 
    try:
5461 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5462 
    except CatalogServiceException, cex:
5463 
      result.cex = cex
5464 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5465 
    result.write(oprot)
5466 
    oprot.writeMessageEnd()
5467 
    oprot.trans.flush()
5468 
 
5469 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5470 
    args = changeItemStatus_args()
5471 
    args.read(iprot)
5472 
    iprot.readMessageEnd()
5473 
    result = changeItemStatus_result()
5474 
    try:
5475 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5476 
    except CatalogServiceException, cex:
5477 
      result.cex = cex
5478 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5479 
    result.write(oprot)
5480 
    oprot.writeMessageEnd()
5481 
    oprot.trans.flush()
5482 
 
5483 
  def process_getItem(self, seqid, iprot, oprot):
5484 
    args = getItem_args()
5485 
    args.read(iprot)
5486 
    iprot.readMessageEnd()
5487 
    result = getItem_result()
5488 
    try:
5489 
      result.success = self._handler.getItem(args.item_id)
5490 
    except CatalogServiceException, cex:
5491 
      result.cex = cex
5492 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5493 
    result.write(oprot)
5494 
    oprot.writeMessageEnd()
5495 
    oprot.trans.flush()
5496 
 
5497 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5498 
    args = getItemsByCatalogId_args()
5499 
    args.read(iprot)
5500 
    iprot.readMessageEnd()
5501 
    result = getItemsByCatalogId_result()
5502 
    try:
5503 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5504 
    except CatalogServiceException, cex:
5505 
      result.cex = cex
5506 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5507 
    result.write(oprot)
5508 
    oprot.writeMessageEnd()
5509 
    oprot.trans.flush()
5510 
 
5511 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5512 
    args = getValidItemsByCatalogId_args()
5513 
    args.read(iprot)
5514 
    iprot.readMessageEnd()
5515 
    result = getValidItemsByCatalogId_result()
5516 
    try:
5517 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5518 
    except CatalogServiceException, cex:
5519 
      result.cex = cex
5520 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5521 
    result.write(oprot)
5522 
    oprot.writeMessageEnd()
5523 
    oprot.trans.flush()
5524 
 
5525 
  def process_getAllItems(self, seqid, iprot, oprot):
5526 
    args = getAllItems_args()
5527 
    args.read(iprot)
5528 
    iprot.readMessageEnd()
5529 
    result = getAllItems_result()
5530 
    try:
5531 
      result.success = self._handler.getAllItems(args.isActive)
5532 
    except CatalogServiceException, cex:
5533 
      result.cex = cex
5534 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5535 
    result.write(oprot)
5536 
    oprot.writeMessageEnd()
5537 
    oprot.trans.flush()
5538 
 
5539 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5540 
    args = getAllItemsByStatus_args()
5541 
    args.read(iprot)
5542 
    iprot.readMessageEnd()
5543 
    result = getAllItemsByStatus_result()
5544 
    try:
5545 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5546 
    except CatalogServiceException, cex:
5547 
      result.cex = cex
5548 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5549 
    result.write(oprot)
5550 
    oprot.writeMessageEnd()
5551 
    oprot.trans.flush()
5552 
 
5553 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5554 
    args = markItemAsContentComplete_args()
5555 
    args.read(iprot)
5556 
    iprot.readMessageEnd()
5557 
    result = markItemAsContentComplete_result()
5558 
    try:
9253 rajveer 5559 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5560 
    except CatalogServiceException, cex:
5561 
      result.cex = cex
5562 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5563 
    result.write(oprot)
5564 
    oprot.writeMessageEnd()
5565 
    oprot.trans.flush()
5566 
 
5567 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5568 
    args = getAllItemsInRange_args()
5569 
    args.read(iprot)
5570 
    iprot.readMessageEnd()
5571 
    result = getAllItemsInRange_result()
5572 
    try:
5573 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5574 
    except CatalogServiceException, cex:
5575 
      result.cex = cex
5576 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5577 
    result.write(oprot)
5578 
    oprot.writeMessageEnd()
5579 
    oprot.trans.flush()
5580 
 
5581 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5582 
    args = getAllItemsByStatusInRange_args()
5583 
    args.read(iprot)
5584 
    iprot.readMessageEnd()
5585 
    result = getAllItemsByStatusInRange_result()
5586 
    try:
5587 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5588 
    except CatalogServiceException, cex:
5589 
      result.cex = cex
5590 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5591 
    result.write(oprot)
5592 
    oprot.writeMessageEnd()
5593 
    oprot.trans.flush()
5594 
 
5595 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5596 
    args = getItemCountByStatus_args()
5597 
    args.read(iprot)
5598 
    iprot.readMessageEnd()
5599 
    result = getItemCountByStatus_result()
5600 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5601 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5602 
    result.write(oprot)
5603 
    oprot.writeMessageEnd()
5604 
    oprot.trans.flush()
5605 
 
5606 
  def process_getBestSellers(self, seqid, iprot, oprot):
5607 
    args = getBestSellers_args()
5608 
    args.read(iprot)
5609 
    iprot.readMessageEnd()
5610 
    result = getBestSellers_result()
5611 
    try:
5612 
      result.success = self._handler.getBestSellers()
5613 
    except CatalogServiceException, isex:
5614 
      result.isex = isex
5615 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5616 
    result.write(oprot)
5617 
    oprot.writeMessageEnd()
5618 
    oprot.trans.flush()
5619 
 
5620 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5621 
    args = getBestSellersCatalogIds_args()
5622 
    args.read(iprot)
5623 
    iprot.readMessageEnd()
5624 
    result = getBestSellersCatalogIds_result()
5625 
    try:
5626 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5627 
    except CatalogServiceException, cex:
5628 
      result.cex = cex
5629 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5630 
    result.write(oprot)
5631 
    oprot.writeMessageEnd()
5632 
    oprot.trans.flush()
5633 
 
5634 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5635 
    args = getBestSellersCount_args()
5636 
    args.read(iprot)
5637 
    iprot.readMessageEnd()
5638 
    result = getBestSellersCount_result()
5639 
    try:
5640 
      result.success = self._handler.getBestSellersCount()
5641 
    except CatalogServiceException, cex:
5642 
      result.cex = cex
5643 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5644 
    result.write(oprot)
5645 
    oprot.writeMessageEnd()
5646 
    oprot.trans.flush()
5647 
 
5648 
  def process_getBestDeals(self, seqid, iprot, oprot):
5649 
    args = getBestDeals_args()
5650 
    args.read(iprot)
5651 
    iprot.readMessageEnd()
5652 
    result = getBestDeals_result()
5653 
    try:
5654 
      result.success = self._handler.getBestDeals()
5655 
    except CatalogServiceException, isex:
5656 
      result.isex = isex
5657 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5658 
    result.write(oprot)
5659 
    oprot.writeMessageEnd()
5660 
    oprot.trans.flush()
5661 
 
5662 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5663 
    args = getBestDealsCatalogIds_args()
5664 
    args.read(iprot)
5665 
    iprot.readMessageEnd()
5666 
    result = getBestDealsCatalogIds_result()
5667 
    try:
5668 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5669 
    except CatalogServiceException, cex:
5670 
      result.cex = cex
5671 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5672 
    result.write(oprot)
5673 
    oprot.writeMessageEnd()
5674 
    oprot.trans.flush()
5675 
 
5676 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5677 
    args = getBestDealsCount_args()
5678 
    args.read(iprot)
5679 
    iprot.readMessageEnd()
5680 
    result = getBestDealsCount_result()
5681 
    try:
5682 
      result.success = self._handler.getBestDealsCount()
5683 
    except CatalogServiceException, cex:
5684 
      result.cex = cex
5685 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5686 
    result.write(oprot)
5687 
    oprot.writeMessageEnd()
5688 
    oprot.trans.flush()
5689 
 
5690 
  def process_getComingSoon(self, seqid, iprot, oprot):
5691 
    args = getComingSoon_args()
5692 
    args.read(iprot)
5693 
    iprot.readMessageEnd()
5694 
    result = getComingSoon_result()
5695 
    try:
5696 
      result.success = self._handler.getComingSoon()
5697 
    except CatalogServiceException, isex:
5698 
      result.isex = isex
5699 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5700 
    result.write(oprot)
5701 
    oprot.writeMessageEnd()
5702 
    oprot.trans.flush()
5703 
 
5704 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5705 
    args = getComingSoonCatalogIds_args()
5706 
    args.read(iprot)
5707 
    iprot.readMessageEnd()
5708 
    result = getComingSoonCatalogIds_result()
5709 
    try:
5710 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5711 
    except CatalogServiceException, cex:
5712 
      result.cex = cex
5713 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5714 
    result.write(oprot)
5715 
    oprot.writeMessageEnd()
5716 
    oprot.trans.flush()
5717 
 
5718 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5719 
    args = getComingSoonCount_args()
5720 
    args.read(iprot)
5721 
    iprot.readMessageEnd()
5722 
    result = getComingSoonCount_result()
5723 
    try:
5724 
      result.success = self._handler.getComingSoonCount()
5725 
    except CatalogServiceException, cex:
5726 
      result.cex = cex
5727 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5728 
    result.write(oprot)
5729 
    oprot.writeMessageEnd()
5730 
    oprot.trans.flush()
5731 
 
5732 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5733 
    args = getLatestArrivals_args()
5734 
    args.read(iprot)
5735 
    iprot.readMessageEnd()
5736 
    result = getLatestArrivals_result()
5737 
    try:
5738 
      result.success = self._handler.getLatestArrivals()
5739 
    except CatalogServiceException, isex:
5740 
      result.isex = isex
5741 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5742 
    result.write(oprot)
5743 
    oprot.writeMessageEnd()
5744 
    oprot.trans.flush()
5745 
 
5746 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5747 
    args = getLatestArrivalsCatalogIds_args()
5748 
    args.read(iprot)
5749 
    iprot.readMessageEnd()
5750 
    result = getLatestArrivalsCatalogIds_result()
5751 
    try:
5752 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5753 
    except CatalogServiceException, cex:
5754 
      result.cex = cex
5755 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5756 
    result.write(oprot)
5757 
    oprot.writeMessageEnd()
5758 
    oprot.trans.flush()
5759 
 
5760 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5761 
    args = getLatestArrivalsCount_args()
5762 
    args.read(iprot)
5763 
    iprot.readMessageEnd()
5764 
    result = getLatestArrivalsCount_result()
5765 
    try:
5766 
      result.success = self._handler.getLatestArrivalsCount()
5767 
    except CatalogServiceException, cex:
5768 
      result.cex = cex
5769 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5770 
    result.write(oprot)
5771 
    oprot.writeMessageEnd()
5772 
    oprot.trans.flush()
5773 
 
5774 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5775 
    args = generateNewEntityID_args()
5776 
    args.read(iprot)
5777 
    iprot.readMessageEnd()
5778 
    result = generateNewEntityID_result()
5779 
    result.success = self._handler.generateNewEntityID()
5780 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5781 
    result.write(oprot)
5782 
    oprot.writeMessageEnd()
5783 
    oprot.trans.flush()
5784 
 
5785 
  def process_addCategory(self, seqid, iprot, oprot):
5786 
    args = addCategory_args()
5787 
    args.read(iprot)
5788 
    iprot.readMessageEnd()
5789 
    result = addCategory_result()
5790 
    result.success = self._handler.addCategory(args.category)
5791 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5792 
    result.write(oprot)
5793 
    oprot.writeMessageEnd()
5794 
    oprot.trans.flush()
5795 
 
5796 
  def process_getCategory(self, seqid, iprot, oprot):
5797 
    args = getCategory_args()
5798 
    args.read(iprot)
5799 
    iprot.readMessageEnd()
5800 
    result = getCategory_result()
5801 
    result.success = self._handler.getCategory(args.id)
5802 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5803 
    result.write(oprot)
5804 
    oprot.writeMessageEnd()
5805 
    oprot.trans.flush()
5806 
 
5807 
  def process_getAllCategories(self, seqid, iprot, oprot):
5808 
    args = getAllCategories_args()
5809 
    args.read(iprot)
5810 
    iprot.readMessageEnd()
5811 
    result = getAllCategories_result()
5812 
    result.success = self._handler.getAllCategories()
5813 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5814 
    result.write(oprot)
5815 
    oprot.writeMessageEnd()
5816 
    oprot.trans.flush()
5817 
 
5818 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5819 
    args = getAllSimilarItems_args()
5820 
    args.read(iprot)
5821 
    iprot.readMessageEnd()
5822 
    result = getAllSimilarItems_result()
5823 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5824 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5825 
    result.write(oprot)
5826 
    oprot.writeMessageEnd()
5827 
    oprot.trans.flush()
5828 
 
5829 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5830 
    args = addSimilarItem_args()
5831 
    args.read(iprot)
5832 
    iprot.readMessageEnd()
5833 
    result = addSimilarItem_result()
5834 
    try:
5835 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5836 
    except CatalogServiceException, cex:
5837 
      result.cex = cex
5838 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5839 
    result.write(oprot)
5840 
    oprot.writeMessageEnd()
5841 
    oprot.trans.flush()
5842 
 
6512 kshitij.so 5843 
  def process_addTag(self, seqid, iprot, oprot):
5844 
    args = addTag_args()
5845 
    args.read(iprot)
5846 
    iprot.readMessageEnd()
5847 
    result = addTag_result()
5848 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5849 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5850 
    result.write(oprot)
5851 
    oprot.writeMessageEnd()
5852 
    oprot.trans.flush()
5853 
 
5854 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5855 
    args = deleteEntityTag_args()
5856 
    args.read(iprot)
5857 
    iprot.readMessageEnd()
5858 
    result = deleteEntityTag_result()
5859 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5860 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5861 
    result.write(oprot)
5862 
    oprot.writeMessageEnd()
5863 
    oprot.trans.flush()
5864 
 
5865 
  def process_deleteTag(self, seqid, iprot, oprot):
5866 
    args = deleteTag_args()
5867 
    args.read(iprot)
5868 
    iprot.readMessageEnd()
5869 
    result = deleteTag_result()
5870 
    result.success = self._handler.deleteTag(args.displayName)
5871 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5872 
    result.write(oprot)
5873 
    oprot.writeMessageEnd()
5874 
    oprot.trans.flush()
5875 
 
5876 
  def process_getAllTags(self, seqid, iprot, oprot):
5877 
    args = getAllTags_args()
5878 
    args.read(iprot)
5879 
    iprot.readMessageEnd()
5880 
    result = getAllTags_result()
5881 
    result.success = self._handler.getAllTags()
5882 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5883 
    result.write(oprot)
5884 
    oprot.writeMessageEnd()
5885 
    oprot.trans.flush()
5886 
 
5887 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5888 
    args = getAllEntitiesByTagName_args()
5889 
    args.read(iprot)
5890 
    iprot.readMessageEnd()
5891 
    result = getAllEntitiesByTagName_result()
5892 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5893 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5894 
    result.write(oprot)
5895 
    oprot.writeMessageEnd()
5896 
    oprot.trans.flush()
5897 
 
6845 amit.gupta 5898 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5899 
    args = getAllEntityTags_args()
5900 
    args.read(iprot)
5901 
    iprot.readMessageEnd()
5902 
    result = getAllEntityTags_result()
5903 
    result.success = self._handler.getAllEntityTags()
5904 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5905 
    result.write(oprot)
5906 
    oprot.writeMessageEnd()
5907 
    oprot.trans.flush()
5908 
 
6850 kshitij.so 5909 
  def process_addBanner(self, seqid, iprot, oprot):
5910 
    args = addBanner_args()
5911 
    args.read(iprot)
5912 
    iprot.readMessageEnd()
5913 
    result = addBanner_result()
8590 kshitij.so 5914 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5915 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5916 
    result.write(oprot)
5917 
    oprot.writeMessageEnd()
5918 
    oprot.trans.flush()
5919 
 
8579 kshitij.so 5920 
  def process_updateBanner(self, seqid, iprot, oprot):
5921 
    args = updateBanner_args()
5922 
    args.read(iprot)
5923 
    iprot.readMessageEnd()
5924 
    result = updateBanner_result()
5925 
    result.success = self._handler.updateBanner(args.banner)
5926 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5927 
    result.write(oprot)
5928 
    oprot.writeMessageEnd()
5929 
    oprot.trans.flush()
5930 
 
6850 kshitij.so 5931 
  def process_getAllBanners(self, seqid, iprot, oprot):
5932 
    args = getAllBanners_args()
5933 
    args.read(iprot)
5934 
    iprot.readMessageEnd()
5935 
    result = getAllBanners_result()
5936 
    result.success = self._handler.getAllBanners()
5937 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5938 
    result.write(oprot)
5939 
    oprot.writeMessageEnd()
5940 
    oprot.trans.flush()
5941 
 
5942 
  def process_deleteBanner(self, seqid, iprot, oprot):
5943 
    args = deleteBanner_args()
5944 
    args.read(iprot)
5945 
    iprot.readMessageEnd()
5946 
    result = deleteBanner_result()
9155 kshitij.so 5947 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 5948 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5949 
    result.write(oprot)
5950 
    oprot.writeMessageEnd()
5951 
    oprot.trans.flush()
5952 
 
5953 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5954 
    args = getBannerDetails_args()
5955 
    args.read(iprot)
5956 
    iprot.readMessageEnd()
5957 
    result = getBannerDetails_result()
9155 kshitij.so 5958 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 5959 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5960 
    result.write(oprot)
5961 
    oprot.writeMessageEnd()
5962 
    oprot.trans.flush()
5963 
 
5964 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5965 
    args = getActiveBanners_args()
5966 
    args.read(iprot)
5967 
    iprot.readMessageEnd()
5968 
    result = getActiveBanners_result()
5969 
    result.success = self._handler.getActiveBanners()
5970 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5971 
    result.write(oprot)
5972 
    oprot.writeMessageEnd()
5973 
    oprot.trans.flush()
5974 
 
6849 kshitij.so 5975 
  def process_addBannerMap(self, seqid, iprot, oprot):
5976 
    args = addBannerMap_args()
5977 
    args.read(iprot)
5978 
    iprot.readMessageEnd()
5979 
    result = addBannerMap_result()
8579 kshitij.so 5980 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5981 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5982 
    result.write(oprot)
5983 
    oprot.writeMessageEnd()
5984 
    oprot.trans.flush()
5985 
 
8579 kshitij.so 5986 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5987 
    args = updateBannerMap_args()
5988 
    args.read(iprot)
5989 
    iprot.readMessageEnd()
5990 
    result = updateBannerMap_result()
5991 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5992 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5993 
    result.write(oprot)
5994 
    oprot.writeMessageEnd()
5995 
    oprot.trans.flush()
5996 
 
6849 kshitij.so 5997 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5998 
    args = deleteBannerMap_args()
5999 
    args.read(iprot)
6000 
    iprot.readMessageEnd()
6001 
    result = deleteBannerMap_result()
6002 
    result.success = self._handler.deleteBannerMap(args.bannerName)
6003 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
6004 
    result.write(oprot)
6005 
    oprot.writeMessageEnd()
6006 
    oprot.trans.flush()
6007 
 
6008 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
6009 
    args = getBannerMapDetails_args()
6010 
    args.read(iprot)
6011 
    iprot.readMessageEnd()
6012 
    result = getBannerMapDetails_result()
9155 kshitij.so 6013 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 6014 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
6015 
    result.write(oprot)
6016 
    oprot.writeMessageEnd()
6017 
    oprot.trans.flush()
6018 
 
8579 kshitij.so 6019 
  def process_addBannerUri(self, seqid, iprot, oprot):
6020 
    args = addBannerUri_args()
6021 
    args.read(iprot)
6022 
    iprot.readMessageEnd()
6023 
    result = addBannerUri_result()
6024 
    self._handler.addBannerUri(args.bannerUriMappings)
6025 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
6026 
    result.write(oprot)
6027 
    oprot.writeMessageEnd()
6028 
    oprot.trans.flush()
6029 
 
6030 
  def process_getUriMapping(self, seqid, iprot, oprot):
6031 
    args = getUriMapping_args()
6032 
    args.read(iprot)
6033 
    iprot.readMessageEnd()
6034 
    result = getUriMapping_result()
9155 kshitij.so 6035 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 6036 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
6037 
    result.write(oprot)
6038 
    oprot.writeMessageEnd()
6039 
    oprot.trans.flush()
6040 
 
6041 
  def process_addCampaign(self, seqid, iprot, oprot):
6042 
    args = addCampaign_args()
6043 
    args.read(iprot)
6044 
    iprot.readMessageEnd()
6045 
    result = addCampaign_result()
6046 
    self._handler.addCampaign(args.campaign)
6047 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
6048 
    result.write(oprot)
6049 
    oprot.writeMessageEnd()
6050 
    oprot.trans.flush()
6051 
 
6052 
  def process_getCampaigns(self, seqid, iprot, oprot):
6053 
    args = getCampaigns_args()
6054 
    args.read(iprot)
6055 
    iprot.readMessageEnd()
6056 
    result = getCampaigns_result()
6057 
    result.success = self._handler.getCampaigns(args.campaignName)
6058 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
6059 
    result.write(oprot)
6060 
    oprot.writeMessageEnd()
6061 
    oprot.trans.flush()
6062 
 
6063 
  def process_deleteCampaign(self, seqid, iprot, oprot):
6064 
    args = deleteCampaign_args()
6065 
    args.read(iprot)
6066 
    iprot.readMessageEnd()
6067 
    result = deleteCampaign_result()
6068 
    self._handler.deleteCampaign(args.campaignId)
6069 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
6070 
    result.write(oprot)
6071 
    oprot.writeMessageEnd()
6072 
    oprot.trans.flush()
6073 
 
6074 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
6075 
    args = getAllCampaigns_args()
6076 
    args.read(iprot)
6077 
    iprot.readMessageEnd()
6078 
    result = getAllCampaigns_result()
6079 
    result.success = self._handler.getAllCampaigns()
6080 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
6081 
    result.write(oprot)
6082 
    oprot.writeMessageEnd()
6083 
    oprot.trans.flush()
6084 
 
9155 kshitij.so 6085 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
6086 
    args = getActiveBannersForMobileSite_args()
6087 
    args.read(iprot)
6088 
    iprot.readMessageEnd()
6089 
    result = getActiveBannersForMobileSite_result()
6090 
    result.success = self._handler.getActiveBannersForMobileSite()
6091 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
6092 
    result.write(oprot)
6093 
    oprot.writeMessageEnd()
6094 
    oprot.trans.flush()
6095 
 
5944 mandeep.dh 6096 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
6097 
    args = deleteSimilarItem_args()
6098 
    args.read(iprot)
6099 
    iprot.readMessageEnd()
6100 
    result = deleteSimilarItem_result()
6101 
    try:
6102 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
6103 
    except CatalogServiceException, cex:
6104 
      result.cex = cex
6105 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
6106 
    result.write(oprot)
6107 
    oprot.writeMessageEnd()
6108 
    oprot.trans.flush()
6109 
 
6110 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
6111 
    args = checkSimilarItem_args()
6112 
    args.read(iprot)
6113 
    iprot.readMessageEnd()
6114 
    result = checkSimilarItem_result()
6115 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
6116 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
6117 
    result.write(oprot)
6118 
    oprot.writeMessageEnd()
6119 
    oprot.trans.flush()
6120 
 
6121 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
6122 
    args = validateRiskyStatus_args()
6123 
    args.read(iprot)
6124 
    iprot.readMessageEnd()
6125 
    result = validateRiskyStatus_result()
6126 
    self._handler.validateRiskyStatus(args.itemId)
6127 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
6128 
    result.write(oprot)
6129 
    oprot.writeMessageEnd()
6130 
    oprot.trans.flush()
6131 
 
6132 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
6133 
    args = changeItemRiskyFlag_args()
6134 
    args.read(iprot)
6135 
    iprot.readMessageEnd()
6136 
    result = changeItemRiskyFlag_result()
6137 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
6138 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
6139 
    result.write(oprot)
6140 
    oprot.writeMessageEnd()
6141 
    oprot.trans.flush()
6142 
 
6143 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
6144 
    args = getItemsByRiskyFlag_args()
6145 
    args.read(iprot)
6146 
    iprot.readMessageEnd()
6147 
    result = getItemsByRiskyFlag_result()
6148 
    result.success = self._handler.getItemsByRiskyFlag()
6149 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
6150 
    result.write(oprot)
6151 
    oprot.writeMessageEnd()
6152 
    oprot.trans.flush()
6153 
 
6154 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
6155 
    args = getItemsForMasterSheet_args()
6156 
    args.read(iprot)
6157 
    iprot.readMessageEnd()
6158 
    result = getItemsForMasterSheet_result()
6159 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
6160 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
6161 
    result.write(oprot)
6162 
    oprot.writeMessageEnd()
6163 
    oprot.trans.flush()
6164 
 
6165 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
6166 
    args = getSimilarItemsCatalogIds_args()
6167 
    args.read(iprot)
6168 
    iprot.readMessageEnd()
6169 
    result = getSimilarItemsCatalogIds_result()
6170 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
6171 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
6172 
    result.write(oprot)
6173 
    oprot.writeMessageEnd()
6174 
    oprot.trans.flush()
6175 
 
6176 
  def process_addProductNotification(self, seqid, iprot, oprot):
6177 
    args = addProductNotification_args()
6178 
    args.read(iprot)
6179 
    iprot.readMessageEnd()
6180 
    result = addProductNotification_result()
6181 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
6182 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
6183 
    result.write(oprot)
6184 
    oprot.writeMessageEnd()
6185 
    oprot.trans.flush()
6186 
 
6187 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
6188 
    args = sendProductNotifications_args()
6189 
    args.read(iprot)
6190 
    iprot.readMessageEnd()
6191 
    result = sendProductNotifications_result()
6192 
    result.success = self._handler.sendProductNotifications()
6193 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
6194 
    result.write(oprot)
6195 
    oprot.writeMessageEnd()
6196 
    oprot.trans.flush()
6197 
 
6198 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
6199 
    args = getAllBrandsByCategory_args()
6200 
    args.read(iprot)
6201 
    iprot.readMessageEnd()
6202 
    result = getAllBrandsByCategory_result()
6203 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
6204 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
6205 
    result.write(oprot)
6206 
    oprot.writeMessageEnd()
6207 
    oprot.trans.flush()
6208 
 
6209 
  def process_getAllBrands(self, seqid, iprot, oprot):
6210 
    args = getAllBrands_args()
6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
6213 
    result = getAllBrands_result()
6214 
    result.success = self._handler.getAllBrands()
6215 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
6216 
    result.write(oprot)
6217 
    oprot.writeMessageEnd()
6218 
    oprot.trans.flush()
6219 
 
6220 
  def process_getAllSources(self, seqid, iprot, oprot):
6221 
    args = getAllSources_args()
6222 
    args.read(iprot)
6223 
    iprot.readMessageEnd()
6224 
    result = getAllSources_result()
6225 
    result.success = self._handler.getAllSources()
6226 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
6230 
 
6231 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6232 
    args = getItemPricingBySource_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = getItemPricingBySource_result()
6236 
    try:
6237 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6238 
    except CatalogServiceException, cex:
6239 
      result.cex = cex
6240 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6241 
    result.write(oprot)
6242 
    oprot.writeMessageEnd()
6243 
    oprot.trans.flush()
6244 
 
6245 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6246 
    args = addSourceItemPricing_args()
6247 
    args.read(iprot)
6248 
    iprot.readMessageEnd()
6249 
    result = addSourceItemPricing_result()
6250 
    try:
6251 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6252 
    except CatalogServiceException, cex:
6253 
      result.cex = cex
6254 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6255 
    result.write(oprot)
6256 
    oprot.writeMessageEnd()
6257 
    oprot.trans.flush()
6258 
 
6259 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6260 
    args = getAllSourcePricing_args()
6261 
    args.read(iprot)
6262 
    iprot.readMessageEnd()
6263 
    result = getAllSourcePricing_result()
6264 
    try:
6265 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6266 
    except CatalogServiceException, cex:
6267 
      result.cex = cex
6268 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6269 
    result.write(oprot)
6270 
    oprot.writeMessageEnd()
6271 
    oprot.trans.flush()
6272 
 
6273 
  def process_getItemForSource(self, seqid, iprot, oprot):
6274 
    args = getItemForSource_args()
6275 
    args.read(iprot)
6276 
    iprot.readMessageEnd()
6277 
    result = getItemForSource_result()
6278 
    try:
6279 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6280 
    except CatalogServiceException, cex:
6281 
      result.cex = cex
6282 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6283 
    result.write(oprot)
6284 
    oprot.writeMessageEnd()
6285 
    oprot.trans.flush()
6286 
 
6287 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6288 
    args = searchItemsInRange_args()
6289 
    args.read(iprot)
6290 
    iprot.readMessageEnd()
6291 
    result = searchItemsInRange_result()
6292 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6293 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6294 
    result.write(oprot)
6295 
    oprot.writeMessageEnd()
6296 
    oprot.trans.flush()
6297 
 
6298 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6299 
    args = getSearchResultCount_args()
6300 
    args.read(iprot)
6301 
    iprot.readMessageEnd()
6302 
    result = getSearchResultCount_result()
6303 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6304 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6305 
    result.write(oprot)
6306 
    oprot.writeMessageEnd()
6307 
    oprot.trans.flush()
6308 
 
6309 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6310 
    args = getProductNotifications_args()
6311 
    args.read(iprot)
6312 
    iprot.readMessageEnd()
6313 
    result = getProductNotifications_result()
6314 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6315 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6316 
    result.write(oprot)
6317 
    oprot.writeMessageEnd()
6318 
    oprot.trans.flush()
6319 
 
6320 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6321 
    args = getProductNotificationRequestCount_args()
6322 
    args.read(iprot)
6323 
    iprot.readMessageEnd()
6324 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6325 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6326 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6327 
    result.write(oprot)
6328 
    oprot.writeMessageEnd()
6329 
    oprot.trans.flush()
6330 
 
6331 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6332 
    args = addAuthorizationLog_args()
6333 
    args.read(iprot)
6334 
    iprot.readMessageEnd()
6335 
    result = addAuthorizationLog_result()
6336 
    try:
6337 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6338 
    except CatalogServiceException, cex:
6339 
      result.cex = cex
6340 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6341 
    result.write(oprot)
6342 
    oprot.writeMessageEnd()
6343 
    oprot.trans.flush()
6344 
 
6345 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6346 
    args = addupdateVoucherForItem_args()
6347 
    args.read(iprot)
6348 
    iprot.readMessageEnd()
6349 
    result = addupdateVoucherForItem_result()
6350 
    try:
6351 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6352 
    except CatalogServiceException, cex:
6353 
      result.cex = cex
6354 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6355 
    result.write(oprot)
6356 
    oprot.writeMessageEnd()
6357 
    oprot.trans.flush()
6358 
 
6359 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6360 
    args = deleteVoucherForItem_args()
6361 
    args.read(iprot)
6362 
    iprot.readMessageEnd()
6363 
    result = deleteVoucherForItem_result()
6364 
    try:
6365 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6366 
    except CatalogServiceException, cex:
6367 
      result.cex = cex
6368 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6369 
    result.write(oprot)
6370 
    oprot.writeMessageEnd()
6371 
    oprot.trans.flush()
6372 
 
6373 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6374 
    args = getVoucherAmount_args()
6375 
    args.read(iprot)
6376 
    iprot.readMessageEnd()
6377 
    result = getVoucherAmount_result()
6378 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6379 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6380 
    result.write(oprot)
6381 
    oprot.writeMessageEnd()
6382 
    oprot.trans.flush()
6383 
 
6384 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6385 
    args = getAllItemVouchers_args()
6386 
    args.read(iprot)
6387 
    iprot.readMessageEnd()
6388 
    result = getAllItemVouchers_result()
6389 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6390 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6391 
    result.write(oprot)
6392 
    oprot.writeMessageEnd()
6393 
    oprot.trans.flush()
6394 
 
6395 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6396 
    args = isValidCatalogItemId_args()
6397 
    args.read(iprot)
6398 
    iprot.readMessageEnd()
6399 
    result = isValidCatalogItemId_result()
6400 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6401 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6402 
    result.write(oprot)
6403 
    oprot.writeMessageEnd()
6404 
    oprot.trans.flush()
6405 
 
6039 amit.gupta 6406 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6407 
    args = getVatPercentageForItem_args()
6408 
    args.read(iprot)
6409 
    iprot.readMessageEnd()
6410 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6411 
    try:
6412 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6413 
    except CatalogServiceException, cex:
6414 
      result.cex = cex
6039 amit.gupta 6415 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6416 
    result.write(oprot)
6417 
    oprot.writeMessageEnd()
6418 
    oprot.trans.flush()
5944 mandeep.dh 6419 
 
6039 amit.gupta 6420 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6421 
    args = getVatAmountForItem_args()
6422 
    args.read(iprot)
6423 
    iprot.readMessageEnd()
6424 
    result = getVatAmountForItem_result()
6425 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6426 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6427 
    result.write(oprot)
6428 
    oprot.writeMessageEnd()
6429 
    oprot.trans.flush()
6430 
 
6531 vikram.rag 6431 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6432 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6433 
    args.read(iprot)
6434 
    iprot.readMessageEnd()
6435 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6436 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6437 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6438 
    result.write(oprot)
6439 
    oprot.writeMessageEnd()
6440 
    oprot.trans.flush()
6039 amit.gupta 6441 
 
6821 amar.kumar 6442 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6443 
    args = getAllAliveItems_args()
6444 
    args.read(iprot)
6445 
    iprot.readMessageEnd()
6446 
    result = getAllAliveItems_result()
6447 
    result.success = self._handler.getAllAliveItems()
6448 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6449 
    result.write(oprot)
6450 
    oprot.writeMessageEnd()
6451 
    oprot.trans.flush()
6452 
 
6805 anupam.sin 6453 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6454 
    args = getInsuranceAmount_args()
6455 
    args.read(iprot)
6456 
    iprot.readMessageEnd()
6457 
    result = getInsuranceAmount_result()
6921 anupam.sin 6458 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6459 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6460 
    result.write(oprot)
6461 
    oprot.writeMessageEnd()
6462 
    oprot.trans.flush()
6531 vikram.rag 6463 
 
6805 anupam.sin 6464 
  def process_getInsurer(self, seqid, iprot, oprot):
6465 
    args = getInsurer_args()
6466 
    args.read(iprot)
6467 
    iprot.readMessageEnd()
6468 
    result = getInsurer_result()
6469 
    result.success = self._handler.getInsurer(args.insurerId)
6470 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6471 
    result.write(oprot)
6472 
    oprot.writeMessageEnd()
6473 
    oprot.trans.flush()
6474 
 
6838 vikram.rag 6475 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6476 
    args = getAllInsurers_args()
6477 
    args.read(iprot)
6478 
    iprot.readMessageEnd()
6479 
    result = getAllInsurers_result()
6480 
    result.success = self._handler.getAllInsurers()
6481 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6482 
    result.write(oprot)
6483 
    oprot.writeMessageEnd()
6484 
    oprot.trans.flush()
6805 anupam.sin 6485 
 
6962 rajveer 6486 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6487 
    args = updateInsuranceDeclaredAmount_args()
6488 
    args.read(iprot)
6489 
    iprot.readMessageEnd()
6490 
    result = updateInsuranceDeclaredAmount_result()
6491 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6492 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6493 
    result.write(oprot)
6494 
    oprot.writeMessageEnd()
6495 
    oprot.trans.flush()
6838 vikram.rag 6496 
 
7190 amar.kumar 6497 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6498 
    args = getFreebieForItem_args()
6499 
    args.read(iprot)
6500 
    iprot.readMessageEnd()
6501 
    result = getFreebieForItem_result()
6502 
    result.success = self._handler.getFreebieForItem(args.itemId)
6503 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6504 
    result.write(oprot)
6505 
    oprot.writeMessageEnd()
6506 
    oprot.trans.flush()
6962 rajveer 6507 
 
7190 amar.kumar 6508 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6509 
    args = addOrUpdateFreebieForItem_args()
6510 
    args.read(iprot)
6511 
    iprot.readMessageEnd()
6512 
    result = addOrUpdateFreebieForItem_result()
6513 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6514 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6515 
    result.write(oprot)
6516 
    oprot.writeMessageEnd()
6517 
    oprot.trans.flush()
6518 
 
7272 amit.gupta 6519 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6520 
    args = addOrUpdateBrandInfo_args()
6521 
    args.read(iprot)
6522 
    iprot.readMessageEnd()
6523 
    result = addOrUpdateBrandInfo_result()
6524 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6525 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6526 
    result.write(oprot)
6527 
    oprot.writeMessageEnd()
6528 
    oprot.trans.flush()
6529 
 
6530 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6531 
    args = getBrandInfo_args()
6532 
    args.read(iprot)
6533 
    iprot.readMessageEnd()
6534 
    result = getBrandInfo_result()
6535 
    result.success = self._handler.getBrandInfo()
6536 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6537 
    result.write(oprot)
6538 
    oprot.writeMessageEnd()
6539 
    oprot.trans.flush()
6540 
 
7256 rajveer 6541 
  def process_getStorePricing(self, seqid, iprot, oprot):
6542 
    args = getStorePricing_args()
6543 
    args.read(iprot)
6544 
    iprot.readMessageEnd()
6545 
    result = getStorePricing_result()
6546 
    result.success = self._handler.getStorePricing(args.itemId)
6547 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6548 
    result.write(oprot)
6549 
    oprot.writeMessageEnd()
6550 
    oprot.trans.flush()
7190 amar.kumar 6551 
 
7306 rajveer 6552 
  def process_getStorePricings(self, seqid, iprot, oprot):
6553 
    args = getStorePricings_args()
6554 
    args.read(iprot)
6555 
    iprot.readMessageEnd()
6556 
    result = getStorePricings_result()
6557 
    result.success = self._handler.getStorePricings(args.itemIds)
6558 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6559 
    result.write(oprot)
6560 
    oprot.writeMessageEnd()
6561 
    oprot.trans.flush()
6562 
 
7265 rajveer 6563 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6564 
    args = updateStorePricing_args()
6565 
    args.read(iprot)
6566 
    iprot.readMessageEnd()
6567 
    result = updateStorePricing_result()
7382 rajveer 6568 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6569 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6570 
    result.write(oprot)
6571 
    oprot.writeMessageEnd()
6572 
    oprot.trans.flush()
7256 rajveer 6573 
 
7281 kshitij.so 6574 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6575 
    args = getAllAmazonListedItems_args()
6576 
    args.read(iprot)
6577 
    iprot.readMessageEnd()
6578 
    result = getAllAmazonListedItems_result()
6579 
    result.success = self._handler.getAllAmazonListedItems()
6580 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6581 
    result.write(oprot)
6582 
    oprot.writeMessageEnd()
6583 
    oprot.trans.flush()
7265 rajveer 6584 
 
8619 kshitij.so 6585 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6586 
    args = searchAmazonItems_args()
6587 
    args.read(iprot)
6588 
    iprot.readMessageEnd()
6589 
    result = searchAmazonItems_result()
6590 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6591 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6592 
    result.write(oprot)
6593 
    oprot.writeMessageEnd()
6594 
    oprot.trans.flush()
6595 
 
6596 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6597 
    args = getAmazonSearchResultCount_args()
6598 
    args.read(iprot)
6599 
    iprot.readMessageEnd()
6600 
    result = getAmazonSearchResultCount_result()
6601 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6602 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6603 
    result.write(oprot)
6604 
    oprot.writeMessageEnd()
6605 
    oprot.trans.flush()
6606 
 
6607 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6608 
    args = getCountForAmazonlistedItems_args()
6609 
    args.read(iprot)
6610 
    iprot.readMessageEnd()
6611 
    result = getCountForAmazonlistedItems_result()
6612 
    result.success = self._handler.getCountForAmazonlistedItems()
6613 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6614 
    result.write(oprot)
6615 
    oprot.writeMessageEnd()
6616 
    oprot.trans.flush()
6617 
 
7281 kshitij.so 6618 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6619 
    args = getAmazonItemDetails_args()
6620 
    args.read(iprot)
6621 
    iprot.readMessageEnd()
6622 
    result = getAmazonItemDetails_result()
6623 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6624 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6625 
    result.write(oprot)
6626 
    oprot.writeMessageEnd()
6627 
    oprot.trans.flush()
6628 
 
6629 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6630 
    args = updateAmazonItemDetails_args()
6631 
    args.read(iprot)
6632 
    iprot.readMessageEnd()
6633 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6634 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6635 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6636 
    result.write(oprot)
6637 
    oprot.writeMessageEnd()
6638 
    oprot.trans.flush()
6639 
 
6640 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6641 
    args = addAmazonItem_args()
6642 
    args.read(iprot)
6643 
    iprot.readMessageEnd()
6644 
    result = addAmazonItem_result()
6645 
    self._handler.addAmazonItem(args.amazonlisted)
6646 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6647 
    result.write(oprot)
6648 
    oprot.writeMessageEnd()
6649 
    oprot.trans.flush()
6650 
 
7291 vikram.rag 6651 
  def process_getAsinItems(self, seqid, iprot, oprot):
6652 
    args = getAsinItems_args()
6653 
    args.read(iprot)
6654 
    iprot.readMessageEnd()
6655 
    result = getAsinItems_result()
6656 
    result.success = self._handler.getAsinItems()
6657 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6658 
    result.write(oprot)
6659 
    oprot.writeMessageEnd()
6660 
    oprot.trans.flush()
7281 kshitij.so 6661 
 
7291 vikram.rag 6662 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6663 
    args = getAllFbaListedItems_args()
6664 
    args.read(iprot)
6665 
    iprot.readMessageEnd()
6666 
    result = getAllFbaListedItems_result()
6667 
    result.success = self._handler.getAllFbaListedItems()
6668 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6669 
    result.write(oprot)
6670 
    oprot.writeMessageEnd()
6671 
    oprot.trans.flush()
6672 
 
6673 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6674 
    args = getAllNonFbaListedItems_args()
6675 
    args.read(iprot)
6676 
    iprot.readMessageEnd()
6677 
    result = getAllNonFbaListedItems_result()
6678 
    result.success = self._handler.getAllNonFbaListedItems()
6679 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6680 
    result.write(oprot)
6681 
    oprot.writeMessageEnd()
6682 
    oprot.trans.flush()
6683 
 
7460 kshitij.so 6684 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6685 
    args = updateItemInventory_args()
6686 
    args.read(iprot)
6687 
    iprot.readMessageEnd()
6688 
    result = updateItemInventory_result()
6689 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6690 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6691 
    result.write(oprot)
6692 
    oprot.writeMessageEnd()
6693 
    oprot.trans.flush()
7291 vikram.rag 6694 
 
7770 kshitij.so 6695 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6696 
    args = updateTimestampForAmazonFeeds_args()
6697 
    args.read(iprot)
6698 
    iprot.readMessageEnd()
6699 
    result = updateTimestampForAmazonFeeds_result()
6700 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6701 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6702 
    result.write(oprot)
6703 
    oprot.writeMessageEnd()
6704 
    oprot.trans.flush()
7460 kshitij.so 6705 
 
7897 amar.kumar 6706 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6707 
    args = getAllParentCategories_args()
6708 
    args.read(iprot)
6709 
    iprot.readMessageEnd()
6710 
    result = getAllParentCategories_result()
6711 
    result.success = self._handler.getAllParentCategories()
6712 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6713 
    result.write(oprot)
6714 
    oprot.writeMessageEnd()
6715 
    oprot.trans.flush()
7770 kshitij.so 6716 
 
7977 kshitij.so 6717 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6718 
    args = addPageViewEvent_args()
6719 
    args.read(iprot)
6720 
    iprot.readMessageEnd()
6721 
    result = addPageViewEvent_result()
6722 
    self._handler.addPageViewEvent(args.pageViewEvents)
6723 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6724 
    result.write(oprot)
6725 
    oprot.writeMessageEnd()
6726 
    oprot.trans.flush()
7897 amar.kumar 6727 
 
7977 kshitij.so 6728 
  def process_addCartEvent(self, seqid, iprot, oprot):
6729 
    args = addCartEvent_args()
6730 
    args.read(iprot)
6731 
    iprot.readMessageEnd()
6732 
    result = addCartEvent_result()
6733 
    self._handler.addCartEvent(args.cartEvents)
6734 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6735 
    result.write(oprot)
6736 
    oprot.writeMessageEnd()
6737 
    oprot.trans.flush()
6738 
 
8182 amar.kumar 6739 
  def process_addEbayItem(self, seqid, iprot, oprot):
6740 
    args = addEbayItem_args()
6741 
    args.read(iprot)
6742 
    iprot.readMessageEnd()
6743 
    result = addEbayItem_result()
6744 
    self._handler.addEbayItem(args.ebayItem)
6745 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6746 
    result.write(oprot)
6747 
    oprot.writeMessageEnd()
6748 
    oprot.trans.flush()
6749 
 
6750 
  def process_getEbayItem(self, seqid, iprot, oprot):
6751 
    args = getEbayItem_args()
6752 
    args.read(iprot)
6753 
    iprot.readMessageEnd()
6754 
    result = getEbayItem_result()
6755 
    result.success = self._handler.getEbayItem(args.listingId)
6756 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6757 
    result.write(oprot)
6758 
    oprot.writeMessageEnd()
6759 
    oprot.trans.flush()
6760 
 
6761 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6762 
    args = updateEbayItem_args()
6763 
    args.read(iprot)
6764 
    iprot.readMessageEnd()
6765 
    result = updateEbayItem_result()
6766 
    self._handler.updateEbayItem(args.ebayItem)
6767 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6768 
    result.write(oprot)
6769 
    oprot.writeMessageEnd()
6770 
    oprot.trans.flush()
6771 
 
8139 kshitij.so 6772 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6773 
    args = getAmazonListedItems_args()
6774 
    args.read(iprot)
6775 
    iprot.readMessageEnd()
6776 
    result = getAmazonListedItems_result()
6777 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6778 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6779 
    result.write(oprot)
6780 
    oprot.writeMessageEnd()
6781 
    oprot.trans.flush()
7977 kshitij.so 6782 
 
8168 kshitij.so 6783 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6784 
    args = updateAmazonAttributesInBulk_args()
6785 
    args.read(iprot)
6786 
    iprot.readMessageEnd()
6787 
    result = updateAmazonAttributesInBulk_result()
6788 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6789 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6790 
    result.write(oprot)
6791 
    oprot.writeMessageEnd()
6792 
    oprot.trans.flush()
8139 kshitij.so 6793 
 
8379 vikram.rag 6794 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6795 
    args = getAllItemstoListOnFba_args()
6796 
    args.read(iprot)
6797 
    iprot.readMessageEnd()
6798 
    result = getAllItemstoListOnFba_result()
6799 
    result.success = self._handler.getAllItemstoListOnFba()
6800 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6801 
    result.write(oprot)
6802 
    oprot.writeMessageEnd()
6803 
    oprot.trans.flush()
8168 kshitij.so 6804 
 
8379 vikram.rag 6805 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6806 
    args = getAllItemstoListOnNonFba_args()
6807 
    args.read(iprot)
6808 
    iprot.readMessageEnd()
6809 
    result = getAllItemstoListOnNonFba_result()
6810 
    result.success = self._handler.getAllItemstoListOnNonFba()
6811 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6812 
    result.write(oprot)
6813 
    oprot.writeMessageEnd()
6814 
    oprot.trans.flush()
6815 
 
8619 kshitij.so 6816 
  def process_updateAsin(self, seqid, iprot, oprot):
6817 
    args = updateAsin_args()
6818 
    args.read(iprot)
6819 
    iprot.readMessageEnd()
6820 
    result = updateAsin_result()
6821 
    self._handler.updateAsin(args.item)
6822 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6823 
    result.write(oprot)
6824 
    oprot.writeMessageEnd()
6825 
    oprot.trans.flush()
8616 vikram.rag 6826 
 
8739 vikram.rag 6827 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
6828 
    args = addOrUpdateSnapdealItem_args()
6829 
    args.read(iprot)
6830 
    iprot.readMessageEnd()
6831 
    result = addOrUpdateSnapdealItem_result()
6832 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
6833 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
6834 
    result.write(oprot)
6835 
    oprot.writeMessageEnd()
6836 
    oprot.trans.flush()
8619 kshitij.so 6837 
 
8739 vikram.rag 6838 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
6839 
    args = getSnapdealItem_args()
6840 
    args.read(iprot)
6841 
    iprot.readMessageEnd()
6842 
    result = getSnapdealItem_result()
6843 
    result.success = self._handler.getSnapdealItem(args.item_id)
6844 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
6845 
    result.write(oprot)
6846 
    oprot.writeMessageEnd()
6847 
    oprot.trans.flush()
6848 
 
9242 kshitij.so 6849 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
6850 
    args = getSnapdealItemDetails_args()
6851 
    args.read(iprot)
6852 
    iprot.readMessageEnd()
6853 
    result = getSnapdealItemDetails_result()
6854 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
6855 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
6856 
    result.write(oprot)
6857 
    oprot.writeMessageEnd()
6858 
    oprot.trans.flush()
6859 
 
8739 vikram.rag 6860 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
6861 
    args = getAllSnapdealItems_args()
6862 
    args.read(iprot)
6863 
    iprot.readMessageEnd()
6864 
    result = getAllSnapdealItems_result()
6865 
    result.success = self._handler.getAllSnapdealItems()
6866 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
6867 
    result.write(oprot)
6868 
    oprot.writeMessageEnd()
6869 
    oprot.trans.flush()
6870 
 
9242 kshitij.so 6871 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
6872 
    args = getSnapdealItems_args()
6873 
    args.read(iprot)
6874 
    iprot.readMessageEnd()
6875 
    result = getSnapdealItems_result()
6876 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
6877 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
6878 
    result.write(oprot)
6879 
    oprot.writeMessageEnd()
6880 
    oprot.trans.flush()
8739 vikram.rag 6881 
 
9242 kshitij.so 6882 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
6883 
    args = searchSnapdealItems_args()
6884 
    args.read(iprot)
6885 
    iprot.readMessageEnd()
6886 
    result = searchSnapdealItems_result()
6887 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
6888 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
6889 
    result.write(oprot)
6890 
    oprot.writeMessageEnd()
6891 
    oprot.trans.flush()
6892 
 
6893 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
6894 
    args = getCountForSnapdealItems_args()
6895 
    args.read(iprot)
6896 
    iprot.readMessageEnd()
6897 
    result = getCountForSnapdealItems_result()
6898 
    result.success = self._handler.getCountForSnapdealItems()
6899 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
6900 
    result.write(oprot)
6901 
    oprot.writeMessageEnd()
6902 
    oprot.trans.flush()
6903 
 
6904 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
6905 
    args = getSnapdealSearchResultCount_args()
6906 
    args.read(iprot)
6907 
    iprot.readMessageEnd()
6908 
    result = getSnapdealSearchResultCount_result()
6909 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
6910 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
6911 
    result.write(oprot)
6912 
    oprot.writeMessageEnd()
6913 
    oprot.trans.flush()
6914 
 
9299 kshitij.so 6915 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
6916 
    args = getPrefferedInsurerForItem_args()
6917 
    args.read(iprot)
6918 
    iprot.readMessageEnd()
6919 
    result = getPrefferedInsurerForItem_result()
6920 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
6921 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
6922 
    result.write(oprot)
6923 
    oprot.writeMessageEnd()
6924 
    oprot.trans.flush()
9242 kshitij.so 6925 
 
9456 vikram.rag 6926 
  def process_getSnapdealItembySkuAtSnapdeal(self, seqid, iprot, oprot):
6927 
    args = getSnapdealItembySkuAtSnapdeal_args()
6928 
    args.read(iprot)
6929 
    iprot.readMessageEnd()
6930 
    result = getSnapdealItembySkuAtSnapdeal_result()
6931 
    result.success = self._handler.getSnapdealItembySkuAtSnapdeal(args.skuAtSnapdeal)
6932 
    oprot.writeMessageBegin("getSnapdealItembySkuAtSnapdeal", TMessageType.REPLY, seqid)
6933 
    result.write(oprot)
6934 
    oprot.writeMessageEnd()
6935 
    oprot.trans.flush()
9299 kshitij.so 6936 
 
9621 manish.sha 6937 
  def process_getProductFeedSubmit(self, seqid, iprot, oprot):
6938 
    args = getProductFeedSubmit_args()
6939 
    args.read(iprot)
6940 
    iprot.readMessageEnd()
6941 
    result = getProductFeedSubmit_result()
6942 
    try:
6943 
      result.success = self._handler.getProductFeedSubmit(args.catalogItemId)
6944 
    except CatalogServiceException, cex:
6945 
      result.cex = cex
6946 
    oprot.writeMessageBegin("getProductFeedSubmit", TMessageType.REPLY, seqid)
6947 
    result.write(oprot)
6948 
    oprot.writeMessageEnd()
6949 
    oprot.trans.flush()
9456 vikram.rag 6950 
 
9621 manish.sha 6951 
  def process_addProductFeedSubmit(self, seqid, iprot, oprot):
6952 
    args = addProductFeedSubmit_args()
6953 
    args.read(iprot)
6954 
    iprot.readMessageEnd()
6955 
    result = addProductFeedSubmit_result()
6956 
    try:
6957 
      result.success = self._handler.addProductFeedSubmit(args.productFeedSubmit)
6958 
    except CatalogServiceException, cex:
6959 
      result.cex = cex
6960 
    oprot.writeMessageBegin("addProductFeedSubmit", TMessageType.REPLY, seqid)
6961 
    result.write(oprot)
6962 
    oprot.writeMessageEnd()
6963 
    oprot.trans.flush()
6964 
 
6965 
  def process_updateProductFeedSubmit(self, seqid, iprot, oprot):
6966 
    args = updateProductFeedSubmit_args()
6967 
    args.read(iprot)
6968 
    iprot.readMessageEnd()
6969 
    result = updateProductFeedSubmit_result()
6970 
    try:
6971 
      result.success = self._handler.updateProductFeedSubmit(args.productFeedSubmit)
6972 
    except CatalogServiceException, cex:
6973 
      result.cex = cex
6974 
    oprot.writeMessageBegin("updateProductFeedSubmit", TMessageType.REPLY, seqid)
6975 
    result.write(oprot)
6976 
    oprot.writeMessageEnd()
6977 
    oprot.trans.flush()
6978 
 
6979 
  def process_deleteProductFeedSubmit(self, seqid, iprot, oprot):
6980 
    args = deleteProductFeedSubmit_args()
6981 
    args.read(iprot)
6982 
    iprot.readMessageEnd()
6983 
    result = deleteProductFeedSubmit_result()
6984 
    try:
6985 
      result.success = self._handler.deleteProductFeedSubmit(args.catalogItemId)
6986 
    except CatalogServiceException, cex:
6987 
      result.cex = cex
6988 
    oprot.writeMessageBegin("deleteProductFeedSubmit", TMessageType.REPLY, seqid)
6989 
    result.write(oprot)
6990 
    oprot.writeMessageEnd()
6991 
    oprot.trans.flush()
6992 
 
6993 
  def process_getAllProductFeedSubmit(self, seqid, iprot, oprot):
6994 
    args = getAllProductFeedSubmit_args()
6995 
    args.read(iprot)
6996 
    iprot.readMessageEnd()
6997 
    result = getAllProductFeedSubmit_result()
6998 
    try:
6999 
      result.success = self._handler.getAllProductFeedSubmit()
7000 
    except CatalogServiceException, cex:
7001 
      result.cex = cex
7002 
    oprot.writeMessageBegin("getAllProductFeedSubmit", TMessageType.REPLY, seqid)
7003 
    result.write(oprot)
7004 
    oprot.writeMessageEnd()
7005 
    oprot.trans.flush()
7006 
 
7007 
 
5944 mandeep.dh 7008 
# HELPER FUNCTIONS AND STRUCTURES
7009 
 
7010 
class addItem_args:
7011 
  """
7012 
  Attributes:
7013 
   - item
7014 
  """
7015 
 
7016 
  thrift_spec = (
7017 
    None, # 0
7018 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7019 
  )
7020 
 
7021 
  def __init__(self, item=None,):
7022 
    self.item = item
7023 
 
7024 
  def read(self, iprot):
7025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7027 
      return
7028 
    iprot.readStructBegin()
7029 
    while True:
7030 
      (fname, ftype, fid) = iprot.readFieldBegin()
7031 
      if ftype == TType.STOP:
7032 
        break
7033 
      if fid == 1:
7034 
        if ftype == TType.STRUCT:
7035 
          self.item = Item()
7036 
          self.item.read(iprot)
7037 
        else:
7038 
          iprot.skip(ftype)
7039 
      else:
7040 
        iprot.skip(ftype)
7041 
      iprot.readFieldEnd()
7042 
    iprot.readStructEnd()
7043 
 
7044 
  def write(self, oprot):
7045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7047 
      return
7048 
    oprot.writeStructBegin('addItem_args')
7049 
    if self.item is not None:
7050 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7051 
      self.item.write(oprot)
7052 
      oprot.writeFieldEnd()
7053 
    oprot.writeFieldStop()
7054 
    oprot.writeStructEnd()
7055 
 
7056 
  def validate(self):
7057 
    return
7058 
 
7059 
 
7060 
  def __repr__(self):
7061 
    L = ['%s=%r' % (key, value)
7062 
      for key, value in self.__dict__.iteritems()]
7063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7064 
 
7065 
  def __eq__(self, other):
7066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7067 
 
7068 
  def __ne__(self, other):
7069 
    return not (self == other)
7070 
 
7071 
class addItem_result:
7072 
  """
7073 
  Attributes:
7074 
   - success
7075 
   - cex
7076 
  """
7077 
 
7078 
  thrift_spec = (
7079 
    (0, TType.I64, 'success', None, None, ), # 0
7080 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7081 
  )
7082 
 
7083 
  def __init__(self, success=None, cex=None,):
7084 
    self.success = success
7085 
    self.cex = cex
7086 
 
7087 
  def read(self, iprot):
7088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7090 
      return
7091 
    iprot.readStructBegin()
7092 
    while True:
7093 
      (fname, ftype, fid) = iprot.readFieldBegin()
7094 
      if ftype == TType.STOP:
7095 
        break
7096 
      if fid == 0:
7097 
        if ftype == TType.I64:
7098 
          self.success = iprot.readI64();
7099 
        else:
7100 
          iprot.skip(ftype)
7101 
      elif fid == 1:
7102 
        if ftype == TType.STRUCT:
7103 
          self.cex = CatalogServiceException()
7104 
          self.cex.read(iprot)
7105 
        else:
7106 
          iprot.skip(ftype)
7107 
      else:
7108 
        iprot.skip(ftype)
7109 
      iprot.readFieldEnd()
7110 
    iprot.readStructEnd()
7111 
 
7112 
  def write(self, oprot):
7113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7115 
      return
7116 
    oprot.writeStructBegin('addItem_result')
7117 
    if self.success is not None:
7118 
      oprot.writeFieldBegin('success', TType.I64, 0)
7119 
      oprot.writeI64(self.success)
7120 
      oprot.writeFieldEnd()
7121 
    if self.cex is not None:
7122 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7123 
      self.cex.write(oprot)
7124 
      oprot.writeFieldEnd()
7125 
    oprot.writeFieldStop()
7126 
    oprot.writeStructEnd()
7127 
 
7128 
  def validate(self):
7129 
    return
7130 
 
7131 
 
7132 
  def __repr__(self):
7133 
    L = ['%s=%r' % (key, value)
7134 
      for key, value in self.__dict__.iteritems()]
7135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7136 
 
7137 
  def __eq__(self, other):
7138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7139 
 
7140 
  def __ne__(self, other):
7141 
    return not (self == other)
7142 
 
7143 
class updateItem_args:
7144 
  """
7145 
  Attributes:
7146 
   - item
7147 
  """
7148 
 
7149 
  thrift_spec = (
7150 
    None, # 0
7151 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
7152 
  )
7153 
 
7154 
  def __init__(self, item=None,):
7155 
    self.item = item
7156 
 
7157 
  def read(self, iprot):
7158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7160 
      return
7161 
    iprot.readStructBegin()
7162 
    while True:
7163 
      (fname, ftype, fid) = iprot.readFieldBegin()
7164 
      if ftype == TType.STOP:
7165 
        break
7166 
      if fid == 1:
7167 
        if ftype == TType.STRUCT:
7168 
          self.item = Item()
7169 
          self.item.read(iprot)
7170 
        else:
7171 
          iprot.skip(ftype)
7172 
      else:
7173 
        iprot.skip(ftype)
7174 
      iprot.readFieldEnd()
7175 
    iprot.readStructEnd()
7176 
 
7177 
  def write(self, oprot):
7178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7180 
      return
7181 
    oprot.writeStructBegin('updateItem_args')
7182 
    if self.item is not None:
7183 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
7184 
      self.item.write(oprot)
7185 
      oprot.writeFieldEnd()
7186 
    oprot.writeFieldStop()
7187 
    oprot.writeStructEnd()
7188 
 
7189 
  def validate(self):
7190 
    return
7191 
 
7192 
 
7193 
  def __repr__(self):
7194 
    L = ['%s=%r' % (key, value)
7195 
      for key, value in self.__dict__.iteritems()]
7196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7197 
 
7198 
  def __eq__(self, other):
7199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7200 
 
7201 
  def __ne__(self, other):
7202 
    return not (self == other)
7203 
 
7204 
class updateItem_result:
7205 
  """
7206 
  Attributes:
7207 
   - success
7208 
   - cex
7209 
  """
7210 
 
7211 
  thrift_spec = (
7212 
    (0, TType.I64, 'success', None, None, ), # 0
7213 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7214 
  )
7215 
 
7216 
  def __init__(self, success=None, cex=None,):
7217 
    self.success = success
7218 
    self.cex = cex
7219 
 
7220 
  def read(self, iprot):
7221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7223 
      return
7224 
    iprot.readStructBegin()
7225 
    while True:
7226 
      (fname, ftype, fid) = iprot.readFieldBegin()
7227 
      if ftype == TType.STOP:
7228 
        break
7229 
      if fid == 0:
7230 
        if ftype == TType.I64:
7231 
          self.success = iprot.readI64();
7232 
        else:
7233 
          iprot.skip(ftype)
7234 
      elif fid == 1:
7235 
        if ftype == TType.STRUCT:
7236 
          self.cex = CatalogServiceException()
7237 
          self.cex.read(iprot)
7238 
        else:
7239 
          iprot.skip(ftype)
7240 
      else:
7241 
        iprot.skip(ftype)
7242 
      iprot.readFieldEnd()
7243 
    iprot.readStructEnd()
7244 
 
7245 
  def write(self, oprot):
7246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7248 
      return
7249 
    oprot.writeStructBegin('updateItem_result')
7250 
    if self.success is not None:
7251 
      oprot.writeFieldBegin('success', TType.I64, 0)
7252 
      oprot.writeI64(self.success)
7253 
      oprot.writeFieldEnd()
7254 
    if self.cex is not None:
7255 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7256 
      self.cex.write(oprot)
7257 
      oprot.writeFieldEnd()
7258 
    oprot.writeFieldStop()
7259 
    oprot.writeStructEnd()
7260 
 
7261 
  def validate(self):
7262 
    return
7263 
 
7264 
 
7265 
  def __repr__(self):
7266 
    L = ['%s=%r' % (key, value)
7267 
      for key, value in self.__dict__.iteritems()]
7268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7269 
 
7270 
  def __eq__(self, other):
7271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7272 
 
7273 
  def __ne__(self, other):
7274 
    return not (self == other)
7275 
 
7276 
class isActive_args:
7277 
  """
7278 
  Attributes:
7279 
   - itemId
7280 
  """
7281 
 
7282 
  thrift_spec = (
7283 
    None, # 0
7284 
    (1, TType.I64, 'itemId', None, None, ), # 1
7285 
  )
7286 
 
7287 
  def __init__(self, itemId=None,):
7288 
    self.itemId = itemId
7289 
 
7290 
  def read(self, iprot):
7291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7293 
      return
7294 
    iprot.readStructBegin()
7295 
    while True:
7296 
      (fname, ftype, fid) = iprot.readFieldBegin()
7297 
      if ftype == TType.STOP:
7298 
        break
7299 
      if fid == 1:
7300 
        if ftype == TType.I64:
7301 
          self.itemId = iprot.readI64();
7302 
        else:
7303 
          iprot.skip(ftype)
7304 
      else:
7305 
        iprot.skip(ftype)
7306 
      iprot.readFieldEnd()
7307 
    iprot.readStructEnd()
7308 
 
7309 
  def write(self, oprot):
7310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7312 
      return
7313 
    oprot.writeStructBegin('isActive_args')
7314 
    if self.itemId is not None:
7315 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7316 
      oprot.writeI64(self.itemId)
7317 
      oprot.writeFieldEnd()
7318 
    oprot.writeFieldStop()
7319 
    oprot.writeStructEnd()
7320 
 
7321 
  def validate(self):
7322 
    return
7323 
 
7324 
 
7325 
  def __repr__(self):
7326 
    L = ['%s=%r' % (key, value)
7327 
      for key, value in self.__dict__.iteritems()]
7328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7329 
 
7330 
  def __eq__(self, other):
7331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7332 
 
7333 
  def __ne__(self, other):
7334 
    return not (self == other)
7335 
 
7336 
class isActive_result:
7337 
  """
7338 
  Attributes:
7339 
   - success
7340 
   - isex
7341 
  """
7342 
 
7343 
  thrift_spec = (
7344 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
7345 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7346 
  )
7347 
 
7348 
  def __init__(self, success=None, isex=None,):
7349 
    self.success = success
7350 
    self.isex = isex
7351 
 
7352 
  def read(self, iprot):
7353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7355 
      return
7356 
    iprot.readStructBegin()
7357 
    while True:
7358 
      (fname, ftype, fid) = iprot.readFieldBegin()
7359 
      if ftype == TType.STOP:
7360 
        break
7361 
      if fid == 0:
7362 
        if ftype == TType.STRUCT:
7363 
          self.success = ItemShippingInfo()
7364 
          self.success.read(iprot)
7365 
        else:
7366 
          iprot.skip(ftype)
7367 
      elif fid == 1:
7368 
        if ftype == TType.STRUCT:
7369 
          self.isex = CatalogServiceException()
7370 
          self.isex.read(iprot)
7371 
        else:
7372 
          iprot.skip(ftype)
7373 
      else:
7374 
        iprot.skip(ftype)
7375 
      iprot.readFieldEnd()
7376 
    iprot.readStructEnd()
7377 
 
7378 
  def write(self, oprot):
7379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7381 
      return
7382 
    oprot.writeStructBegin('isActive_result')
7383 
    if self.success is not None:
7384 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7385 
      self.success.write(oprot)
7386 
      oprot.writeFieldEnd()
7387 
    if self.isex is not None:
7388 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7389 
      self.isex.write(oprot)
7390 
      oprot.writeFieldEnd()
7391 
    oprot.writeFieldStop()
7392 
    oprot.writeStructEnd()
7393 
 
7394 
  def validate(self):
7395 
    return
7396 
 
7397 
 
7398 
  def __repr__(self):
7399 
    L = ['%s=%r' % (key, value)
7400 
      for key, value in self.__dict__.iteritems()]
7401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7402 
 
7403 
  def __eq__(self, other):
7404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7405 
 
7406 
  def __ne__(self, other):
7407 
    return not (self == other)
7408 
 
7438 amit.gupta 7409 
class getItemsStatus_args:
7410 
  """
7411 
  Attributes:
7412 
   - itemIds
7413 
  """
7414 
 
7415 
  thrift_spec = (
7416 
    None, # 0
7417 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7418 
  )
7419 
 
7420 
  def __init__(self, itemIds=None,):
7421 
    self.itemIds = itemIds
7422 
 
7423 
  def read(self, iprot):
7424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7426 
      return
7427 
    iprot.readStructBegin()
7428 
    while True:
7429 
      (fname, ftype, fid) = iprot.readFieldBegin()
7430 
      if ftype == TType.STOP:
7431 
        break
7432 
      if fid == 1:
7433 
        if ftype == TType.LIST:
7434 
          self.itemIds = []
8590 kshitij.so 7435 
          (_etype33, _size30) = iprot.readListBegin()
7436 
          for _i34 in xrange(_size30):
7437 
            _elem35 = iprot.readI64();
7438 
            self.itemIds.append(_elem35)
7438 amit.gupta 7439 
          iprot.readListEnd()
7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      else:
7443 
        iprot.skip(ftype)
7444 
      iprot.readFieldEnd()
7445 
    iprot.readStructEnd()
7446 
 
7447 
  def write(self, oprot):
7448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7450 
      return
7451 
    oprot.writeStructBegin('getItemsStatus_args')
7452 
    if self.itemIds is not None:
7453 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7454 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7455 
      for iter36 in self.itemIds:
7456 
        oprot.writeI64(iter36)
7438 amit.gupta 7457 
      oprot.writeListEnd()
7458 
      oprot.writeFieldEnd()
7459 
    oprot.writeFieldStop()
7460 
    oprot.writeStructEnd()
7461 
 
7462 
  def validate(self):
7463 
    return
7464 
 
7465 
 
7466 
  def __repr__(self):
7467 
    L = ['%s=%r' % (key, value)
7468 
      for key, value in self.__dict__.iteritems()]
7469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7470 
 
7471 
  def __eq__(self, other):
7472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7473 
 
7474 
  def __ne__(self, other):
7475 
    return not (self == other)
7476 
 
7477 
class getItemsStatus_result:
7478 
  """
7479 
  Attributes:
7480 
   - success
7481 
   - isex
7482 
  """
7483 
 
7484 
  thrift_spec = (
7485 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7486 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7487 
  )
7488 
 
7489 
  def __init__(self, success=None, isex=None,):
7490 
    self.success = success
7491 
    self.isex = isex
7492 
 
7493 
  def read(self, iprot):
7494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7496 
      return
7497 
    iprot.readStructBegin()
7498 
    while True:
7499 
      (fname, ftype, fid) = iprot.readFieldBegin()
7500 
      if ftype == TType.STOP:
7501 
        break
7502 
      if fid == 0:
7503 
        if ftype == TType.MAP:
7504 
          self.success = {}
8590 kshitij.so 7505 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7506 
          for _i41 in xrange(_size37):
7507 
            _key42 = iprot.readI64();
7508 
            _val43 = iprot.readBool();
7509 
            self.success[_key42] = _val43
7438 amit.gupta 7510 
          iprot.readMapEnd()
7511 
        else:
7512 
          iprot.skip(ftype)
7513 
      elif fid == 1:
7514 
        if ftype == TType.STRUCT:
7515 
          self.isex = CatalogServiceException()
7516 
          self.isex.read(iprot)
7517 
        else:
7518 
          iprot.skip(ftype)
7519 
      else:
7520 
        iprot.skip(ftype)
7521 
      iprot.readFieldEnd()
7522 
    iprot.readStructEnd()
7523 
 
7524 
  def write(self, oprot):
7525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7527 
      return
7528 
    oprot.writeStructBegin('getItemsStatus_result')
7529 
    if self.success is not None:
7530 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7531 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7532 
      for kiter44,viter45 in self.success.items():
7533 
        oprot.writeI64(kiter44)
7534 
        oprot.writeBool(viter45)
7438 amit.gupta 7535 
      oprot.writeMapEnd()
7536 
      oprot.writeFieldEnd()
7537 
    if self.isex is not None:
7538 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7539 
      self.isex.write(oprot)
7540 
      oprot.writeFieldEnd()
7541 
    oprot.writeFieldStop()
7542 
    oprot.writeStructEnd()
7543 
 
7544 
  def validate(self):
7545 
    return
7546 
 
7547 
 
7548 
  def __repr__(self):
7549 
    L = ['%s=%r' % (key, value)
7550 
      for key, value in self.__dict__.iteritems()]
7551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7552 
 
7553 
  def __eq__(self, other):
7554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7555 
 
7556 
  def __ne__(self, other):
7557 
    return not (self == other)
7558 
 
5944 mandeep.dh 7559 
class getItemStatusDescription_args:
7560 
  """
7561 
  Attributes:
7562 
   - itemId
7563 
  """
7564 
 
7565 
  thrift_spec = (
7566 
    None, # 0
7567 
    (1, TType.I64, 'itemId', None, None, ), # 1
7568 
  )
7569 
 
7570 
  def __init__(self, itemId=None,):
7571 
    self.itemId = itemId
7572 
 
7573 
  def read(self, iprot):
7574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7576 
      return
7577 
    iprot.readStructBegin()
7578 
    while True:
7579 
      (fname, ftype, fid) = iprot.readFieldBegin()
7580 
      if ftype == TType.STOP:
7581 
        break
7582 
      if fid == 1:
7583 
        if ftype == TType.I64:
7584 
          self.itemId = iprot.readI64();
7585 
        else:
7586 
          iprot.skip(ftype)
7587 
      else:
7588 
        iprot.skip(ftype)
7589 
      iprot.readFieldEnd()
7590 
    iprot.readStructEnd()
7591 
 
7592 
  def write(self, oprot):
7593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7595 
      return
7596 
    oprot.writeStructBegin('getItemStatusDescription_args')
7597 
    if self.itemId is not None:
7598 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7599 
      oprot.writeI64(self.itemId)
7600 
      oprot.writeFieldEnd()
7601 
    oprot.writeFieldStop()
7602 
    oprot.writeStructEnd()
7603 
 
7604 
  def validate(self):
7605 
    return
7606 
 
7607 
 
7608 
  def __repr__(self):
7609 
    L = ['%s=%r' % (key, value)
7610 
      for key, value in self.__dict__.iteritems()]
7611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7612 
 
7613 
  def __eq__(self, other):
7614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7615 
 
7616 
  def __ne__(self, other):
7617 
    return not (self == other)
7618 
 
7619 
class getItemStatusDescription_result:
7620 
  """
7621 
  Attributes:
7622 
   - success
7623 
   - isex
7624 
  """
7625 
 
7626 
  thrift_spec = (
7627 
    (0, TType.STRING, 'success', None, None, ), # 0
7628 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7629 
  )
7630 
 
7631 
  def __init__(self, success=None, isex=None,):
7632 
    self.success = success
7633 
    self.isex = isex
7634 
 
7635 
  def read(self, iprot):
7636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7638 
      return
7639 
    iprot.readStructBegin()
7640 
    while True:
7641 
      (fname, ftype, fid) = iprot.readFieldBegin()
7642 
      if ftype == TType.STOP:
7643 
        break
7644 
      if fid == 0:
7645 
        if ftype == TType.STRING:
7646 
          self.success = iprot.readString();
7647 
        else:
7648 
          iprot.skip(ftype)
7649 
      elif fid == 1:
7650 
        if ftype == TType.STRUCT:
7651 
          self.isex = CatalogServiceException()
7652 
          self.isex.read(iprot)
7653 
        else:
7654 
          iprot.skip(ftype)
7655 
      else:
7656 
        iprot.skip(ftype)
7657 
      iprot.readFieldEnd()
7658 
    iprot.readStructEnd()
7659 
 
7660 
  def write(self, oprot):
7661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7663 
      return
7664 
    oprot.writeStructBegin('getItemStatusDescription_result')
7665 
    if self.success is not None:
7666 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7667 
      oprot.writeString(self.success)
7668 
      oprot.writeFieldEnd()
7669 
    if self.isex is not None:
7670 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7671 
      self.isex.write(oprot)
7672 
      oprot.writeFieldEnd()
7673 
    oprot.writeFieldStop()
7674 
    oprot.writeStructEnd()
7675 
 
7676 
  def validate(self):
7677 
    return
7678 
 
7679 
 
7680 
  def __repr__(self):
7681 
    L = ['%s=%r' % (key, value)
7682 
      for key, value in self.__dict__.iteritems()]
7683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7684 
 
7685 
  def __eq__(self, other):
7686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7687 
 
7688 
  def __ne__(self, other):
7689 
    return not (self == other)
7690 
 
7691 
class startItemOn_args:
7692 
  """
7693 
  Attributes:
7694 
   - item_id
7695 
   - timestamp
7696 
  """
7697 
 
7698 
  thrift_spec = (
7699 
    None, # 0
7700 
    (1, TType.I64, 'item_id', None, None, ), # 1
7701 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7702 
  )
7703 
 
7704 
  def __init__(self, item_id=None, timestamp=None,):
7705 
    self.item_id = item_id
7706 
    self.timestamp = timestamp
7707 
 
7708 
  def read(self, iprot):
7709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7711 
      return
7712 
    iprot.readStructBegin()
7713 
    while True:
7714 
      (fname, ftype, fid) = iprot.readFieldBegin()
7715 
      if ftype == TType.STOP:
7716 
        break
7717 
      if fid == 1:
7718 
        if ftype == TType.I64:
7719 
          self.item_id = iprot.readI64();
7720 
        else:
7721 
          iprot.skip(ftype)
7722 
      elif fid == 2:
7723 
        if ftype == TType.I64:
7724 
          self.timestamp = iprot.readI64();
7725 
        else:
7726 
          iprot.skip(ftype)
7727 
      else:
7728 
        iprot.skip(ftype)
7729 
      iprot.readFieldEnd()
7730 
    iprot.readStructEnd()
7731 
 
7732 
  def write(self, oprot):
7733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7735 
      return
7736 
    oprot.writeStructBegin('startItemOn_args')
7737 
    if self.item_id is not None:
7738 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7739 
      oprot.writeI64(self.item_id)
7740 
      oprot.writeFieldEnd()
7741 
    if self.timestamp is not None:
7742 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7743 
      oprot.writeI64(self.timestamp)
7744 
      oprot.writeFieldEnd()
7745 
    oprot.writeFieldStop()
7746 
    oprot.writeStructEnd()
7747 
 
7748 
  def validate(self):
7749 
    return
7750 
 
7751 
 
7752 
  def __repr__(self):
7753 
    L = ['%s=%r' % (key, value)
7754 
      for key, value in self.__dict__.iteritems()]
7755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7756 
 
7757 
  def __eq__(self, other):
7758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7759 
 
7760 
  def __ne__(self, other):
7761 
    return not (self == other)
7762 
 
7763 
class startItemOn_result:
7764 
  """
7765 
  Attributes:
7766 
   - cex
7767 
  """
7768 
 
7769 
  thrift_spec = (
7770 
    None, # 0
7771 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7772 
  )
7773 
 
7774 
  def __init__(self, cex=None,):
7775 
    self.cex = cex
7776 
 
7777 
  def read(self, iprot):
7778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7780 
      return
7781 
    iprot.readStructBegin()
7782 
    while True:
7783 
      (fname, ftype, fid) = iprot.readFieldBegin()
7784 
      if ftype == TType.STOP:
7785 
        break
7786 
      if fid == 1:
7787 
        if ftype == TType.STRUCT:
7788 
          self.cex = CatalogServiceException()
7789 
          self.cex.read(iprot)
7790 
        else:
7791 
          iprot.skip(ftype)
7792 
      else:
7793 
        iprot.skip(ftype)
7794 
      iprot.readFieldEnd()
7795 
    iprot.readStructEnd()
7796 
 
7797 
  def write(self, oprot):
7798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7800 
      return
7801 
    oprot.writeStructBegin('startItemOn_result')
7802 
    if self.cex is not None:
7803 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7804 
      self.cex.write(oprot)
7805 
      oprot.writeFieldEnd()
7806 
    oprot.writeFieldStop()
7807 
    oprot.writeStructEnd()
7808 
 
7809 
  def validate(self):
7810 
    return
7811 
 
7812 
 
7813 
  def __repr__(self):
7814 
    L = ['%s=%r' % (key, value)
7815 
      for key, value in self.__dict__.iteritems()]
7816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7817 
 
7818 
  def __eq__(self, other):
7819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7820 
 
7821 
  def __ne__(self, other):
7822 
    return not (self == other)
7823 
 
7824 
class retireItemOn_args:
7825 
  """
7826 
  Attributes:
7827 
   - item_id
7828 
   - timestamp
7829 
  """
7830 
 
7831 
  thrift_spec = (
7832 
    None, # 0
7833 
    (1, TType.I64, 'item_id', None, None, ), # 1
7834 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7835 
  )
7836 
 
7837 
  def __init__(self, item_id=None, timestamp=None,):
7838 
    self.item_id = item_id
7839 
    self.timestamp = timestamp
7840 
 
7841 
  def read(self, iprot):
7842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7844 
      return
7845 
    iprot.readStructBegin()
7846 
    while True:
7847 
      (fname, ftype, fid) = iprot.readFieldBegin()
7848 
      if ftype == TType.STOP:
7849 
        break
7850 
      if fid == 1:
7851 
        if ftype == TType.I64:
7852 
          self.item_id = iprot.readI64();
7853 
        else:
7854 
          iprot.skip(ftype)
7855 
      elif fid == 2:
7856 
        if ftype == TType.I64:
7857 
          self.timestamp = iprot.readI64();
7858 
        else:
7859 
          iprot.skip(ftype)
7860 
      else:
7861 
        iprot.skip(ftype)
7862 
      iprot.readFieldEnd()
7863 
    iprot.readStructEnd()
7864 
 
7865 
  def write(self, oprot):
7866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7868 
      return
7869 
    oprot.writeStructBegin('retireItemOn_args')
7870 
    if self.item_id is not None:
7871 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7872 
      oprot.writeI64(self.item_id)
7873 
      oprot.writeFieldEnd()
7874 
    if self.timestamp is not None:
7875 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7876 
      oprot.writeI64(self.timestamp)
7877 
      oprot.writeFieldEnd()
7878 
    oprot.writeFieldStop()
7879 
    oprot.writeStructEnd()
7880 
 
7881 
  def validate(self):
7882 
    return
7883 
 
7884 
 
7885 
  def __repr__(self):
7886 
    L = ['%s=%r' % (key, value)
7887 
      for key, value in self.__dict__.iteritems()]
7888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7889 
 
7890 
  def __eq__(self, other):
7891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7892 
 
7893 
  def __ne__(self, other):
7894 
    return not (self == other)
7895 
 
7896 
class retireItemOn_result:
7897 
  """
7898 
  Attributes:
7899 
   - cex
7900 
  """
7901 
 
7902 
  thrift_spec = (
7903 
    None, # 0
7904 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7905 
  )
7906 
 
7907 
  def __init__(self, cex=None,):
7908 
    self.cex = cex
7909 
 
7910 
  def read(self, iprot):
7911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7913 
      return
7914 
    iprot.readStructBegin()
7915 
    while True:
7916 
      (fname, ftype, fid) = iprot.readFieldBegin()
7917 
      if ftype == TType.STOP:
7918 
        break
7919 
      if fid == 1:
7920 
        if ftype == TType.STRUCT:
7921 
          self.cex = CatalogServiceException()
7922 
          self.cex.read(iprot)
7923 
        else:
7924 
          iprot.skip(ftype)
7925 
      else:
7926 
        iprot.skip(ftype)
7927 
      iprot.readFieldEnd()
7928 
    iprot.readStructEnd()
7929 
 
7930 
  def write(self, oprot):
7931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7933 
      return
7934 
    oprot.writeStructBegin('retireItemOn_result')
7935 
    if self.cex is not None:
7936 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7937 
      self.cex.write(oprot)
7938 
      oprot.writeFieldEnd()
7939 
    oprot.writeFieldStop()
7940 
    oprot.writeStructEnd()
7941 
 
7942 
  def validate(self):
7943 
    return
7944 
 
7945 
 
7946 
  def __repr__(self):
7947 
    L = ['%s=%r' % (key, value)
7948 
      for key, value in self.__dict__.iteritems()]
7949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7950 
 
7951 
  def __eq__(self, other):
7952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7953 
 
7954 
  def __ne__(self, other):
7955 
    return not (self == other)
7956 
 
7957 
class changeItemStatus_args:
7958 
  """
7959 
  Attributes:
7960 
   - item_id
7961 
   - timestamp
7962 
   - newstatus
7963 
  """
7964 
 
7965 
  thrift_spec = (
7966 
    None, # 0
7967 
    (1, TType.I64, 'item_id', None, None, ), # 1
7968 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7969 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7970 
  )
7971 
 
7972 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7973 
    self.item_id = item_id
7974 
    self.timestamp = timestamp
7975 
    self.newstatus = newstatus
7976 
 
7977 
  def read(self, iprot):
7978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7980 
      return
7981 
    iprot.readStructBegin()
7982 
    while True:
7983 
      (fname, ftype, fid) = iprot.readFieldBegin()
7984 
      if ftype == TType.STOP:
7985 
        break
7986 
      if fid == 1:
7987 
        if ftype == TType.I64:
7988 
          self.item_id = iprot.readI64();
7989 
        else:
7990 
          iprot.skip(ftype)
7991 
      elif fid == 2:
7992 
        if ftype == TType.I64:
7993 
          self.timestamp = iprot.readI64();
7994 
        else:
7995 
          iprot.skip(ftype)
7996 
      elif fid == 3:
7997 
        if ftype == TType.I32:
7998 
          self.newstatus = iprot.readI32();
7999 
        else:
8000 
          iprot.skip(ftype)
8001 
      else:
8002 
        iprot.skip(ftype)
8003 
      iprot.readFieldEnd()
8004 
    iprot.readStructEnd()
8005 
 
8006 
  def write(self, oprot):
8007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8009 
      return
8010 
    oprot.writeStructBegin('changeItemStatus_args')
8011 
    if self.item_id is not None:
8012 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8013 
      oprot.writeI64(self.item_id)
8014 
      oprot.writeFieldEnd()
8015 
    if self.timestamp is not None:
8016 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
8017 
      oprot.writeI64(self.timestamp)
8018 
      oprot.writeFieldEnd()
8019 
    if self.newstatus is not None:
8020 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
8021 
      oprot.writeI32(self.newstatus)
8022 
      oprot.writeFieldEnd()
8023 
    oprot.writeFieldStop()
8024 
    oprot.writeStructEnd()
8025 
 
8026 
  def validate(self):
8027 
    return
8028 
 
8029 
 
8030 
  def __repr__(self):
8031 
    L = ['%s=%r' % (key, value)
8032 
      for key, value in self.__dict__.iteritems()]
8033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8034 
 
8035 
  def __eq__(self, other):
8036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8037 
 
8038 
  def __ne__(self, other):
8039 
    return not (self == other)
8040 
 
8041 
class changeItemStatus_result:
8042 
  """
8043 
  Attributes:
8044 
   - cex
8045 
  """
8046 
 
8047 
  thrift_spec = (
8048 
    None, # 0
8049 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8050 
  )
8051 
 
8052 
  def __init__(self, cex=None,):
8053 
    self.cex = cex
8054 
 
8055 
  def read(self, iprot):
8056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8058 
      return
8059 
    iprot.readStructBegin()
8060 
    while True:
8061 
      (fname, ftype, fid) = iprot.readFieldBegin()
8062 
      if ftype == TType.STOP:
8063 
        break
8064 
      if fid == 1:
8065 
        if ftype == TType.STRUCT:
8066 
          self.cex = CatalogServiceException()
8067 
          self.cex.read(iprot)
8068 
        else:
8069 
          iprot.skip(ftype)
8070 
      else:
8071 
        iprot.skip(ftype)
8072 
      iprot.readFieldEnd()
8073 
    iprot.readStructEnd()
8074 
 
8075 
  def write(self, oprot):
8076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8078 
      return
8079 
    oprot.writeStructBegin('changeItemStatus_result')
8080 
    if self.cex is not None:
8081 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8082 
      self.cex.write(oprot)
8083 
      oprot.writeFieldEnd()
8084 
    oprot.writeFieldStop()
8085 
    oprot.writeStructEnd()
8086 
 
8087 
  def validate(self):
8088 
    return
8089 
 
8090 
 
8091 
  def __repr__(self):
8092 
    L = ['%s=%r' % (key, value)
8093 
      for key, value in self.__dict__.iteritems()]
8094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8095 
 
8096 
  def __eq__(self, other):
8097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8098 
 
8099 
  def __ne__(self, other):
8100 
    return not (self == other)
8101 
 
8102 
class getItem_args:
8103 
  """
8104 
  Attributes:
8105 
   - item_id
8106 
  """
8107 
 
8108 
  thrift_spec = (
8109 
    None, # 0
8110 
    (1, TType.I64, 'item_id', None, None, ), # 1
8111 
  )
8112 
 
8113 
  def __init__(self, item_id=None,):
8114 
    self.item_id = item_id
8115 
 
8116 
  def read(self, iprot):
8117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8119 
      return
8120 
    iprot.readStructBegin()
8121 
    while True:
8122 
      (fname, ftype, fid) = iprot.readFieldBegin()
8123 
      if ftype == TType.STOP:
8124 
        break
8125 
      if fid == 1:
8126 
        if ftype == TType.I64:
8127 
          self.item_id = iprot.readI64();
8128 
        else:
8129 
          iprot.skip(ftype)
8130 
      else:
8131 
        iprot.skip(ftype)
8132 
      iprot.readFieldEnd()
8133 
    iprot.readStructEnd()
8134 
 
8135 
  def write(self, oprot):
8136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8138 
      return
8139 
    oprot.writeStructBegin('getItem_args')
8140 
    if self.item_id is not None:
8141 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8142 
      oprot.writeI64(self.item_id)
8143 
      oprot.writeFieldEnd()
8144 
    oprot.writeFieldStop()
8145 
    oprot.writeStructEnd()
8146 
 
8147 
  def validate(self):
8148 
    return
8149 
 
8150 
 
8151 
  def __repr__(self):
8152 
    L = ['%s=%r' % (key, value)
8153 
      for key, value in self.__dict__.iteritems()]
8154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8155 
 
8156 
  def __eq__(self, other):
8157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8158 
 
8159 
  def __ne__(self, other):
8160 
    return not (self == other)
8161 
 
8162 
class getItem_result:
8163 
  """
8164 
  Attributes:
8165 
   - success
8166 
   - cex
8167 
  """
8168 
 
8169 
  thrift_spec = (
8170 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
8171 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8172 
  )
8173 
 
8174 
  def __init__(self, success=None, cex=None,):
8175 
    self.success = success
8176 
    self.cex = cex
8177 
 
8178 
  def read(self, iprot):
8179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8181 
      return
8182 
    iprot.readStructBegin()
8183 
    while True:
8184 
      (fname, ftype, fid) = iprot.readFieldBegin()
8185 
      if ftype == TType.STOP:
8186 
        break
8187 
      if fid == 0:
8188 
        if ftype == TType.STRUCT:
8189 
          self.success = Item()
8190 
          self.success.read(iprot)
8191 
        else:
8192 
          iprot.skip(ftype)
8193 
      elif fid == 1:
8194 
        if ftype == TType.STRUCT:
8195 
          self.cex = CatalogServiceException()
8196 
          self.cex.read(iprot)
8197 
        else:
8198 
          iprot.skip(ftype)
8199 
      else:
8200 
        iprot.skip(ftype)
8201 
      iprot.readFieldEnd()
8202 
    iprot.readStructEnd()
8203 
 
8204 
  def write(self, oprot):
8205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8207 
      return
8208 
    oprot.writeStructBegin('getItem_result')
8209 
    if self.success is not None:
8210 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8211 
      self.success.write(oprot)
8212 
      oprot.writeFieldEnd()
8213 
    if self.cex is not None:
8214 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8215 
      self.cex.write(oprot)
8216 
      oprot.writeFieldEnd()
8217 
    oprot.writeFieldStop()
8218 
    oprot.writeStructEnd()
8219 
 
8220 
  def validate(self):
8221 
    return
8222 
 
8223 
 
8224 
  def __repr__(self):
8225 
    L = ['%s=%r' % (key, value)
8226 
      for key, value in self.__dict__.iteritems()]
8227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8228 
 
8229 
  def __eq__(self, other):
8230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8231 
 
8232 
  def __ne__(self, other):
8233 
    return not (self == other)
8234 
 
8235 
class getItemsByCatalogId_args:
8236 
  """
8237 
  Attributes:
8238 
   - catalog_item_id
8239 
  """
8240 
 
8241 
  thrift_spec = (
8242 
    None, # 0
8243 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8244 
  )
8245 
 
8246 
  def __init__(self, catalog_item_id=None,):
8247 
    self.catalog_item_id = catalog_item_id
8248 
 
8249 
  def read(self, iprot):
8250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8252 
      return
8253 
    iprot.readStructBegin()
8254 
    while True:
8255 
      (fname, ftype, fid) = iprot.readFieldBegin()
8256 
      if ftype == TType.STOP:
8257 
        break
8258 
      if fid == 1:
8259 
        if ftype == TType.I64:
8260 
          self.catalog_item_id = iprot.readI64();
8261 
        else:
8262 
          iprot.skip(ftype)
8263 
      else:
8264 
        iprot.skip(ftype)
8265 
      iprot.readFieldEnd()
8266 
    iprot.readStructEnd()
8267 
 
8268 
  def write(self, oprot):
8269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8271 
      return
8272 
    oprot.writeStructBegin('getItemsByCatalogId_args')
8273 
    if self.catalog_item_id is not None:
8274 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8275 
      oprot.writeI64(self.catalog_item_id)
8276 
      oprot.writeFieldEnd()
8277 
    oprot.writeFieldStop()
8278 
    oprot.writeStructEnd()
8279 
 
8280 
  def validate(self):
8281 
    return
8282 
 
8283 
 
8284 
  def __repr__(self):
8285 
    L = ['%s=%r' % (key, value)
8286 
      for key, value in self.__dict__.iteritems()]
8287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8288 
 
8289 
  def __eq__(self, other):
8290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8291 
 
8292 
  def __ne__(self, other):
8293 
    return not (self == other)
8294 
 
8295 
class getItemsByCatalogId_result:
8296 
  """
8297 
  Attributes:
8298 
   - success
8299 
   - cex
8300 
  """
8301 
 
8302 
  thrift_spec = (
8303 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8304 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8305 
  )
8306 
 
8307 
  def __init__(self, success=None, cex=None,):
8308 
    self.success = success
8309 
    self.cex = cex
8310 
 
8311 
  def read(self, iprot):
8312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8314 
      return
8315 
    iprot.readStructBegin()
8316 
    while True:
8317 
      (fname, ftype, fid) = iprot.readFieldBegin()
8318 
      if ftype == TType.STOP:
8319 
        break
8320 
      if fid == 0:
8321 
        if ftype == TType.LIST:
8322 
          self.success = []
8590 kshitij.so 8323 
          (_etype49, _size46) = iprot.readListBegin()
8324 
          for _i50 in xrange(_size46):
8325 
            _elem51 = Item()
8326 
            _elem51.read(iprot)
8327 
            self.success.append(_elem51)
5944 mandeep.dh 8328 
          iprot.readListEnd()
8329 
        else:
8330 
          iprot.skip(ftype)
8331 
      elif fid == 1:
8332 
        if ftype == TType.STRUCT:
8333 
          self.cex = CatalogServiceException()
8334 
          self.cex.read(iprot)
8335 
        else:
8336 
          iprot.skip(ftype)
8337 
      else:
8338 
        iprot.skip(ftype)
8339 
      iprot.readFieldEnd()
8340 
    iprot.readStructEnd()
8341 
 
8342 
  def write(self, oprot):
8343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8345 
      return
8346 
    oprot.writeStructBegin('getItemsByCatalogId_result')
8347 
    if self.success is not None:
8348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8350 
      for iter52 in self.success:
8351 
        iter52.write(oprot)
5944 mandeep.dh 8352 
      oprot.writeListEnd()
8353 
      oprot.writeFieldEnd()
8354 
    if self.cex is not None:
8355 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8356 
      self.cex.write(oprot)
8357 
      oprot.writeFieldEnd()
8358 
    oprot.writeFieldStop()
8359 
    oprot.writeStructEnd()
8360 
 
8361 
  def validate(self):
8362 
    return
8363 
 
8364 
 
8365 
  def __repr__(self):
8366 
    L = ['%s=%r' % (key, value)
8367 
      for key, value in self.__dict__.iteritems()]
8368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8369 
 
8370 
  def __eq__(self, other):
8371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8372 
 
8373 
  def __ne__(self, other):
8374 
    return not (self == other)
8375 
 
8376 
class getValidItemsByCatalogId_args:
8377 
  """
8378 
  Attributes:
8379 
   - catalog_item_id
8380 
  """
8381 
 
8382 
  thrift_spec = (
8383 
    None, # 0
8384 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8385 
  )
8386 
 
8387 
  def __init__(self, catalog_item_id=None,):
8388 
    self.catalog_item_id = catalog_item_id
8389 
 
8390 
  def read(self, iprot):
8391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8393 
      return
8394 
    iprot.readStructBegin()
8395 
    while True:
8396 
      (fname, ftype, fid) = iprot.readFieldBegin()
8397 
      if ftype == TType.STOP:
8398 
        break
8399 
      if fid == 1:
8400 
        if ftype == TType.I64:
8401 
          self.catalog_item_id = iprot.readI64();
8402 
        else:
8403 
          iprot.skip(ftype)
8404 
      else:
8405 
        iprot.skip(ftype)
8406 
      iprot.readFieldEnd()
8407 
    iprot.readStructEnd()
8408 
 
8409 
  def write(self, oprot):
8410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8412 
      return
8413 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8414 
    if self.catalog_item_id is not None:
8415 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8416 
      oprot.writeI64(self.catalog_item_id)
8417 
      oprot.writeFieldEnd()
8418 
    oprot.writeFieldStop()
8419 
    oprot.writeStructEnd()
8420 
 
8421 
  def validate(self):
8422 
    return
8423 
 
8424 
 
8425 
  def __repr__(self):
8426 
    L = ['%s=%r' % (key, value)
8427 
      for key, value in self.__dict__.iteritems()]
8428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8429 
 
8430 
  def __eq__(self, other):
8431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8432 
 
8433 
  def __ne__(self, other):
8434 
    return not (self == other)
8435 
 
8436 
class getValidItemsByCatalogId_result:
8437 
  """
8438 
  Attributes:
8439 
   - success
8440 
   - cex
8441 
  """
8442 
 
8443 
  thrift_spec = (
8444 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8445 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8446 
  )
8447 
 
8448 
  def __init__(self, success=None, cex=None,):
8449 
    self.success = success
8450 
    self.cex = cex
8451 
 
8452 
  def read(self, iprot):
8453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8455 
      return
8456 
    iprot.readStructBegin()
8457 
    while True:
8458 
      (fname, ftype, fid) = iprot.readFieldBegin()
8459 
      if ftype == TType.STOP:
8460 
        break
8461 
      if fid == 0:
8462 
        if ftype == TType.LIST:
8463 
          self.success = []
8590 kshitij.so 8464 
          (_etype56, _size53) = iprot.readListBegin()
8465 
          for _i57 in xrange(_size53):
8466 
            _elem58 = Item()
8467 
            _elem58.read(iprot)
8468 
            self.success.append(_elem58)
5944 mandeep.dh 8469 
          iprot.readListEnd()
8470 
        else:
8471 
          iprot.skip(ftype)
8472 
      elif fid == 1:
8473 
        if ftype == TType.STRUCT:
8474 
          self.cex = CatalogServiceException()
8475 
          self.cex.read(iprot)
8476 
        else:
8477 
          iprot.skip(ftype)
8478 
      else:
8479 
        iprot.skip(ftype)
8480 
      iprot.readFieldEnd()
8481 
    iprot.readStructEnd()
8482 
 
8483 
  def write(self, oprot):
8484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8486 
      return
8487 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8488 
    if self.success is not None:
8489 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8490 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8491 
      for iter59 in self.success:
8492 
        iter59.write(oprot)
5944 mandeep.dh 8493 
      oprot.writeListEnd()
8494 
      oprot.writeFieldEnd()
8495 
    if self.cex is not None:
8496 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8497 
      self.cex.write(oprot)
8498 
      oprot.writeFieldEnd()
8499 
    oprot.writeFieldStop()
8500 
    oprot.writeStructEnd()
8501 
 
8502 
  def validate(self):
8503 
    return
8504 
 
8505 
 
8506 
  def __repr__(self):
8507 
    L = ['%s=%r' % (key, value)
8508 
      for key, value in self.__dict__.iteritems()]
8509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8510 
 
8511 
  def __eq__(self, other):
8512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8513 
 
8514 
  def __ne__(self, other):
8515 
    return not (self == other)
8516 
 
8517 
class getAllItems_args:
8518 
  """
8519 
  Attributes:
8520 
   - isActive
8521 
  """
8522 
 
8523 
  thrift_spec = (
8524 
    None, # 0
8525 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8526 
  )
8527 
 
8528 
  def __init__(self, isActive=None,):
8529 
    self.isActive = isActive
8530 
 
8531 
  def read(self, iprot):
8532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8534 
      return
8535 
    iprot.readStructBegin()
8536 
    while True:
8537 
      (fname, ftype, fid) = iprot.readFieldBegin()
8538 
      if ftype == TType.STOP:
8539 
        break
8540 
      if fid == 1:
8541 
        if ftype == TType.BOOL:
8542 
          self.isActive = iprot.readBool();
8543 
        else:
8544 
          iprot.skip(ftype)
8545 
      else:
8546 
        iprot.skip(ftype)
8547 
      iprot.readFieldEnd()
8548 
    iprot.readStructEnd()
8549 
 
8550 
  def write(self, oprot):
8551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8553 
      return
8554 
    oprot.writeStructBegin('getAllItems_args')
8555 
    if self.isActive is not None:
8556 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8557 
      oprot.writeBool(self.isActive)
8558 
      oprot.writeFieldEnd()
8559 
    oprot.writeFieldStop()
8560 
    oprot.writeStructEnd()
8561 
 
8562 
  def validate(self):
8563 
    return
8564 
 
8565 
 
8566 
  def __repr__(self):
8567 
    L = ['%s=%r' % (key, value)
8568 
      for key, value in self.__dict__.iteritems()]
8569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8570 
 
8571 
  def __eq__(self, other):
8572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8573 
 
8574 
  def __ne__(self, other):
8575 
    return not (self == other)
8576 
 
8577 
class getAllItems_result:
8578 
  """
8579 
  Attributes:
8580 
   - success
8581 
   - cex
8582 
  """
8583 
 
8584 
  thrift_spec = (
8585 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8586 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8587 
  )
8588 
 
8589 
  def __init__(self, success=None, cex=None,):
8590 
    self.success = success
8591 
    self.cex = cex
8592 
 
8593 
  def read(self, iprot):
8594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8596 
      return
8597 
    iprot.readStructBegin()
8598 
    while True:
8599 
      (fname, ftype, fid) = iprot.readFieldBegin()
8600 
      if ftype == TType.STOP:
8601 
        break
8602 
      if fid == 0:
8603 
        if ftype == TType.LIST:
8604 
          self.success = []
8590 kshitij.so 8605 
          (_etype63, _size60) = iprot.readListBegin()
8606 
          for _i64 in xrange(_size60):
8607 
            _elem65 = Item()
8608 
            _elem65.read(iprot)
8609 
            self.success.append(_elem65)
5944 mandeep.dh 8610 
          iprot.readListEnd()
8611 
        else:
8612 
          iprot.skip(ftype)
8613 
      elif fid == 1:
8614 
        if ftype == TType.STRUCT:
8615 
          self.cex = CatalogServiceException()
8616 
          self.cex.read(iprot)
8617 
        else:
8618 
          iprot.skip(ftype)
8619 
      else:
8620 
        iprot.skip(ftype)
8621 
      iprot.readFieldEnd()
8622 
    iprot.readStructEnd()
8623 
 
8624 
  def write(self, oprot):
8625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8627 
      return
8628 
    oprot.writeStructBegin('getAllItems_result')
8629 
    if self.success is not None:
8630 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8631 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8632 
      for iter66 in self.success:
8633 
        iter66.write(oprot)
5944 mandeep.dh 8634 
      oprot.writeListEnd()
8635 
      oprot.writeFieldEnd()
8636 
    if self.cex is not None:
8637 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8638 
      self.cex.write(oprot)
8639 
      oprot.writeFieldEnd()
8640 
    oprot.writeFieldStop()
8641 
    oprot.writeStructEnd()
8642 
 
8643 
  def validate(self):
8644 
    return
8645 
 
8646 
 
8647 
  def __repr__(self):
8648 
    L = ['%s=%r' % (key, value)
8649 
      for key, value in self.__dict__.iteritems()]
8650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8651 
 
8652 
  def __eq__(self, other):
8653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8654 
 
8655 
  def __ne__(self, other):
8656 
    return not (self == other)
8657 
 
8658 
class getAllItemsByStatus_args:
8659 
  """
8660 
  Attributes:
8661 
   - itemStatus
8662 
  """
8663 
 
8664 
  thrift_spec = (
8665 
    None, # 0
8666 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8667 
  )
8668 
 
8669 
  def __init__(self, itemStatus=None,):
8670 
    self.itemStatus = itemStatus
8671 
 
8672 
  def read(self, iprot):
8673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8675 
      return
8676 
    iprot.readStructBegin()
8677 
    while True:
8678 
      (fname, ftype, fid) = iprot.readFieldBegin()
8679 
      if ftype == TType.STOP:
8680 
        break
8681 
      if fid == 1:
8682 
        if ftype == TType.I32:
8683 
          self.itemStatus = iprot.readI32();
8684 
        else:
8685 
          iprot.skip(ftype)
8686 
      else:
8687 
        iprot.skip(ftype)
8688 
      iprot.readFieldEnd()
8689 
    iprot.readStructEnd()
8690 
 
8691 
  def write(self, oprot):
8692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8694 
      return
8695 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8696 
    if self.itemStatus is not None:
8697 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8698 
      oprot.writeI32(self.itemStatus)
8699 
      oprot.writeFieldEnd()
8700 
    oprot.writeFieldStop()
8701 
    oprot.writeStructEnd()
8702 
 
8703 
  def validate(self):
8704 
    return
8705 
 
8706 
 
8707 
  def __repr__(self):
8708 
    L = ['%s=%r' % (key, value)
8709 
      for key, value in self.__dict__.iteritems()]
8710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8711 
 
8712 
  def __eq__(self, other):
8713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8714 
 
8715 
  def __ne__(self, other):
8716 
    return not (self == other)
8717 
 
8718 
class getAllItemsByStatus_result:
8719 
  """
8720 
  Attributes:
8721 
   - success
8722 
   - cex
8723 
  """
8724 
 
8725 
  thrift_spec = (
8726 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8727 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8728 
  )
8729 
 
8730 
  def __init__(self, success=None, cex=None,):
8731 
    self.success = success
8732 
    self.cex = cex
8733 
 
8734 
  def read(self, iprot):
8735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8737 
      return
8738 
    iprot.readStructBegin()
8739 
    while True:
8740 
      (fname, ftype, fid) = iprot.readFieldBegin()
8741 
      if ftype == TType.STOP:
8742 
        break
8743 
      if fid == 0:
8744 
        if ftype == TType.LIST:
8745 
          self.success = []
8590 kshitij.so 8746 
          (_etype70, _size67) = iprot.readListBegin()
8747 
          for _i71 in xrange(_size67):
8748 
            _elem72 = Item()
8749 
            _elem72.read(iprot)
8750 
            self.success.append(_elem72)
5944 mandeep.dh 8751 
          iprot.readListEnd()
8752 
        else:
8753 
          iprot.skip(ftype)
8754 
      elif fid == 1:
8755 
        if ftype == TType.STRUCT:
8756 
          self.cex = CatalogServiceException()
8757 
          self.cex.read(iprot)
8758 
        else:
8759 
          iprot.skip(ftype)
8760 
      else:
8761 
        iprot.skip(ftype)
8762 
      iprot.readFieldEnd()
8763 
    iprot.readStructEnd()
8764 
 
8765 
  def write(self, oprot):
8766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8768 
      return
8769 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8770 
    if self.success is not None:
8771 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8772 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8773 
      for iter73 in self.success:
8774 
        iter73.write(oprot)
5944 mandeep.dh 8775 
      oprot.writeListEnd()
8776 
      oprot.writeFieldEnd()
8777 
    if self.cex is not None:
8778 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8779 
      self.cex.write(oprot)
8780 
      oprot.writeFieldEnd()
8781 
    oprot.writeFieldStop()
8782 
    oprot.writeStructEnd()
8783 
 
8784 
  def validate(self):
8785 
    return
8786 
 
8787 
 
8788 
  def __repr__(self):
8789 
    L = ['%s=%r' % (key, value)
8790 
      for key, value in self.__dict__.iteritems()]
8791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8792 
 
8793 
  def __eq__(self, other):
8794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8795 
 
8796 
  def __ne__(self, other):
8797 
    return not (self == other)
8798 
 
8799 
class markItemAsContentComplete_args:
8800 
  """
8801 
  Attributes:
8802 
   - entityId
8803 
   - category
8804 
   - brand
8805 
   - modelName
8806 
   - modelNumber
9253 rajveer 8807 
   - isAndroid
5944 mandeep.dh 8808 
  """
8809 
 
8810 
  thrift_spec = (
8811 
    None, # 0
8812 
    (1, TType.I64, 'entityId', None, None, ), # 1
8813 
    (2, TType.I64, 'category', None, None, ), # 2
8814 
    (3, TType.STRING, 'brand', None, None, ), # 3
8815 
    (4, TType.STRING, 'modelName', None, None, ), # 4
8816 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 8817 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 8818 
  )
8819 
 
9253 rajveer 8820 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 8821 
    self.entityId = entityId
8822 
    self.category = category
8823 
    self.brand = brand
8824 
    self.modelName = modelName
8825 
    self.modelNumber = modelNumber
9253 rajveer 8826 
    self.isAndroid = isAndroid
5944 mandeep.dh 8827 
 
8828 
  def read(self, iprot):
8829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8831 
      return
8832 
    iprot.readStructBegin()
8833 
    while True:
8834 
      (fname, ftype, fid) = iprot.readFieldBegin()
8835 
      if ftype == TType.STOP:
8836 
        break
8837 
      if fid == 1:
8838 
        if ftype == TType.I64:
8839 
          self.entityId = iprot.readI64();
8840 
        else:
8841 
          iprot.skip(ftype)
8842 
      elif fid == 2:
8843 
        if ftype == TType.I64:
8844 
          self.category = iprot.readI64();
8845 
        else:
8846 
          iprot.skip(ftype)
8847 
      elif fid == 3:
8848 
        if ftype == TType.STRING:
8849 
          self.brand = iprot.readString();
8850 
        else:
8851 
          iprot.skip(ftype)
8852 
      elif fid == 4:
8853 
        if ftype == TType.STRING:
8854 
          self.modelName = iprot.readString();
8855 
        else:
8856 
          iprot.skip(ftype)
8857 
      elif fid == 5:
8858 
        if ftype == TType.STRING:
8859 
          self.modelNumber = iprot.readString();
8860 
        else:
8861 
          iprot.skip(ftype)
9253 rajveer 8862 
      elif fid == 6:
8863 
        if ftype == TType.BOOL:
8864 
          self.isAndroid = iprot.readBool();
8865 
        else:
8866 
          iprot.skip(ftype)
5944 mandeep.dh 8867 
      else:
8868 
        iprot.skip(ftype)
8869 
      iprot.readFieldEnd()
8870 
    iprot.readStructEnd()
8871 
 
8872 
  def write(self, oprot):
8873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8875 
      return
8876 
    oprot.writeStructBegin('markItemAsContentComplete_args')
8877 
    if self.entityId is not None:
8878 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
8879 
      oprot.writeI64(self.entityId)
8880 
      oprot.writeFieldEnd()
8881 
    if self.category is not None:
8882 
      oprot.writeFieldBegin('category', TType.I64, 2)
8883 
      oprot.writeI64(self.category)
8884 
      oprot.writeFieldEnd()
8885 
    if self.brand is not None:
8886 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8887 
      oprot.writeString(self.brand)
8888 
      oprot.writeFieldEnd()
8889 
    if self.modelName is not None:
8890 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
8891 
      oprot.writeString(self.modelName)
8892 
      oprot.writeFieldEnd()
8893 
    if self.modelNumber is not None:
8894 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
8895 
      oprot.writeString(self.modelNumber)
8896 
      oprot.writeFieldEnd()
9253 rajveer 8897 
    if self.isAndroid is not None:
8898 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
8899 
      oprot.writeBool(self.isAndroid)
8900 
      oprot.writeFieldEnd()
5944 mandeep.dh 8901 
    oprot.writeFieldStop()
8902 
    oprot.writeStructEnd()
8903 
 
8904 
  def validate(self):
8905 
    return
8906 
 
8907 
 
8908 
  def __repr__(self):
8909 
    L = ['%s=%r' % (key, value)
8910 
      for key, value in self.__dict__.iteritems()]
8911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8912 
 
8913 
  def __eq__(self, other):
8914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8915 
 
8916 
  def __ne__(self, other):
8917 
    return not (self == other)
8918 
 
8919 
class markItemAsContentComplete_result:
8920 
  """
8921 
  Attributes:
8922 
   - success
8923 
   - cex
8924 
  """
8925 
 
8926 
  thrift_spec = (
8927 
    (0, TType.BOOL, 'success', None, None, ), # 0
8928 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8929 
  )
8930 
 
8931 
  def __init__(self, success=None, cex=None,):
8932 
    self.success = success
8933 
    self.cex = cex
8934 
 
8935 
  def read(self, iprot):
8936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8938 
      return
8939 
    iprot.readStructBegin()
8940 
    while True:
8941 
      (fname, ftype, fid) = iprot.readFieldBegin()
8942 
      if ftype == TType.STOP:
8943 
        break
8944 
      if fid == 0:
8945 
        if ftype == TType.BOOL:
8946 
          self.success = iprot.readBool();
8947 
        else:
8948 
          iprot.skip(ftype)
8949 
      elif fid == 1:
8950 
        if ftype == TType.STRUCT:
8951 
          self.cex = CatalogServiceException()
8952 
          self.cex.read(iprot)
8953 
        else:
8954 
          iprot.skip(ftype)
8955 
      else:
8956 
        iprot.skip(ftype)
8957 
      iprot.readFieldEnd()
8958 
    iprot.readStructEnd()
8959 
 
8960 
  def write(self, oprot):
8961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8963 
      return
8964 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8965 
    if self.success is not None:
8966 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8967 
      oprot.writeBool(self.success)
8968 
      oprot.writeFieldEnd()
8969 
    if self.cex is not None:
8970 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8971 
      self.cex.write(oprot)
8972 
      oprot.writeFieldEnd()
8973 
    oprot.writeFieldStop()
8974 
    oprot.writeStructEnd()
8975 
 
8976 
  def validate(self):
8977 
    return
8978 
 
8979 
 
8980 
  def __repr__(self):
8981 
    L = ['%s=%r' % (key, value)
8982 
      for key, value in self.__dict__.iteritems()]
8983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8984 
 
8985 
  def __eq__(self, other):
8986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8987 
 
8988 
  def __ne__(self, other):
8989 
    return not (self == other)
8990 
 
8991 
class getAllItemsInRange_args:
8992 
  """
8993 
  Attributes:
8994 
   - offset
8995 
   - limit
8996 
  """
8997 
 
8998 
  thrift_spec = (
8999 
    None, # 0
9000 
    (1, TType.I64, 'offset', None, None, ), # 1
9001 
    (2, TType.I64, 'limit', None, None, ), # 2
9002 
  )
9003 
 
9004 
  def __init__(self, offset=None, limit=None,):
9005 
    self.offset = offset
9006 
    self.limit = limit
9007 
 
9008 
  def read(self, iprot):
9009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9011 
      return
9012 
    iprot.readStructBegin()
9013 
    while True:
9014 
      (fname, ftype, fid) = iprot.readFieldBegin()
9015 
      if ftype == TType.STOP:
9016 
        break
9017 
      if fid == 1:
9018 
        if ftype == TType.I64:
9019 
          self.offset = iprot.readI64();
9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      elif fid == 2:
9023 
        if ftype == TType.I64:
9024 
          self.limit = iprot.readI64();
9025 
        else:
9026 
          iprot.skip(ftype)
9027 
      else:
9028 
        iprot.skip(ftype)
9029 
      iprot.readFieldEnd()
9030 
    iprot.readStructEnd()
9031 
 
9032 
  def write(self, oprot):
9033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9035 
      return
9036 
    oprot.writeStructBegin('getAllItemsInRange_args')
9037 
    if self.offset is not None:
9038 
      oprot.writeFieldBegin('offset', TType.I64, 1)
9039 
      oprot.writeI64(self.offset)
9040 
      oprot.writeFieldEnd()
9041 
    if self.limit is not None:
9042 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9043 
      oprot.writeI64(self.limit)
9044 
      oprot.writeFieldEnd()
9045 
    oprot.writeFieldStop()
9046 
    oprot.writeStructEnd()
9047 
 
9048 
  def validate(self):
9049 
    return
9050 
 
9051 
 
9052 
  def __repr__(self):
9053 
    L = ['%s=%r' % (key, value)
9054 
      for key, value in self.__dict__.iteritems()]
9055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9056 
 
9057 
  def __eq__(self, other):
9058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9059 
 
9060 
  def __ne__(self, other):
9061 
    return not (self == other)
9062 
 
9063 
class getAllItemsInRange_result:
9064 
  """
9065 
  Attributes:
9066 
   - success
9067 
   - cex
9068 
  """
9069 
 
9070 
  thrift_spec = (
9071 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9072 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9073 
  )
9074 
 
9075 
  def __init__(self, success=None, cex=None,):
9076 
    self.success = success
9077 
    self.cex = cex
9078 
 
9079 
  def read(self, iprot):
9080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9082 
      return
9083 
    iprot.readStructBegin()
9084 
    while True:
9085 
      (fname, ftype, fid) = iprot.readFieldBegin()
9086 
      if ftype == TType.STOP:
9087 
        break
9088 
      if fid == 0:
9089 
        if ftype == TType.LIST:
9090 
          self.success = []
8590 kshitij.so 9091 
          (_etype77, _size74) = iprot.readListBegin()
9092 
          for _i78 in xrange(_size74):
9093 
            _elem79 = Item()
9094 
            _elem79.read(iprot)
9095 
            self.success.append(_elem79)
5944 mandeep.dh 9096 
          iprot.readListEnd()
9097 
        else:
9098 
          iprot.skip(ftype)
9099 
      elif fid == 1:
9100 
        if ftype == TType.STRUCT:
9101 
          self.cex = CatalogServiceException()
9102 
          self.cex.read(iprot)
9103 
        else:
9104 
          iprot.skip(ftype)
9105 
      else:
9106 
        iprot.skip(ftype)
9107 
      iprot.readFieldEnd()
9108 
    iprot.readStructEnd()
9109 
 
9110 
  def write(self, oprot):
9111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9113 
      return
9114 
    oprot.writeStructBegin('getAllItemsInRange_result')
9115 
    if self.success is not None:
9116 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9117 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9118 
      for iter80 in self.success:
9119 
        iter80.write(oprot)
5944 mandeep.dh 9120 
      oprot.writeListEnd()
9121 
      oprot.writeFieldEnd()
9122 
    if self.cex is not None:
9123 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9124 
      self.cex.write(oprot)
9125 
      oprot.writeFieldEnd()
9126 
    oprot.writeFieldStop()
9127 
    oprot.writeStructEnd()
9128 
 
9129 
  def validate(self):
9130 
    return
9131 
 
9132 
 
9133 
  def __repr__(self):
9134 
    L = ['%s=%r' % (key, value)
9135 
      for key, value in self.__dict__.iteritems()]
9136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9137 
 
9138 
  def __eq__(self, other):
9139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9140 
 
9141 
  def __ne__(self, other):
9142 
    return not (self == other)
9143 
 
9144 
class getAllItemsByStatusInRange_args:
9145 
  """
9146 
  Attributes:
9147 
   - itemStatus
9148 
   - offset
9149 
   - limit
9150 
  """
9151 
 
9152 
  thrift_spec = (
9153 
    None, # 0
9154 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
9155 
    (2, TType.I64, 'offset', None, None, ), # 2
9156 
    (3, TType.I64, 'limit', None, None, ), # 3
9157 
  )
9158 
 
9159 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
9160 
    self.itemStatus = itemStatus
9161 
    self.offset = offset
9162 
    self.limit = limit
9163 
 
9164 
  def read(self, iprot):
9165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9167 
      return
9168 
    iprot.readStructBegin()
9169 
    while True:
9170 
      (fname, ftype, fid) = iprot.readFieldBegin()
9171 
      if ftype == TType.STOP:
9172 
        break
9173 
      if fid == 1:
9174 
        if ftype == TType.I32:
9175 
          self.itemStatus = iprot.readI32();
9176 
        else:
9177 
          iprot.skip(ftype)
9178 
      elif fid == 2:
9179 
        if ftype == TType.I64:
9180 
          self.offset = iprot.readI64();
9181 
        else:
9182 
          iprot.skip(ftype)
9183 
      elif fid == 3:
9184 
        if ftype == TType.I64:
9185 
          self.limit = iprot.readI64();
9186 
        else:
9187 
          iprot.skip(ftype)
9188 
      else:
9189 
        iprot.skip(ftype)
9190 
      iprot.readFieldEnd()
9191 
    iprot.readStructEnd()
9192 
 
9193 
  def write(self, oprot):
9194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9196 
      return
9197 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
9198 
    if self.itemStatus is not None:
9199 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
9200 
      oprot.writeI32(self.itemStatus)
9201 
      oprot.writeFieldEnd()
9202 
    if self.offset is not None:
9203 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9204 
      oprot.writeI64(self.offset)
9205 
      oprot.writeFieldEnd()
9206 
    if self.limit is not None:
9207 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9208 
      oprot.writeI64(self.limit)
9209 
      oprot.writeFieldEnd()
9210 
    oprot.writeFieldStop()
9211 
    oprot.writeStructEnd()
9212 
 
9213 
  def validate(self):
9214 
    return
9215 
 
9216 
 
9217 
  def __repr__(self):
9218 
    L = ['%s=%r' % (key, value)
9219 
      for key, value in self.__dict__.iteritems()]
9220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9221 
 
9222 
  def __eq__(self, other):
9223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9224 
 
9225 
  def __ne__(self, other):
9226 
    return not (self == other)
9227 
 
9228 
class getAllItemsByStatusInRange_result:
9229 
  """
9230 
  Attributes:
9231 
   - success
9232 
   - cex
9233 
  """
9234 
 
9235 
  thrift_spec = (
9236 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9237 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9238 
  )
9239 
 
9240 
  def __init__(self, success=None, cex=None,):
9241 
    self.success = success
9242 
    self.cex = cex
9243 
 
9244 
  def read(self, iprot):
9245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9247 
      return
9248 
    iprot.readStructBegin()
9249 
    while True:
9250 
      (fname, ftype, fid) = iprot.readFieldBegin()
9251 
      if ftype == TType.STOP:
9252 
        break
9253 
      if fid == 0:
9254 
        if ftype == TType.LIST:
9255 
          self.success = []
8590 kshitij.so 9256 
          (_etype84, _size81) = iprot.readListBegin()
9257 
          for _i85 in xrange(_size81):
9258 
            _elem86 = Item()
9259 
            _elem86.read(iprot)
9260 
            self.success.append(_elem86)
5944 mandeep.dh 9261 
          iprot.readListEnd()
9262 
        else:
9263 
          iprot.skip(ftype)
9264 
      elif fid == 1:
9265 
        if ftype == TType.STRUCT:
9266 
          self.cex = CatalogServiceException()
9267 
          self.cex.read(iprot)
9268 
        else:
9269 
          iprot.skip(ftype)
9270 
      else:
9271 
        iprot.skip(ftype)
9272 
      iprot.readFieldEnd()
9273 
    iprot.readStructEnd()
9274 
 
9275 
  def write(self, oprot):
9276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9278 
      return
9279 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
9280 
    if self.success is not None:
9281 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9282 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9283 
      for iter87 in self.success:
9284 
        iter87.write(oprot)
5944 mandeep.dh 9285 
      oprot.writeListEnd()
9286 
      oprot.writeFieldEnd()
9287 
    if self.cex is not None:
9288 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9289 
      self.cex.write(oprot)
9290 
      oprot.writeFieldEnd()
9291 
    oprot.writeFieldStop()
9292 
    oprot.writeStructEnd()
9293 
 
9294 
  def validate(self):
9295 
    return
9296 
 
9297 
 
9298 
  def __repr__(self):
9299 
    L = ['%s=%r' % (key, value)
9300 
      for key, value in self.__dict__.iteritems()]
9301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9302 
 
9303 
  def __eq__(self, other):
9304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9305 
 
9306 
  def __ne__(self, other):
9307 
    return not (self == other)
9308 
 
9309 
class getItemCountByStatus_args:
9310 
  """
9311 
  Attributes:
9312 
   - useStatus
9313 
   - itemStatus
9314 
  """
9315 
 
9316 
  thrift_spec = (
9317 
    None, # 0
9318 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
9319 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
9320 
  )
9321 
 
9322 
  def __init__(self, useStatus=None, itemStatus=None,):
9323 
    self.useStatus = useStatus
9324 
    self.itemStatus = itemStatus
9325 
 
9326 
  def read(self, iprot):
9327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9329 
      return
9330 
    iprot.readStructBegin()
9331 
    while True:
9332 
      (fname, ftype, fid) = iprot.readFieldBegin()
9333 
      if ftype == TType.STOP:
9334 
        break
9335 
      if fid == 1:
9336 
        if ftype == TType.BOOL:
9337 
          self.useStatus = iprot.readBool();
9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      elif fid == 2:
9341 
        if ftype == TType.I32:
9342 
          self.itemStatus = iprot.readI32();
9343 
        else:
9344 
          iprot.skip(ftype)
9345 
      else:
9346 
        iprot.skip(ftype)
9347 
      iprot.readFieldEnd()
9348 
    iprot.readStructEnd()
9349 
 
9350 
  def write(self, oprot):
9351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9353 
      return
9354 
    oprot.writeStructBegin('getItemCountByStatus_args')
9355 
    if self.useStatus is not None:
9356 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
9357 
      oprot.writeBool(self.useStatus)
9358 
      oprot.writeFieldEnd()
9359 
    if self.itemStatus is not None:
9360 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
9361 
      oprot.writeI32(self.itemStatus)
9362 
      oprot.writeFieldEnd()
9363 
    oprot.writeFieldStop()
9364 
    oprot.writeStructEnd()
9365 
 
9366 
  def validate(self):
9367 
    return
9368 
 
9369 
 
9370 
  def __repr__(self):
9371 
    L = ['%s=%r' % (key, value)
9372 
      for key, value in self.__dict__.iteritems()]
9373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9374 
 
9375 
  def __eq__(self, other):
9376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9377 
 
9378 
  def __ne__(self, other):
9379 
    return not (self == other)
9380 
 
9381 
class getItemCountByStatus_result:
9382 
  """
9383 
  Attributes:
9384 
   - success
9385 
  """
9386 
 
9387 
  thrift_spec = (
9388 
    (0, TType.I32, 'success', None, None, ), # 0
9389 
  )
9390 
 
9391 
  def __init__(self, success=None,):
9392 
    self.success = success
9393 
 
9394 
  def read(self, iprot):
9395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9397 
      return
9398 
    iprot.readStructBegin()
9399 
    while True:
9400 
      (fname, ftype, fid) = iprot.readFieldBegin()
9401 
      if ftype == TType.STOP:
9402 
        break
9403 
      if fid == 0:
9404 
        if ftype == TType.I32:
9405 
          self.success = iprot.readI32();
9406 
        else:
9407 
          iprot.skip(ftype)
9408 
      else:
9409 
        iprot.skip(ftype)
9410 
      iprot.readFieldEnd()
9411 
    iprot.readStructEnd()
9412 
 
9413 
  def write(self, oprot):
9414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9416 
      return
9417 
    oprot.writeStructBegin('getItemCountByStatus_result')
9418 
    if self.success is not None:
9419 
      oprot.writeFieldBegin('success', TType.I32, 0)
9420 
      oprot.writeI32(self.success)
9421 
      oprot.writeFieldEnd()
9422 
    oprot.writeFieldStop()
9423 
    oprot.writeStructEnd()
9424 
 
9425 
  def validate(self):
9426 
    return
9427 
 
9428 
 
9429 
  def __repr__(self):
9430 
    L = ['%s=%r' % (key, value)
9431 
      for key, value in self.__dict__.iteritems()]
9432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9433 
 
9434 
  def __eq__(self, other):
9435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9436 
 
9437 
  def __ne__(self, other):
9438 
    return not (self == other)
9439 
 
9440 
class getBestSellers_args:
9441 
 
9442 
  thrift_spec = (
9443 
  )
9444 
 
9445 
  def read(self, iprot):
9446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9448 
      return
9449 
    iprot.readStructBegin()
9450 
    while True:
9451 
      (fname, ftype, fid) = iprot.readFieldBegin()
9452 
      if ftype == TType.STOP:
9453 
        break
9454 
      else:
9455 
        iprot.skip(ftype)
9456 
      iprot.readFieldEnd()
9457 
    iprot.readStructEnd()
9458 
 
9459 
  def write(self, oprot):
9460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9462 
      return
9463 
    oprot.writeStructBegin('getBestSellers_args')
9464 
    oprot.writeFieldStop()
9465 
    oprot.writeStructEnd()
9466 
 
9467 
  def validate(self):
9468 
    return
9469 
 
9470 
 
9471 
  def __repr__(self):
9472 
    L = ['%s=%r' % (key, value)
9473 
      for key, value in self.__dict__.iteritems()]
9474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9475 
 
9476 
  def __eq__(self, other):
9477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9478 
 
9479 
  def __ne__(self, other):
9480 
    return not (self == other)
9481 
 
9482 
class getBestSellers_result:
9483 
  """
9484 
  Attributes:
9485 
   - success
9486 
   - isex
9487 
  """
9488 
 
9489 
  thrift_spec = (
9490 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9491 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9492 
  )
9493 
 
9494 
  def __init__(self, success=None, isex=None,):
9495 
    self.success = success
9496 
    self.isex = isex
9497 
 
9498 
  def read(self, iprot):
9499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9501 
      return
9502 
    iprot.readStructBegin()
9503 
    while True:
9504 
      (fname, ftype, fid) = iprot.readFieldBegin()
9505 
      if ftype == TType.STOP:
9506 
        break
9507 
      if fid == 0:
9508 
        if ftype == TType.LIST:
9509 
          self.success = []
8590 kshitij.so 9510 
          (_etype91, _size88) = iprot.readListBegin()
9511 
          for _i92 in xrange(_size88):
9512 
            _elem93 = Item()
9513 
            _elem93.read(iprot)
9514 
            self.success.append(_elem93)
5944 mandeep.dh 9515 
          iprot.readListEnd()
9516 
        else:
9517 
          iprot.skip(ftype)
9518 
      elif fid == 1:
9519 
        if ftype == TType.STRUCT:
9520 
          self.isex = CatalogServiceException()
9521 
          self.isex.read(iprot)
9522 
        else:
9523 
          iprot.skip(ftype)
9524 
      else:
9525 
        iprot.skip(ftype)
9526 
      iprot.readFieldEnd()
9527 
    iprot.readStructEnd()
9528 
 
9529 
  def write(self, oprot):
9530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9532 
      return
9533 
    oprot.writeStructBegin('getBestSellers_result')
9534 
    if self.success is not None:
9535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9537 
      for iter94 in self.success:
9538 
        iter94.write(oprot)
5944 mandeep.dh 9539 
      oprot.writeListEnd()
9540 
      oprot.writeFieldEnd()
9541 
    if self.isex is not None:
9542 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9543 
      self.isex.write(oprot)
9544 
      oprot.writeFieldEnd()
9545 
    oprot.writeFieldStop()
9546 
    oprot.writeStructEnd()
9547 
 
9548 
  def validate(self):
9549 
    return
9550 
 
9551 
 
9552 
  def __repr__(self):
9553 
    L = ['%s=%r' % (key, value)
9554 
      for key, value in self.__dict__.iteritems()]
9555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9556 
 
9557 
  def __eq__(self, other):
9558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9559 
 
9560 
  def __ne__(self, other):
9561 
    return not (self == other)
9562 
 
9563 
class getBestSellersCatalogIds_args:
9564 
  """
9565 
  Attributes:
9566 
   - beginIndex
9567 
   - totalItems
9568 
   - brand
9569 
   - category
9570 
  """
9571 
 
9572 
  thrift_spec = (
9573 
    None, # 0
9574 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9575 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9576 
    (3, TType.STRING, 'brand', None, None, ), # 3
9577 
    (4, TType.I64, 'category', None, None, ), # 4
9578 
  )
9579 
 
9580 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9581 
    self.beginIndex = beginIndex
9582 
    self.totalItems = totalItems
9583 
    self.brand = brand
9584 
    self.category = category
9585 
 
9586 
  def read(self, iprot):
9587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9589 
      return
9590 
    iprot.readStructBegin()
9591 
    while True:
9592 
      (fname, ftype, fid) = iprot.readFieldBegin()
9593 
      if ftype == TType.STOP:
9594 
        break
9595 
      if fid == 1:
9596 
        if ftype == TType.I64:
9597 
          self.beginIndex = iprot.readI64();
9598 
        else:
9599 
          iprot.skip(ftype)
9600 
      elif fid == 2:
9601 
        if ftype == TType.I64:
9602 
          self.totalItems = iprot.readI64();
9603 
        else:
9604 
          iprot.skip(ftype)
9605 
      elif fid == 3:
9606 
        if ftype == TType.STRING:
9607 
          self.brand = iprot.readString();
9608 
        else:
9609 
          iprot.skip(ftype)
9610 
      elif fid == 4:
9611 
        if ftype == TType.I64:
9612 
          self.category = iprot.readI64();
9613 
        else:
9614 
          iprot.skip(ftype)
9615 
      else:
9616 
        iprot.skip(ftype)
9617 
      iprot.readFieldEnd()
9618 
    iprot.readStructEnd()
9619 
 
9620 
  def write(self, oprot):
9621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9623 
      return
9624 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9625 
    if self.beginIndex is not None:
9626 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9627 
      oprot.writeI64(self.beginIndex)
9628 
      oprot.writeFieldEnd()
9629 
    if self.totalItems is not None:
9630 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9631 
      oprot.writeI64(self.totalItems)
9632 
      oprot.writeFieldEnd()
9633 
    if self.brand is not None:
9634 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9635 
      oprot.writeString(self.brand)
9636 
      oprot.writeFieldEnd()
9637 
    if self.category is not None:
9638 
      oprot.writeFieldBegin('category', TType.I64, 4)
9639 
      oprot.writeI64(self.category)
9640 
      oprot.writeFieldEnd()
9641 
    oprot.writeFieldStop()
9642 
    oprot.writeStructEnd()
9643 
 
9644 
  def validate(self):
9645 
    return
9646 
 
9647 
 
9648 
  def __repr__(self):
9649 
    L = ['%s=%r' % (key, value)
9650 
      for key, value in self.__dict__.iteritems()]
9651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9652 
 
9653 
  def __eq__(self, other):
9654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9655 
 
9656 
  def __ne__(self, other):
9657 
    return not (self == other)
9658 
 
9659 
class getBestSellersCatalogIds_result:
9660 
  """
9661 
  Attributes:
9662 
   - success
9663 
   - cex
9664 
  """
9665 
 
9666 
  thrift_spec = (
9667 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9668 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9669 
  )
9670 
 
9671 
  def __init__(self, success=None, cex=None,):
9672 
    self.success = success
9673 
    self.cex = cex
9674 
 
9675 
  def read(self, iprot):
9676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9678 
      return
9679 
    iprot.readStructBegin()
9680 
    while True:
9681 
      (fname, ftype, fid) = iprot.readFieldBegin()
9682 
      if ftype == TType.STOP:
9683 
        break
9684 
      if fid == 0:
9685 
        if ftype == TType.LIST:
9686 
          self.success = []
8590 kshitij.so 9687 
          (_etype98, _size95) = iprot.readListBegin()
9688 
          for _i99 in xrange(_size95):
9689 
            _elem100 = iprot.readI64();
9690 
            self.success.append(_elem100)
5944 mandeep.dh 9691 
          iprot.readListEnd()
9692 
        else:
9693 
          iprot.skip(ftype)
9694 
      elif fid == 1:
9695 
        if ftype == TType.STRUCT:
9696 
          self.cex = CatalogServiceException()
9697 
          self.cex.read(iprot)
9698 
        else:
9699 
          iprot.skip(ftype)
9700 
      else:
9701 
        iprot.skip(ftype)
9702 
      iprot.readFieldEnd()
9703 
    iprot.readStructEnd()
9704 
 
9705 
  def write(self, oprot):
9706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9708 
      return
9709 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9710 
    if self.success is not None:
9711 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9712 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9713 
      for iter101 in self.success:
9714 
        oprot.writeI64(iter101)
5944 mandeep.dh 9715 
      oprot.writeListEnd()
9716 
      oprot.writeFieldEnd()
9717 
    if self.cex is not None:
9718 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9719 
      self.cex.write(oprot)
9720 
      oprot.writeFieldEnd()
9721 
    oprot.writeFieldStop()
9722 
    oprot.writeStructEnd()
9723 
 
9724 
  def validate(self):
9725 
    return
9726 
 
9727 
 
9728 
  def __repr__(self):
9729 
    L = ['%s=%r' % (key, value)
9730 
      for key, value in self.__dict__.iteritems()]
9731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9732 
 
9733 
  def __eq__(self, other):
9734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9735 
 
9736 
  def __ne__(self, other):
9737 
    return not (self == other)
9738 
 
9739 
class getBestSellersCount_args:
9740 
 
9741 
  thrift_spec = (
9742 
  )
9743 
 
9744 
  def read(self, iprot):
9745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9747 
      return
9748 
    iprot.readStructBegin()
9749 
    while True:
9750 
      (fname, ftype, fid) = iprot.readFieldBegin()
9751 
      if ftype == TType.STOP:
9752 
        break
9753 
      else:
9754 
        iprot.skip(ftype)
9755 
      iprot.readFieldEnd()
9756 
    iprot.readStructEnd()
9757 
 
9758 
  def write(self, oprot):
9759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9761 
      return
9762 
    oprot.writeStructBegin('getBestSellersCount_args')
9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
9781 
class getBestSellersCount_result:
9782 
  """
9783 
  Attributes:
9784 
   - success
9785 
   - cex
9786 
  """
9787 
 
9788 
  thrift_spec = (
9789 
    (0, TType.I64, 'success', None, None, ), # 0
9790 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9791 
  )
9792 
 
9793 
  def __init__(self, success=None, cex=None,):
9794 
    self.success = success
9795 
    self.cex = cex
9796 
 
9797 
  def read(self, iprot):
9798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9800 
      return
9801 
    iprot.readStructBegin()
9802 
    while True:
9803 
      (fname, ftype, fid) = iprot.readFieldBegin()
9804 
      if ftype == TType.STOP:
9805 
        break
9806 
      if fid == 0:
9807 
        if ftype == TType.I64:
9808 
          self.success = iprot.readI64();
9809 
        else:
9810 
          iprot.skip(ftype)
9811 
      elif fid == 1:
9812 
        if ftype == TType.STRUCT:
9813 
          self.cex = CatalogServiceException()
9814 
          self.cex.read(iprot)
9815 
        else:
9816 
          iprot.skip(ftype)
9817 
      else:
9818 
        iprot.skip(ftype)
9819 
      iprot.readFieldEnd()
9820 
    iprot.readStructEnd()
9821 
 
9822 
  def write(self, oprot):
9823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9825 
      return
9826 
    oprot.writeStructBegin('getBestSellersCount_result')
9827 
    if self.success is not None:
9828 
      oprot.writeFieldBegin('success', TType.I64, 0)
9829 
      oprot.writeI64(self.success)
9830 
      oprot.writeFieldEnd()
9831 
    if self.cex is not None:
9832 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9833 
      self.cex.write(oprot)
9834 
      oprot.writeFieldEnd()
9835 
    oprot.writeFieldStop()
9836 
    oprot.writeStructEnd()
9837 
 
9838 
  def validate(self):
9839 
    return
9840 
 
9841 
 
9842 
  def __repr__(self):
9843 
    L = ['%s=%r' % (key, value)
9844 
      for key, value in self.__dict__.iteritems()]
9845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9846 
 
9847 
  def __eq__(self, other):
9848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9849 
 
9850 
  def __ne__(self, other):
9851 
    return not (self == other)
9852 
 
9853 
class getBestDeals_args:
9854 
 
9855 
  thrift_spec = (
9856 
  )
9857 
 
9858 
  def read(self, iprot):
9859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9861 
      return
9862 
    iprot.readStructBegin()
9863 
    while True:
9864 
      (fname, ftype, fid) = iprot.readFieldBegin()
9865 
      if ftype == TType.STOP:
9866 
        break
9867 
      else:
9868 
        iprot.skip(ftype)
9869 
      iprot.readFieldEnd()
9870 
    iprot.readStructEnd()
9871 
 
9872 
  def write(self, oprot):
9873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9875 
      return
9876 
    oprot.writeStructBegin('getBestDeals_args')
9877 
    oprot.writeFieldStop()
9878 
    oprot.writeStructEnd()
9879 
 
9880 
  def validate(self):
9881 
    return
9882 
 
9883 
 
9884 
  def __repr__(self):
9885 
    L = ['%s=%r' % (key, value)
9886 
      for key, value in self.__dict__.iteritems()]
9887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9888 
 
9889 
  def __eq__(self, other):
9890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9891 
 
9892 
  def __ne__(self, other):
9893 
    return not (self == other)
9894 
 
9895 
class getBestDeals_result:
9896 
  """
9897 
  Attributes:
9898 
   - success
9899 
   - isex
9900 
  """
9901 
 
9902 
  thrift_spec = (
9903 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9904 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9905 
  )
9906 
 
9907 
  def __init__(self, success=None, isex=None,):
9908 
    self.success = success
9909 
    self.isex = isex
9910 
 
9911 
  def read(self, iprot):
9912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9914 
      return
9915 
    iprot.readStructBegin()
9916 
    while True:
9917 
      (fname, ftype, fid) = iprot.readFieldBegin()
9918 
      if ftype == TType.STOP:
9919 
        break
9920 
      if fid == 0:
9921 
        if ftype == TType.LIST:
9922 
          self.success = []
8590 kshitij.so 9923 
          (_etype105, _size102) = iprot.readListBegin()
9924 
          for _i106 in xrange(_size102):
9925 
            _elem107 = Item()
9926 
            _elem107.read(iprot)
9927 
            self.success.append(_elem107)
5944 mandeep.dh 9928 
          iprot.readListEnd()
9929 
        else:
9930 
          iprot.skip(ftype)
9931 
      elif fid == 1:
9932 
        if ftype == TType.STRUCT:
9933 
          self.isex = CatalogServiceException()
9934 
          self.isex.read(iprot)
9935 
        else:
9936 
          iprot.skip(ftype)
9937 
      else:
9938 
        iprot.skip(ftype)
9939 
      iprot.readFieldEnd()
9940 
    iprot.readStructEnd()
9941 
 
9942 
  def write(self, oprot):
9943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9945 
      return
9946 
    oprot.writeStructBegin('getBestDeals_result')
9947 
    if self.success is not None:
9948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9949 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9950 
      for iter108 in self.success:
9951 
        iter108.write(oprot)
5944 mandeep.dh 9952 
      oprot.writeListEnd()
9953 
      oprot.writeFieldEnd()
9954 
    if self.isex is not None:
9955 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9956 
      self.isex.write(oprot)
9957 
      oprot.writeFieldEnd()
9958 
    oprot.writeFieldStop()
9959 
    oprot.writeStructEnd()
9960 
 
9961 
  def validate(self):
9962 
    return
9963 
 
9964 
 
9965 
  def __repr__(self):
9966 
    L = ['%s=%r' % (key, value)
9967 
      for key, value in self.__dict__.iteritems()]
9968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9969 
 
9970 
  def __eq__(self, other):
9971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9972 
 
9973 
  def __ne__(self, other):
9974 
    return not (self == other)
9975 
 
9976 
class getBestDealsCatalogIds_args:
9977 
  """
9978 
  Attributes:
9979 
   - beginIndex
9980 
   - totalItems
9981 
   - brand
9982 
   - category
9983 
  """
9984 
 
9985 
  thrift_spec = (
9986 
    None, # 0
9987 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9988 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9989 
    (3, TType.STRING, 'brand', None, None, ), # 3
9990 
    (4, TType.I64, 'category', None, None, ), # 4
9991 
  )
9992 
 
9993 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9994 
    self.beginIndex = beginIndex
9995 
    self.totalItems = totalItems
9996 
    self.brand = brand
9997 
    self.category = category
9998 
 
9999 
  def read(self, iprot):
10000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10002 
      return
10003 
    iprot.readStructBegin()
10004 
    while True:
10005 
      (fname, ftype, fid) = iprot.readFieldBegin()
10006 
      if ftype == TType.STOP:
10007 
        break
10008 
      if fid == 1:
10009 
        if ftype == TType.I64:
10010 
          self.beginIndex = iprot.readI64();
10011 
        else:
10012 
          iprot.skip(ftype)
10013 
      elif fid == 2:
10014 
        if ftype == TType.I64:
10015 
          self.totalItems = iprot.readI64();
10016 
        else:
10017 
          iprot.skip(ftype)
10018 
      elif fid == 3:
10019 
        if ftype == TType.STRING:
10020 
          self.brand = iprot.readString();
10021 
        else:
10022 
          iprot.skip(ftype)
10023 
      elif fid == 4:
10024 
        if ftype == TType.I64:
10025 
          self.category = iprot.readI64();
10026 
        else:
10027 
          iprot.skip(ftype)
10028 
      else:
10029 
        iprot.skip(ftype)
10030 
      iprot.readFieldEnd()
10031 
    iprot.readStructEnd()
10032 
 
10033 
  def write(self, oprot):
10034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10036 
      return
10037 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
10038 
    if self.beginIndex is not None:
10039 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10040 
      oprot.writeI64(self.beginIndex)
10041 
      oprot.writeFieldEnd()
10042 
    if self.totalItems is not None:
10043 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10044 
      oprot.writeI64(self.totalItems)
10045 
      oprot.writeFieldEnd()
10046 
    if self.brand is not None:
10047 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10048 
      oprot.writeString(self.brand)
10049 
      oprot.writeFieldEnd()
10050 
    if self.category is not None:
10051 
      oprot.writeFieldBegin('category', TType.I64, 4)
10052 
      oprot.writeI64(self.category)
10053 
      oprot.writeFieldEnd()
10054 
    oprot.writeFieldStop()
10055 
    oprot.writeStructEnd()
10056 
 
10057 
  def validate(self):
10058 
    return
10059 
 
10060 
 
10061 
  def __repr__(self):
10062 
    L = ['%s=%r' % (key, value)
10063 
      for key, value in self.__dict__.iteritems()]
10064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10065 
 
10066 
  def __eq__(self, other):
10067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10068 
 
10069 
  def __ne__(self, other):
10070 
    return not (self == other)
10071 
 
10072 
class getBestDealsCatalogIds_result:
10073 
  """
10074 
  Attributes:
10075 
   - success
10076 
   - cex
10077 
  """
10078 
 
10079 
  thrift_spec = (
10080 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10081 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10082 
  )
10083 
 
10084 
  def __init__(self, success=None, cex=None,):
10085 
    self.success = success
10086 
    self.cex = cex
10087 
 
10088 
  def read(self, iprot):
10089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10091 
      return
10092 
    iprot.readStructBegin()
10093 
    while True:
10094 
      (fname, ftype, fid) = iprot.readFieldBegin()
10095 
      if ftype == TType.STOP:
10096 
        break
10097 
      if fid == 0:
10098 
        if ftype == TType.LIST:
10099 
          self.success = []
8590 kshitij.so 10100 
          (_etype112, _size109) = iprot.readListBegin()
10101 
          for _i113 in xrange(_size109):
10102 
            _elem114 = iprot.readI64();
10103 
            self.success.append(_elem114)
5944 mandeep.dh 10104 
          iprot.readListEnd()
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      elif fid == 1:
10108 
        if ftype == TType.STRUCT:
10109 
          self.cex = CatalogServiceException()
10110 
          self.cex.read(iprot)
10111 
        else:
10112 
          iprot.skip(ftype)
10113 
      else:
10114 
        iprot.skip(ftype)
10115 
      iprot.readFieldEnd()
10116 
    iprot.readStructEnd()
10117 
 
10118 
  def write(self, oprot):
10119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10121 
      return
10122 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
10123 
    if self.success is not None:
10124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10125 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10126 
      for iter115 in self.success:
10127 
        oprot.writeI64(iter115)
5944 mandeep.dh 10128 
      oprot.writeListEnd()
10129 
      oprot.writeFieldEnd()
10130 
    if self.cex is not None:
10131 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10132 
      self.cex.write(oprot)
10133 
      oprot.writeFieldEnd()
10134 
    oprot.writeFieldStop()
10135 
    oprot.writeStructEnd()
10136 
 
10137 
  def validate(self):
10138 
    return
10139 
 
10140 
 
10141 
  def __repr__(self):
10142 
    L = ['%s=%r' % (key, value)
10143 
      for key, value in self.__dict__.iteritems()]
10144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10145 
 
10146 
  def __eq__(self, other):
10147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10148 
 
10149 
  def __ne__(self, other):
10150 
    return not (self == other)
10151 
 
10152 
class getBestDealsCount_args:
10153 
 
10154 
  thrift_spec = (
10155 
  )
10156 
 
10157 
  def read(self, iprot):
10158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10160 
      return
10161 
    iprot.readStructBegin()
10162 
    while True:
10163 
      (fname, ftype, fid) = iprot.readFieldBegin()
10164 
      if ftype == TType.STOP:
10165 
        break
10166 
      else:
10167 
        iprot.skip(ftype)
10168 
      iprot.readFieldEnd()
10169 
    iprot.readStructEnd()
10170 
 
10171 
  def write(self, oprot):
10172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10174 
      return
10175 
    oprot.writeStructBegin('getBestDealsCount_args')
10176 
    oprot.writeFieldStop()
10177 
    oprot.writeStructEnd()
10178 
 
10179 
  def validate(self):
10180 
    return
10181 
 
10182 
 
10183 
  def __repr__(self):
10184 
    L = ['%s=%r' % (key, value)
10185 
      for key, value in self.__dict__.iteritems()]
10186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10187 
 
10188 
  def __eq__(self, other):
10189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10190 
 
10191 
  def __ne__(self, other):
10192 
    return not (self == other)
10193 
 
10194 
class getBestDealsCount_result:
10195 
  """
10196 
  Attributes:
10197 
   - success
10198 
   - cex
10199 
  """
10200 
 
10201 
  thrift_spec = (
10202 
    (0, TType.I64, 'success', None, None, ), # 0
10203 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10204 
  )
10205 
 
10206 
  def __init__(self, success=None, cex=None,):
10207 
    self.success = success
10208 
    self.cex = cex
10209 
 
10210 
  def read(self, iprot):
10211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10213 
      return
10214 
    iprot.readStructBegin()
10215 
    while True:
10216 
      (fname, ftype, fid) = iprot.readFieldBegin()
10217 
      if ftype == TType.STOP:
10218 
        break
10219 
      if fid == 0:
10220 
        if ftype == TType.I64:
10221 
          self.success = iprot.readI64();
10222 
        else:
10223 
          iprot.skip(ftype)
10224 
      elif fid == 1:
10225 
        if ftype == TType.STRUCT:
10226 
          self.cex = CatalogServiceException()
10227 
          self.cex.read(iprot)
10228 
        else:
10229 
          iprot.skip(ftype)
10230 
      else:
10231 
        iprot.skip(ftype)
10232 
      iprot.readFieldEnd()
10233 
    iprot.readStructEnd()
10234 
 
10235 
  def write(self, oprot):
10236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10238 
      return
10239 
    oprot.writeStructBegin('getBestDealsCount_result')
10240 
    if self.success is not None:
10241 
      oprot.writeFieldBegin('success', TType.I64, 0)
10242 
      oprot.writeI64(self.success)
10243 
      oprot.writeFieldEnd()
10244 
    if self.cex is not None:
10245 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10246 
      self.cex.write(oprot)
10247 
      oprot.writeFieldEnd()
10248 
    oprot.writeFieldStop()
10249 
    oprot.writeStructEnd()
10250 
 
10251 
  def validate(self):
10252 
    return
10253 
 
10254 
 
10255 
  def __repr__(self):
10256 
    L = ['%s=%r' % (key, value)
10257 
      for key, value in self.__dict__.iteritems()]
10258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10259 
 
10260 
  def __eq__(self, other):
10261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10262 
 
10263 
  def __ne__(self, other):
10264 
    return not (self == other)
10265 
 
10266 
class getComingSoon_args:
10267 
 
10268 
  thrift_spec = (
10269 
  )
10270 
 
10271 
  def read(self, iprot):
10272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10274 
      return
10275 
    iprot.readStructBegin()
10276 
    while True:
10277 
      (fname, ftype, fid) = iprot.readFieldBegin()
10278 
      if ftype == TType.STOP:
10279 
        break
10280 
      else:
10281 
        iprot.skip(ftype)
10282 
      iprot.readFieldEnd()
10283 
    iprot.readStructEnd()
10284 
 
10285 
  def write(self, oprot):
10286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10288 
      return
10289 
    oprot.writeStructBegin('getComingSoon_args')
10290 
    oprot.writeFieldStop()
10291 
    oprot.writeStructEnd()
10292 
 
10293 
  def validate(self):
10294 
    return
10295 
 
10296 
 
10297 
  def __repr__(self):
10298 
    L = ['%s=%r' % (key, value)
10299 
      for key, value in self.__dict__.iteritems()]
10300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10301 
 
10302 
  def __eq__(self, other):
10303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10304 
 
10305 
  def __ne__(self, other):
10306 
    return not (self == other)
10307 
 
10308 
class getComingSoon_result:
10309 
  """
10310 
  Attributes:
10311 
   - success
10312 
   - isex
10313 
  """
10314 
 
10315 
  thrift_spec = (
10316 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10317 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10318 
  )
10319 
 
10320 
  def __init__(self, success=None, isex=None,):
10321 
    self.success = success
10322 
    self.isex = isex
10323 
 
10324 
  def read(self, iprot):
10325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10327 
      return
10328 
    iprot.readStructBegin()
10329 
    while True:
10330 
      (fname, ftype, fid) = iprot.readFieldBegin()
10331 
      if ftype == TType.STOP:
10332 
        break
10333 
      if fid == 0:
10334 
        if ftype == TType.LIST:
10335 
          self.success = []
8590 kshitij.so 10336 
          (_etype119, _size116) = iprot.readListBegin()
10337 
          for _i120 in xrange(_size116):
10338 
            _elem121 = Item()
10339 
            _elem121.read(iprot)
10340 
            self.success.append(_elem121)
5944 mandeep.dh 10341 
          iprot.readListEnd()
10342 
        else:
10343 
          iprot.skip(ftype)
10344 
      elif fid == 1:
10345 
        if ftype == TType.STRUCT:
10346 
          self.isex = CatalogServiceException()
10347 
          self.isex.read(iprot)
10348 
        else:
10349 
          iprot.skip(ftype)
10350 
      else:
10351 
        iprot.skip(ftype)
10352 
      iprot.readFieldEnd()
10353 
    iprot.readStructEnd()
10354 
 
10355 
  def write(self, oprot):
10356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10358 
      return
10359 
    oprot.writeStructBegin('getComingSoon_result')
10360 
    if self.success is not None:
10361 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10362 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10363 
      for iter122 in self.success:
10364 
        iter122.write(oprot)
5944 mandeep.dh 10365 
      oprot.writeListEnd()
10366 
      oprot.writeFieldEnd()
10367 
    if self.isex is not None:
10368 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10369 
      self.isex.write(oprot)
10370 
      oprot.writeFieldEnd()
10371 
    oprot.writeFieldStop()
10372 
    oprot.writeStructEnd()
10373 
 
10374 
  def validate(self):
10375 
    return
10376 
 
10377 
 
10378 
  def __repr__(self):
10379 
    L = ['%s=%r' % (key, value)
10380 
      for key, value in self.__dict__.iteritems()]
10381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10382 
 
10383 
  def __eq__(self, other):
10384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10385 
 
10386 
  def __ne__(self, other):
10387 
    return not (self == other)
10388 
 
10389 
class getComingSoonCatalogIds_args:
10390 
  """
10391 
  Attributes:
10392 
   - beginIndex
10393 
   - totalItems
10394 
   - brand
10395 
   - category
10396 
  """
10397 
 
10398 
  thrift_spec = (
10399 
    None, # 0
10400 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10401 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10402 
    (3, TType.STRING, 'brand', None, None, ), # 3
10403 
    (4, TType.I64, 'category', None, None, ), # 4
10404 
  )
10405 
 
10406 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10407 
    self.beginIndex = beginIndex
10408 
    self.totalItems = totalItems
10409 
    self.brand = brand
10410 
    self.category = category
10411 
 
10412 
  def read(self, iprot):
10413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10415 
      return
10416 
    iprot.readStructBegin()
10417 
    while True:
10418 
      (fname, ftype, fid) = iprot.readFieldBegin()
10419 
      if ftype == TType.STOP:
10420 
        break
10421 
      if fid == 1:
10422 
        if ftype == TType.I64:
10423 
          self.beginIndex = iprot.readI64();
10424 
        else:
10425 
          iprot.skip(ftype)
10426 
      elif fid == 2:
10427 
        if ftype == TType.I64:
10428 
          self.totalItems = iprot.readI64();
10429 
        else:
10430 
          iprot.skip(ftype)
10431 
      elif fid == 3:
10432 
        if ftype == TType.STRING:
10433 
          self.brand = iprot.readString();
10434 
        else:
10435 
          iprot.skip(ftype)
10436 
      elif fid == 4:
10437 
        if ftype == TType.I64:
10438 
          self.category = iprot.readI64();
10439 
        else:
10440 
          iprot.skip(ftype)
10441 
      else:
10442 
        iprot.skip(ftype)
10443 
      iprot.readFieldEnd()
10444 
    iprot.readStructEnd()
10445 
 
10446 
  def write(self, oprot):
10447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10449 
      return
10450 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10451 
    if self.beginIndex is not None:
10452 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10453 
      oprot.writeI64(self.beginIndex)
10454 
      oprot.writeFieldEnd()
10455 
    if self.totalItems is not None:
10456 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10457 
      oprot.writeI64(self.totalItems)
10458 
      oprot.writeFieldEnd()
10459 
    if self.brand is not None:
10460 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10461 
      oprot.writeString(self.brand)
10462 
      oprot.writeFieldEnd()
10463 
    if self.category is not None:
10464 
      oprot.writeFieldBegin('category', TType.I64, 4)
10465 
      oprot.writeI64(self.category)
10466 
      oprot.writeFieldEnd()
10467 
    oprot.writeFieldStop()
10468 
    oprot.writeStructEnd()
10469 
 
10470 
  def validate(self):
10471 
    return
10472 
 
10473 
 
10474 
  def __repr__(self):
10475 
    L = ['%s=%r' % (key, value)
10476 
      for key, value in self.__dict__.iteritems()]
10477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10478 
 
10479 
  def __eq__(self, other):
10480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10481 
 
10482 
  def __ne__(self, other):
10483 
    return not (self == other)
10484 
 
10485 
class getComingSoonCatalogIds_result:
10486 
  """
10487 
  Attributes:
10488 
   - success
10489 
   - cex
10490 
  """
10491 
 
10492 
  thrift_spec = (
10493 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10494 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10495 
  )
10496 
 
10497 
  def __init__(self, success=None, cex=None,):
10498 
    self.success = success
10499 
    self.cex = cex
10500 
 
10501 
  def read(self, iprot):
10502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10504 
      return
10505 
    iprot.readStructBegin()
10506 
    while True:
10507 
      (fname, ftype, fid) = iprot.readFieldBegin()
10508 
      if ftype == TType.STOP:
10509 
        break
10510 
      if fid == 0:
10511 
        if ftype == TType.LIST:
10512 
          self.success = []
8590 kshitij.so 10513 
          (_etype126, _size123) = iprot.readListBegin()
10514 
          for _i127 in xrange(_size123):
10515 
            _elem128 = iprot.readI64();
10516 
            self.success.append(_elem128)
5944 mandeep.dh 10517 
          iprot.readListEnd()
10518 
        else:
10519 
          iprot.skip(ftype)
10520 
      elif fid == 1:
10521 
        if ftype == TType.STRUCT:
10522 
          self.cex = CatalogServiceException()
10523 
          self.cex.read(iprot)
10524 
        else:
10525 
          iprot.skip(ftype)
10526 
      else:
10527 
        iprot.skip(ftype)
10528 
      iprot.readFieldEnd()
10529 
    iprot.readStructEnd()
10530 
 
10531 
  def write(self, oprot):
10532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10534 
      return
10535 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10536 
    if self.success is not None:
10537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10538 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10539 
      for iter129 in self.success:
10540 
        oprot.writeI64(iter129)
5944 mandeep.dh 10541 
      oprot.writeListEnd()
10542 
      oprot.writeFieldEnd()
10543 
    if self.cex is not None:
10544 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10545 
      self.cex.write(oprot)
10546 
      oprot.writeFieldEnd()
10547 
    oprot.writeFieldStop()
10548 
    oprot.writeStructEnd()
10549 
 
10550 
  def validate(self):
10551 
    return
10552 
 
10553 
 
10554 
  def __repr__(self):
10555 
    L = ['%s=%r' % (key, value)
10556 
      for key, value in self.__dict__.iteritems()]
10557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10558 
 
10559 
  def __eq__(self, other):
10560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10561 
 
10562 
  def __ne__(self, other):
10563 
    return not (self == other)
10564 
 
10565 
class getComingSoonCount_args:
10566 
 
10567 
  thrift_spec = (
10568 
  )
10569 
 
10570 
  def read(self, iprot):
10571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10573 
      return
10574 
    iprot.readStructBegin()
10575 
    while True:
10576 
      (fname, ftype, fid) = iprot.readFieldBegin()
10577 
      if ftype == TType.STOP:
10578 
        break
10579 
      else:
10580 
        iprot.skip(ftype)
10581 
      iprot.readFieldEnd()
10582 
    iprot.readStructEnd()
10583 
 
10584 
  def write(self, oprot):
10585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10587 
      return
10588 
    oprot.writeStructBegin('getComingSoonCount_args')
10589 
    oprot.writeFieldStop()
10590 
    oprot.writeStructEnd()
10591 
 
10592 
  def validate(self):
10593 
    return
10594 
 
10595 
 
10596 
  def __repr__(self):
10597 
    L = ['%s=%r' % (key, value)
10598 
      for key, value in self.__dict__.iteritems()]
10599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10600 
 
10601 
  def __eq__(self, other):
10602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10603 
 
10604 
  def __ne__(self, other):
10605 
    return not (self == other)
10606 
 
10607 
class getComingSoonCount_result:
10608 
  """
10609 
  Attributes:
10610 
   - success
10611 
   - cex
10612 
  """
10613 
 
10614 
  thrift_spec = (
10615 
    (0, TType.I64, 'success', None, None, ), # 0
10616 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10617 
  )
10618 
 
10619 
  def __init__(self, success=None, cex=None,):
10620 
    self.success = success
10621 
    self.cex = cex
10622 
 
10623 
  def read(self, iprot):
10624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10626 
      return
10627 
    iprot.readStructBegin()
10628 
    while True:
10629 
      (fname, ftype, fid) = iprot.readFieldBegin()
10630 
      if ftype == TType.STOP:
10631 
        break
10632 
      if fid == 0:
10633 
        if ftype == TType.I64:
10634 
          self.success = iprot.readI64();
10635 
        else:
10636 
          iprot.skip(ftype)
10637 
      elif fid == 1:
10638 
        if ftype == TType.STRUCT:
10639 
          self.cex = CatalogServiceException()
10640 
          self.cex.read(iprot)
10641 
        else:
10642 
          iprot.skip(ftype)
10643 
      else:
10644 
        iprot.skip(ftype)
10645 
      iprot.readFieldEnd()
10646 
    iprot.readStructEnd()
10647 
 
10648 
  def write(self, oprot):
10649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10651 
      return
10652 
    oprot.writeStructBegin('getComingSoonCount_result')
10653 
    if self.success is not None:
10654 
      oprot.writeFieldBegin('success', TType.I64, 0)
10655 
      oprot.writeI64(self.success)
10656 
      oprot.writeFieldEnd()
10657 
    if self.cex is not None:
10658 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10659 
      self.cex.write(oprot)
10660 
      oprot.writeFieldEnd()
10661 
    oprot.writeFieldStop()
10662 
    oprot.writeStructEnd()
10663 
 
10664 
  def validate(self):
10665 
    return
10666 
 
10667 
 
10668 
  def __repr__(self):
10669 
    L = ['%s=%r' % (key, value)
10670 
      for key, value in self.__dict__.iteritems()]
10671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10672 
 
10673 
  def __eq__(self, other):
10674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10675 
 
10676 
  def __ne__(self, other):
10677 
    return not (self == other)
10678 
 
10679 
class getLatestArrivals_args:
10680 
 
10681 
  thrift_spec = (
10682 
  )
10683 
 
10684 
  def read(self, iprot):
10685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10687 
      return
10688 
    iprot.readStructBegin()
10689 
    while True:
10690 
      (fname, ftype, fid) = iprot.readFieldBegin()
10691 
      if ftype == TType.STOP:
10692 
        break
10693 
      else:
10694 
        iprot.skip(ftype)
10695 
      iprot.readFieldEnd()
10696 
    iprot.readStructEnd()
10697 
 
10698 
  def write(self, oprot):
10699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10701 
      return
10702 
    oprot.writeStructBegin('getLatestArrivals_args')
10703 
    oprot.writeFieldStop()
10704 
    oprot.writeStructEnd()
10705 
 
10706 
  def validate(self):
10707 
    return
10708 
 
10709 
 
10710 
  def __repr__(self):
10711 
    L = ['%s=%r' % (key, value)
10712 
      for key, value in self.__dict__.iteritems()]
10713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10714 
 
10715 
  def __eq__(self, other):
10716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10717 
 
10718 
  def __ne__(self, other):
10719 
    return not (self == other)
10720 
 
10721 
class getLatestArrivals_result:
10722 
  """
10723 
  Attributes:
10724 
   - success
10725 
   - isex
10726 
  """
10727 
 
10728 
  thrift_spec = (
10729 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10730 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10731 
  )
10732 
 
10733 
  def __init__(self, success=None, isex=None,):
10734 
    self.success = success
10735 
    self.isex = isex
10736 
 
10737 
  def read(self, iprot):
10738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10740 
      return
10741 
    iprot.readStructBegin()
10742 
    while True:
10743 
      (fname, ftype, fid) = iprot.readFieldBegin()
10744 
      if ftype == TType.STOP:
10745 
        break
10746 
      if fid == 0:
10747 
        if ftype == TType.LIST:
10748 
          self.success = []
8590 kshitij.so 10749 
          (_etype133, _size130) = iprot.readListBegin()
10750 
          for _i134 in xrange(_size130):
10751 
            _elem135 = Item()
10752 
            _elem135.read(iprot)
10753 
            self.success.append(_elem135)
5944 mandeep.dh 10754 
          iprot.readListEnd()
10755 
        else:
10756 
          iprot.skip(ftype)
10757 
      elif fid == 1:
10758 
        if ftype == TType.STRUCT:
10759 
          self.isex = CatalogServiceException()
10760 
          self.isex.read(iprot)
10761 
        else:
10762 
          iprot.skip(ftype)
10763 
      else:
10764 
        iprot.skip(ftype)
10765 
      iprot.readFieldEnd()
10766 
    iprot.readStructEnd()
10767 
 
10768 
  def write(self, oprot):
10769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10771 
      return
10772 
    oprot.writeStructBegin('getLatestArrivals_result')
10773 
    if self.success is not None:
10774 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10775 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10776 
      for iter136 in self.success:
10777 
        iter136.write(oprot)
5944 mandeep.dh 10778 
      oprot.writeListEnd()
10779 
      oprot.writeFieldEnd()
10780 
    if self.isex is not None:
10781 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10782 
      self.isex.write(oprot)
10783 
      oprot.writeFieldEnd()
10784 
    oprot.writeFieldStop()
10785 
    oprot.writeStructEnd()
10786 
 
10787 
  def validate(self):
10788 
    return
10789 
 
10790 
 
10791 
  def __repr__(self):
10792 
    L = ['%s=%r' % (key, value)
10793 
      for key, value in self.__dict__.iteritems()]
10794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10795 
 
10796 
  def __eq__(self, other):
10797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10798 
 
10799 
  def __ne__(self, other):
10800 
    return not (self == other)
10801 
 
10802 
class getLatestArrivalsCatalogIds_args:
10803 
  """
10804 
  Attributes:
10805 
   - beginIndex
10806 
   - totalItems
10807 
   - brand
10808 
   - categories
10809 
  """
10810 
 
10811 
  thrift_spec = (
10812 
    None, # 0
10813 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10814 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10815 
    (3, TType.STRING, 'brand', None, None, ), # 3
10816 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
10817 
  )
10818 
 
10819 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
10820 
    self.beginIndex = beginIndex
10821 
    self.totalItems = totalItems
10822 
    self.brand = brand
10823 
    self.categories = categories
10824 
 
10825 
  def read(self, iprot):
10826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10828 
      return
10829 
    iprot.readStructBegin()
10830 
    while True:
10831 
      (fname, ftype, fid) = iprot.readFieldBegin()
10832 
      if ftype == TType.STOP:
10833 
        break
10834 
      if fid == 1:
10835 
        if ftype == TType.I64:
10836 
          self.beginIndex = iprot.readI64();
10837 
        else:
10838 
          iprot.skip(ftype)
10839 
      elif fid == 2:
10840 
        if ftype == TType.I64:
10841 
          self.totalItems = iprot.readI64();
10842 
        else:
10843 
          iprot.skip(ftype)
10844 
      elif fid == 3:
10845 
        if ftype == TType.STRING:
10846 
          self.brand = iprot.readString();
10847 
        else:
10848 
          iprot.skip(ftype)
10849 
      elif fid == 4:
10850 
        if ftype == TType.LIST:
10851 
          self.categories = []
8590 kshitij.so 10852 
          (_etype140, _size137) = iprot.readListBegin()
10853 
          for _i141 in xrange(_size137):
10854 
            _elem142 = iprot.readI64();
10855 
            self.categories.append(_elem142)
5944 mandeep.dh 10856 
          iprot.readListEnd()
10857 
        else:
10858 
          iprot.skip(ftype)
10859 
      else:
10860 
        iprot.skip(ftype)
10861 
      iprot.readFieldEnd()
10862 
    iprot.readStructEnd()
10863 
 
10864 
  def write(self, oprot):
10865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10867 
      return
10868 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
10869 
    if self.beginIndex is not None:
10870 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10871 
      oprot.writeI64(self.beginIndex)
10872 
      oprot.writeFieldEnd()
10873 
    if self.totalItems is not None:
10874 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10875 
      oprot.writeI64(self.totalItems)
10876 
      oprot.writeFieldEnd()
10877 
    if self.brand is not None:
10878 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10879 
      oprot.writeString(self.brand)
10880 
      oprot.writeFieldEnd()
10881 
    if self.categories is not None:
10882 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
10883 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 10884 
      for iter143 in self.categories:
10885 
        oprot.writeI64(iter143)
5944 mandeep.dh 10886 
      oprot.writeListEnd()
10887 
      oprot.writeFieldEnd()
10888 
    oprot.writeFieldStop()
10889 
    oprot.writeStructEnd()
10890 
 
10891 
  def validate(self):
10892 
    return
10893 
 
10894 
 
10895 
  def __repr__(self):
10896 
    L = ['%s=%r' % (key, value)
10897 
      for key, value in self.__dict__.iteritems()]
10898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10899 
 
10900 
  def __eq__(self, other):
10901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10902 
 
10903 
  def __ne__(self, other):
10904 
    return not (self == other)
10905 
 
10906 
class getLatestArrivalsCatalogIds_result:
10907 
  """
10908 
  Attributes:
10909 
   - success
10910 
   - cex
10911 
  """
10912 
 
10913 
  thrift_spec = (
10914 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10915 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10916 
  )
10917 
 
10918 
  def __init__(self, success=None, cex=None,):
10919 
    self.success = success
10920 
    self.cex = cex
10921 
 
10922 
  def read(self, iprot):
10923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10925 
      return
10926 
    iprot.readStructBegin()
10927 
    while True:
10928 
      (fname, ftype, fid) = iprot.readFieldBegin()
10929 
      if ftype == TType.STOP:
10930 
        break
10931 
      if fid == 0:
10932 
        if ftype == TType.LIST:
10933 
          self.success = []
8590 kshitij.so 10934 
          (_etype147, _size144) = iprot.readListBegin()
10935 
          for _i148 in xrange(_size144):
10936 
            _elem149 = iprot.readI64();
10937 
            self.success.append(_elem149)
5944 mandeep.dh 10938 
          iprot.readListEnd()
10939 
        else:
10940 
          iprot.skip(ftype)
10941 
      elif fid == 1:
10942 
        if ftype == TType.STRUCT:
10943 
          self.cex = CatalogServiceException()
10944 
          self.cex.read(iprot)
10945 
        else:
10946 
          iprot.skip(ftype)
10947 
      else:
10948 
        iprot.skip(ftype)
10949 
      iprot.readFieldEnd()
10950 
    iprot.readStructEnd()
10951 
 
10952 
  def write(self, oprot):
10953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10955 
      return
10956 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
10957 
    if self.success is not None:
10958 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10959 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10960 
      for iter150 in self.success:
10961 
        oprot.writeI64(iter150)
5944 mandeep.dh 10962 
      oprot.writeListEnd()
10963 
      oprot.writeFieldEnd()
10964 
    if self.cex is not None:
10965 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10966 
      self.cex.write(oprot)
10967 
      oprot.writeFieldEnd()
10968 
    oprot.writeFieldStop()
10969 
    oprot.writeStructEnd()
10970 
 
10971 
  def validate(self):
10972 
    return
10973 
 
10974 
 
10975 
  def __repr__(self):
10976 
    L = ['%s=%r' % (key, value)
10977 
      for key, value in self.__dict__.iteritems()]
10978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10979 
 
10980 
  def __eq__(self, other):
10981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10982 
 
10983 
  def __ne__(self, other):
10984 
    return not (self == other)
10985 
 
10986 
class getLatestArrivalsCount_args:
10987 
 
10988 
  thrift_spec = (
10989 
  )
10990 
 
10991 
  def read(self, iprot):
10992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10994 
      return
10995 
    iprot.readStructBegin()
10996 
    while True:
10997 
      (fname, ftype, fid) = iprot.readFieldBegin()
10998 
      if ftype == TType.STOP:
10999 
        break
11000 
      else:
11001 
        iprot.skip(ftype)
11002 
      iprot.readFieldEnd()
11003 
    iprot.readStructEnd()
11004 
 
11005 
  def write(self, oprot):
11006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11008 
      return
11009 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
11010 
    oprot.writeFieldStop()
11011 
    oprot.writeStructEnd()
11012 
 
11013 
  def validate(self):
11014 
    return
11015 
 
11016 
 
11017 
  def __repr__(self):
11018 
    L = ['%s=%r' % (key, value)
11019 
      for key, value in self.__dict__.iteritems()]
11020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11021 
 
11022 
  def __eq__(self, other):
11023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11024 
 
11025 
  def __ne__(self, other):
11026 
    return not (self == other)
11027 
 
11028 
class getLatestArrivalsCount_result:
11029 
  """
11030 
  Attributes:
11031 
   - success
11032 
   - cex
11033 
  """
11034 
 
11035 
  thrift_spec = (
11036 
    (0, TType.I64, 'success', None, None, ), # 0
11037 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11038 
  )
11039 
 
11040 
  def __init__(self, success=None, cex=None,):
11041 
    self.success = success
11042 
    self.cex = cex
11043 
 
11044 
  def read(self, iprot):
11045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11047 
      return
11048 
    iprot.readStructBegin()
11049 
    while True:
11050 
      (fname, ftype, fid) = iprot.readFieldBegin()
11051 
      if ftype == TType.STOP:
11052 
        break
11053 
      if fid == 0:
11054 
        if ftype == TType.I64:
11055 
          self.success = iprot.readI64();
11056 
        else:
11057 
          iprot.skip(ftype)
11058 
      elif fid == 1:
11059 
        if ftype == TType.STRUCT:
11060 
          self.cex = CatalogServiceException()
11061 
          self.cex.read(iprot)
11062 
        else:
11063 
          iprot.skip(ftype)
11064 
      else:
11065 
        iprot.skip(ftype)
11066 
      iprot.readFieldEnd()
11067 
    iprot.readStructEnd()
11068 
 
11069 
  def write(self, oprot):
11070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11072 
      return
11073 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
11074 
    if self.success is not None:
11075 
      oprot.writeFieldBegin('success', TType.I64, 0)
11076 
      oprot.writeI64(self.success)
11077 
      oprot.writeFieldEnd()
11078 
    if self.cex is not None:
11079 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11080 
      self.cex.write(oprot)
11081 
      oprot.writeFieldEnd()
11082 
    oprot.writeFieldStop()
11083 
    oprot.writeStructEnd()
11084 
 
11085 
  def validate(self):
11086 
    return
11087 
 
11088 
 
11089 
  def __repr__(self):
11090 
    L = ['%s=%r' % (key, value)
11091 
      for key, value in self.__dict__.iteritems()]
11092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11093 
 
11094 
  def __eq__(self, other):
11095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11096 
 
11097 
  def __ne__(self, other):
11098 
    return not (self == other)
11099 
 
11100 
class generateNewEntityID_args:
11101 
 
11102 
  thrift_spec = (
11103 
  )
11104 
 
11105 
  def read(self, iprot):
11106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11108 
      return
11109 
    iprot.readStructBegin()
11110 
    while True:
11111 
      (fname, ftype, fid) = iprot.readFieldBegin()
11112 
      if ftype == TType.STOP:
11113 
        break
11114 
      else:
11115 
        iprot.skip(ftype)
11116 
      iprot.readFieldEnd()
11117 
    iprot.readStructEnd()
11118 
 
11119 
  def write(self, oprot):
11120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11122 
      return
11123 
    oprot.writeStructBegin('generateNewEntityID_args')
11124 
    oprot.writeFieldStop()
11125 
    oprot.writeStructEnd()
11126 
 
11127 
  def validate(self):
11128 
    return
11129 
 
11130 
 
11131 
  def __repr__(self):
11132 
    L = ['%s=%r' % (key, value)
11133 
      for key, value in self.__dict__.iteritems()]
11134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11135 
 
11136 
  def __eq__(self, other):
11137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11138 
 
11139 
  def __ne__(self, other):
11140 
    return not (self == other)
11141 
 
11142 
class generateNewEntityID_result:
11143 
  """
11144 
  Attributes:
11145 
   - success
11146 
  """
11147 
 
11148 
  thrift_spec = (
11149 
    (0, TType.I64, 'success', None, None, ), # 0
11150 
  )
11151 
 
11152 
  def __init__(self, success=None,):
11153 
    self.success = success
11154 
 
11155 
  def read(self, iprot):
11156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11158 
      return
11159 
    iprot.readStructBegin()
11160 
    while True:
11161 
      (fname, ftype, fid) = iprot.readFieldBegin()
11162 
      if ftype == TType.STOP:
11163 
        break
11164 
      if fid == 0:
11165 
        if ftype == TType.I64:
11166 
          self.success = iprot.readI64();
11167 
        else:
11168 
          iprot.skip(ftype)
11169 
      else:
11170 
        iprot.skip(ftype)
11171 
      iprot.readFieldEnd()
11172 
    iprot.readStructEnd()
11173 
 
11174 
  def write(self, oprot):
11175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11177 
      return
11178 
    oprot.writeStructBegin('generateNewEntityID_result')
11179 
    if self.success is not None:
11180 
      oprot.writeFieldBegin('success', TType.I64, 0)
11181 
      oprot.writeI64(self.success)
11182 
      oprot.writeFieldEnd()
11183 
    oprot.writeFieldStop()
11184 
    oprot.writeStructEnd()
11185 
 
11186 
  def validate(self):
11187 
    return
11188 
 
11189 
 
11190 
  def __repr__(self):
11191 
    L = ['%s=%r' % (key, value)
11192 
      for key, value in self.__dict__.iteritems()]
11193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11194 
 
11195 
  def __eq__(self, other):
11196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11197 
 
11198 
  def __ne__(self, other):
11199 
    return not (self == other)
11200 
 
11201 
class addCategory_args:
11202 
  """
11203 
  Attributes:
11204 
   - category
11205 
  """
11206 
 
11207 
  thrift_spec = (
11208 
    None, # 0
11209 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
11210 
  )
11211 
 
11212 
  def __init__(self, category=None,):
11213 
    self.category = category
11214 
 
11215 
  def read(self, iprot):
11216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11218 
      return
11219 
    iprot.readStructBegin()
11220 
    while True:
11221 
      (fname, ftype, fid) = iprot.readFieldBegin()
11222 
      if ftype == TType.STOP:
11223 
        break
11224 
      if fid == 1:
11225 
        if ftype == TType.STRUCT:
11226 
          self.category = Category()
11227 
          self.category.read(iprot)
11228 
        else:
11229 
          iprot.skip(ftype)
11230 
      else:
11231 
        iprot.skip(ftype)
11232 
      iprot.readFieldEnd()
11233 
    iprot.readStructEnd()
11234 
 
11235 
  def write(self, oprot):
11236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11238 
      return
11239 
    oprot.writeStructBegin('addCategory_args')
11240 
    if self.category is not None:
11241 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
11242 
      self.category.write(oprot)
11243 
      oprot.writeFieldEnd()
11244 
    oprot.writeFieldStop()
11245 
    oprot.writeStructEnd()
11246 
 
11247 
  def validate(self):
11248 
    return
11249 
 
11250 
 
11251 
  def __repr__(self):
11252 
    L = ['%s=%r' % (key, value)
11253 
      for key, value in self.__dict__.iteritems()]
11254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11255 
 
11256 
  def __eq__(self, other):
11257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11258 
 
11259 
  def __ne__(self, other):
11260 
    return not (self == other)
11261 
 
11262 
class addCategory_result:
11263 
  """
11264 
  Attributes:
11265 
   - success
11266 
  """
11267 
 
11268 
  thrift_spec = (
11269 
    (0, TType.BOOL, 'success', None, None, ), # 0
11270 
  )
11271 
 
11272 
  def __init__(self, success=None,):
11273 
    self.success = success
11274 
 
11275 
  def read(self, iprot):
11276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11278 
      return
11279 
    iprot.readStructBegin()
11280 
    while True:
11281 
      (fname, ftype, fid) = iprot.readFieldBegin()
11282 
      if ftype == TType.STOP:
11283 
        break
11284 
      if fid == 0:
11285 
        if ftype == TType.BOOL:
11286 
          self.success = iprot.readBool();
11287 
        else:
11288 
          iprot.skip(ftype)
11289 
      else:
11290 
        iprot.skip(ftype)
11291 
      iprot.readFieldEnd()
11292 
    iprot.readStructEnd()
11293 
 
11294 
  def write(self, oprot):
11295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11297 
      return
11298 
    oprot.writeStructBegin('addCategory_result')
11299 
    if self.success is not None:
11300 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11301 
      oprot.writeBool(self.success)
11302 
      oprot.writeFieldEnd()
11303 
    oprot.writeFieldStop()
11304 
    oprot.writeStructEnd()
11305 
 
11306 
  def validate(self):
11307 
    return
11308 
 
11309 
 
11310 
  def __repr__(self):
11311 
    L = ['%s=%r' % (key, value)
11312 
      for key, value in self.__dict__.iteritems()]
11313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11314 
 
11315 
  def __eq__(self, other):
11316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11317 
 
11318 
  def __ne__(self, other):
11319 
    return not (self == other)
11320 
 
11321 
class getCategory_args:
11322 
  """
11323 
  Attributes:
11324 
   - id
11325 
  """
11326 
 
11327 
  thrift_spec = (
11328 
    None, # 0
11329 
    (1, TType.I64, 'id', None, None, ), # 1
11330 
  )
11331 
 
11332 
  def __init__(self, id=None,):
11333 
    self.id = id
11334 
 
11335 
  def read(self, iprot):
11336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11338 
      return
11339 
    iprot.readStructBegin()
11340 
    while True:
11341 
      (fname, ftype, fid) = iprot.readFieldBegin()
11342 
      if ftype == TType.STOP:
11343 
        break
11344 
      if fid == 1:
11345 
        if ftype == TType.I64:
11346 
          self.id = iprot.readI64();
11347 
        else:
11348 
          iprot.skip(ftype)
11349 
      else:
11350 
        iprot.skip(ftype)
11351 
      iprot.readFieldEnd()
11352 
    iprot.readStructEnd()
11353 
 
11354 
  def write(self, oprot):
11355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11357 
      return
11358 
    oprot.writeStructBegin('getCategory_args')
11359 
    if self.id is not None:
11360 
      oprot.writeFieldBegin('id', TType.I64, 1)
11361 
      oprot.writeI64(self.id)
11362 
      oprot.writeFieldEnd()
11363 
    oprot.writeFieldStop()
11364 
    oprot.writeStructEnd()
11365 
 
11366 
  def validate(self):
11367 
    return
11368 
 
11369 
 
11370 
  def __repr__(self):
11371 
    L = ['%s=%r' % (key, value)
11372 
      for key, value in self.__dict__.iteritems()]
11373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11374 
 
11375 
  def __eq__(self, other):
11376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11377 
 
11378 
  def __ne__(self, other):
11379 
    return not (self == other)
11380 
 
11381 
class getCategory_result:
11382 
  """
11383 
  Attributes:
11384 
   - success
11385 
  """
11386 
 
11387 
  thrift_spec = (
11388 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11389 
  )
11390 
 
11391 
  def __init__(self, success=None,):
11392 
    self.success = success
11393 
 
11394 
  def read(self, iprot):
11395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11397 
      return
11398 
    iprot.readStructBegin()
11399 
    while True:
11400 
      (fname, ftype, fid) = iprot.readFieldBegin()
11401 
      if ftype == TType.STOP:
11402 
        break
11403 
      if fid == 0:
11404 
        if ftype == TType.STRUCT:
11405 
          self.success = Category()
11406 
          self.success.read(iprot)
11407 
        else:
11408 
          iprot.skip(ftype)
11409 
      else:
11410 
        iprot.skip(ftype)
11411 
      iprot.readFieldEnd()
11412 
    iprot.readStructEnd()
11413 
 
11414 
  def write(self, oprot):
11415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11417 
      return
11418 
    oprot.writeStructBegin('getCategory_result')
11419 
    if self.success is not None:
11420 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11421 
      self.success.write(oprot)
11422 
      oprot.writeFieldEnd()
11423 
    oprot.writeFieldStop()
11424 
    oprot.writeStructEnd()
11425 
 
11426 
  def validate(self):
11427 
    return
11428 
 
11429 
 
11430 
  def __repr__(self):
11431 
    L = ['%s=%r' % (key, value)
11432 
      for key, value in self.__dict__.iteritems()]
11433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11434 
 
11435 
  def __eq__(self, other):
11436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11437 
 
11438 
  def __ne__(self, other):
11439 
    return not (self == other)
11440 
 
11441 
class getAllCategories_args:
11442 
 
11443 
  thrift_spec = (
11444 
  )
11445 
 
11446 
  def read(self, iprot):
11447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11449 
      return
11450 
    iprot.readStructBegin()
11451 
    while True:
11452 
      (fname, ftype, fid) = iprot.readFieldBegin()
11453 
      if ftype == TType.STOP:
11454 
        break
11455 
      else:
11456 
        iprot.skip(ftype)
11457 
      iprot.readFieldEnd()
11458 
    iprot.readStructEnd()
11459 
 
11460 
  def write(self, oprot):
11461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11463 
      return
11464 
    oprot.writeStructBegin('getAllCategories_args')
11465 
    oprot.writeFieldStop()
11466 
    oprot.writeStructEnd()
11467 
 
11468 
  def validate(self):
11469 
    return
11470 
 
11471 
 
11472 
  def __repr__(self):
11473 
    L = ['%s=%r' % (key, value)
11474 
      for key, value in self.__dict__.iteritems()]
11475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11476 
 
11477 
  def __eq__(self, other):
11478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11479 
 
11480 
  def __ne__(self, other):
11481 
    return not (self == other)
11482 
 
11483 
class getAllCategories_result:
11484 
  """
11485 
  Attributes:
11486 
   - success
11487 
  """
11488 
 
11489 
  thrift_spec = (
11490 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11491 
  )
11492 
 
11493 
  def __init__(self, success=None,):
11494 
    self.success = success
11495 
 
11496 
  def read(self, iprot):
11497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11499 
      return
11500 
    iprot.readStructBegin()
11501 
    while True:
11502 
      (fname, ftype, fid) = iprot.readFieldBegin()
11503 
      if ftype == TType.STOP:
11504 
        break
11505 
      if fid == 0:
11506 
        if ftype == TType.LIST:
11507 
          self.success = []
8590 kshitij.so 11508 
          (_etype154, _size151) = iprot.readListBegin()
11509 
          for _i155 in xrange(_size151):
11510 
            _elem156 = Category()
11511 
            _elem156.read(iprot)
11512 
            self.success.append(_elem156)
5944 mandeep.dh 11513 
          iprot.readListEnd()
11514 
        else:
11515 
          iprot.skip(ftype)
11516 
      else:
11517 
        iprot.skip(ftype)
11518 
      iprot.readFieldEnd()
11519 
    iprot.readStructEnd()
11520 
 
11521 
  def write(self, oprot):
11522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11524 
      return
11525 
    oprot.writeStructBegin('getAllCategories_result')
11526 
    if self.success is not None:
11527 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11528 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11529 
      for iter157 in self.success:
11530 
        iter157.write(oprot)
5944 mandeep.dh 11531 
      oprot.writeListEnd()
11532 
      oprot.writeFieldEnd()
11533 
    oprot.writeFieldStop()
11534 
    oprot.writeStructEnd()
11535 
 
11536 
  def validate(self):
11537 
    return
11538 
 
11539 
 
11540 
  def __repr__(self):
11541 
    L = ['%s=%r' % (key, value)
11542 
      for key, value in self.__dict__.iteritems()]
11543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11544 
 
11545 
  def __eq__(self, other):
11546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11547 
 
11548 
  def __ne__(self, other):
11549 
    return not (self == other)
11550 
 
11551 
class getAllSimilarItems_args:
11552 
  """
11553 
  Attributes:
11554 
   - itemId
11555 
  """
11556 
 
11557 
  thrift_spec = (
11558 
    None, # 0
11559 
    (1, TType.I64, 'itemId', None, None, ), # 1
11560 
  )
11561 
 
11562 
  def __init__(self, itemId=None,):
11563 
    self.itemId = itemId
11564 
 
11565 
  def read(self, iprot):
11566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11568 
      return
11569 
    iprot.readStructBegin()
11570 
    while True:
11571 
      (fname, ftype, fid) = iprot.readFieldBegin()
11572 
      if ftype == TType.STOP:
11573 
        break
11574 
      if fid == 1:
11575 
        if ftype == TType.I64:
11576 
          self.itemId = iprot.readI64();
11577 
        else:
11578 
          iprot.skip(ftype)
11579 
      else:
11580 
        iprot.skip(ftype)
11581 
      iprot.readFieldEnd()
11582 
    iprot.readStructEnd()
11583 
 
11584 
  def write(self, oprot):
11585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11587 
      return
11588 
    oprot.writeStructBegin('getAllSimilarItems_args')
11589 
    if self.itemId is not None:
11590 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11591 
      oprot.writeI64(self.itemId)
11592 
      oprot.writeFieldEnd()
11593 
    oprot.writeFieldStop()
11594 
    oprot.writeStructEnd()
11595 
 
11596 
  def validate(self):
11597 
    return
11598 
 
11599 
 
11600 
  def __repr__(self):
11601 
    L = ['%s=%r' % (key, value)
11602 
      for key, value in self.__dict__.iteritems()]
11603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11604 
 
11605 
  def __eq__(self, other):
11606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11607 
 
11608 
  def __ne__(self, other):
11609 
    return not (self == other)
11610 
 
11611 
class getAllSimilarItems_result:
11612 
  """
11613 
  Attributes:
11614 
   - success
11615 
  """
11616 
 
11617 
  thrift_spec = (
11618 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11619 
  )
11620 
 
11621 
  def __init__(self, success=None,):
11622 
    self.success = success
11623 
 
11624 
  def read(self, iprot):
11625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11627 
      return
11628 
    iprot.readStructBegin()
11629 
    while True:
11630 
      (fname, ftype, fid) = iprot.readFieldBegin()
11631 
      if ftype == TType.STOP:
11632 
        break
11633 
      if fid == 0:
11634 
        if ftype == TType.LIST:
11635 
          self.success = []
8590 kshitij.so 11636 
          (_etype161, _size158) = iprot.readListBegin()
11637 
          for _i162 in xrange(_size158):
11638 
            _elem163 = Item()
11639 
            _elem163.read(iprot)
11640 
            self.success.append(_elem163)
5944 mandeep.dh 11641 
          iprot.readListEnd()
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('getAllSimilarItems_result')
11654 
    if self.success is not None:
11655 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11656 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11657 
      for iter164 in self.success:
11658 
        iter164.write(oprot)
5944 mandeep.dh 11659 
      oprot.writeListEnd()
11660 
      oprot.writeFieldEnd()
11661 
    oprot.writeFieldStop()
11662 
    oprot.writeStructEnd()
11663 
 
11664 
  def validate(self):
11665 
    return
11666 
 
11667 
 
11668 
  def __repr__(self):
11669 
    L = ['%s=%r' % (key, value)
11670 
      for key, value in self.__dict__.iteritems()]
11671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11672 
 
11673 
  def __eq__(self, other):
11674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11675 
 
11676 
  def __ne__(self, other):
11677 
    return not (self == other)
11678 
 
11679 
class addSimilarItem_args:
11680 
  """
11681 
  Attributes:
11682 
   - itemId
11683 
   - catalogItemId
11684 
  """
11685 
 
11686 
  thrift_spec = (
11687 
    None, # 0
11688 
    (1, TType.I64, 'itemId', None, None, ), # 1
11689 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11690 
  )
11691 
 
11692 
  def __init__(self, itemId=None, catalogItemId=None,):
11693 
    self.itemId = itemId
11694 
    self.catalogItemId = catalogItemId
11695 
 
11696 
  def read(self, iprot):
11697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11699 
      return
11700 
    iprot.readStructBegin()
11701 
    while True:
11702 
      (fname, ftype, fid) = iprot.readFieldBegin()
11703 
      if ftype == TType.STOP:
11704 
        break
11705 
      if fid == 1:
11706 
        if ftype == TType.I64:
11707 
          self.itemId = iprot.readI64();
11708 
        else:
11709 
          iprot.skip(ftype)
11710 
      elif fid == 2:
11711 
        if ftype == TType.I64:
11712 
          self.catalogItemId = iprot.readI64();
11713 
        else:
11714 
          iprot.skip(ftype)
11715 
      else:
11716 
        iprot.skip(ftype)
11717 
      iprot.readFieldEnd()
11718 
    iprot.readStructEnd()
11719 
 
11720 
  def write(self, oprot):
11721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11723 
      return
11724 
    oprot.writeStructBegin('addSimilarItem_args')
11725 
    if self.itemId is not None:
11726 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11727 
      oprot.writeI64(self.itemId)
11728 
      oprot.writeFieldEnd()
11729 
    if self.catalogItemId is not None:
11730 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11731 
      oprot.writeI64(self.catalogItemId)
11732 
      oprot.writeFieldEnd()
11733 
    oprot.writeFieldStop()
11734 
    oprot.writeStructEnd()
11735 
 
11736 
  def validate(self):
11737 
    return
11738 
 
11739 
 
11740 
  def __repr__(self):
11741 
    L = ['%s=%r' % (key, value)
11742 
      for key, value in self.__dict__.iteritems()]
11743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11744 
 
11745 
  def __eq__(self, other):
11746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11747 
 
11748 
  def __ne__(self, other):
11749 
    return not (self == other)
11750 
 
11751 
class addSimilarItem_result:
11752 
  """
11753 
  Attributes:
11754 
   - success
11755 
   - cex
11756 
  """
11757 
 
11758 
  thrift_spec = (
11759 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11760 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11761 
  )
11762 
 
11763 
  def __init__(self, success=None, cex=None,):
11764 
    self.success = success
11765 
    self.cex = cex
11766 
 
11767 
  def read(self, iprot):
11768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11770 
      return
11771 
    iprot.readStructBegin()
11772 
    while True:
11773 
      (fname, ftype, fid) = iprot.readFieldBegin()
11774 
      if ftype == TType.STOP:
11775 
        break
11776 
      if fid == 0:
11777 
        if ftype == TType.STRUCT:
11778 
          self.success = Item()
11779 
          self.success.read(iprot)
11780 
        else:
11781 
          iprot.skip(ftype)
11782 
      elif fid == 1:
11783 
        if ftype == TType.STRUCT:
11784 
          self.cex = CatalogServiceException()
11785 
          self.cex.read(iprot)
11786 
        else:
11787 
          iprot.skip(ftype)
11788 
      else:
11789 
        iprot.skip(ftype)
11790 
      iprot.readFieldEnd()
11791 
    iprot.readStructEnd()
11792 
 
11793 
  def write(self, oprot):
11794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11796 
      return
11797 
    oprot.writeStructBegin('addSimilarItem_result')
11798 
    if self.success is not None:
11799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11800 
      self.success.write(oprot)
11801 
      oprot.writeFieldEnd()
11802 
    if self.cex is not None:
11803 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11804 
      self.cex.write(oprot)
11805 
      oprot.writeFieldEnd()
11806 
    oprot.writeFieldStop()
11807 
    oprot.writeStructEnd()
11808 
 
11809 
  def validate(self):
11810 
    return
11811 
 
11812 
 
11813 
  def __repr__(self):
11814 
    L = ['%s=%r' % (key, value)
11815 
      for key, value in self.__dict__.iteritems()]
11816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11817 
 
11818 
  def __eq__(self, other):
11819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11820 
 
11821 
  def __ne__(self, other):
11822 
    return not (self == other)
11823 
 
6512 kshitij.so 11824 
class addTag_args:
11825 
  """
11826 
  Attributes:
11827 
   - displayName
11828 
   - itemId
11829 
  """
11830 
 
11831 
  thrift_spec = (
11832 
    None, # 0
11833 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11834 
    (2, TType.I64, 'itemId', None, None, ), # 2
11835 
  )
11836 
 
11837 
  def __init__(self, displayName=None, itemId=None,):
11838 
    self.displayName = displayName
11839 
    self.itemId = itemId
11840 
 
11841 
  def read(self, iprot):
11842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11844 
      return
11845 
    iprot.readStructBegin()
11846 
    while True:
11847 
      (fname, ftype, fid) = iprot.readFieldBegin()
11848 
      if ftype == TType.STOP:
11849 
        break
11850 
      if fid == 1:
11851 
        if ftype == TType.STRING:
11852 
          self.displayName = iprot.readString();
11853 
        else:
11854 
          iprot.skip(ftype)
11855 
      elif fid == 2:
11856 
        if ftype == TType.I64:
11857 
          self.itemId = iprot.readI64();
11858 
        else:
11859 
          iprot.skip(ftype)
11860 
      else:
11861 
        iprot.skip(ftype)
11862 
      iprot.readFieldEnd()
11863 
    iprot.readStructEnd()
11864 
 
11865 
  def write(self, oprot):
11866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11868 
      return
11869 
    oprot.writeStructBegin('addTag_args')
11870 
    if self.displayName is not None:
11871 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11872 
      oprot.writeString(self.displayName)
11873 
      oprot.writeFieldEnd()
11874 
    if self.itemId is not None:
11875 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11876 
      oprot.writeI64(self.itemId)
11877 
      oprot.writeFieldEnd()
11878 
    oprot.writeFieldStop()
11879 
    oprot.writeStructEnd()
11880 
 
11881 
  def validate(self):
11882 
    return
11883 
 
11884 
 
11885 
  def __repr__(self):
11886 
    L = ['%s=%r' % (key, value)
11887 
      for key, value in self.__dict__.iteritems()]
11888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11889 
 
11890 
  def __eq__(self, other):
11891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11892 
 
11893 
  def __ne__(self, other):
11894 
    return not (self == other)
11895 
 
11896 
class addTag_result:
11897 
  """
11898 
  Attributes:
11899 
   - success
11900 
  """
11901 
 
11902 
  thrift_spec = (
11903 
    (0, TType.BOOL, 'success', None, None, ), # 0
11904 
  )
11905 
 
11906 
  def __init__(self, success=None,):
11907 
    self.success = success
11908 
 
11909 
  def read(self, iprot):
11910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11912 
      return
11913 
    iprot.readStructBegin()
11914 
    while True:
11915 
      (fname, ftype, fid) = iprot.readFieldBegin()
11916 
      if ftype == TType.STOP:
11917 
        break
11918 
      if fid == 0:
11919 
        if ftype == TType.BOOL:
11920 
          self.success = iprot.readBool();
11921 
        else:
11922 
          iprot.skip(ftype)
11923 
      else:
11924 
        iprot.skip(ftype)
11925 
      iprot.readFieldEnd()
11926 
    iprot.readStructEnd()
11927 
 
11928 
  def write(self, oprot):
11929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11931 
      return
11932 
    oprot.writeStructBegin('addTag_result')
11933 
    if self.success is not None:
11934 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11935 
      oprot.writeBool(self.success)
11936 
      oprot.writeFieldEnd()
11937 
    oprot.writeFieldStop()
11938 
    oprot.writeStructEnd()
11939 
 
11940 
  def validate(self):
11941 
    return
11942 
 
11943 
 
11944 
  def __repr__(self):
11945 
    L = ['%s=%r' % (key, value)
11946 
      for key, value in self.__dict__.iteritems()]
11947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11948 
 
11949 
  def __eq__(self, other):
11950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11951 
 
11952 
  def __ne__(self, other):
11953 
    return not (self == other)
11954 
 
11955 
class deleteEntityTag_args:
11956 
  """
11957 
  Attributes:
11958 
   - displayName
11959 
   - itemId
11960 
  """
11961 
 
11962 
  thrift_spec = (
11963 
    None, # 0
11964 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11965 
    (2, TType.I64, 'itemId', None, None, ), # 2
11966 
  )
11967 
 
11968 
  def __init__(self, displayName=None, itemId=None,):
11969 
    self.displayName = displayName
11970 
    self.itemId = itemId
11971 
 
11972 
  def read(self, iprot):
11973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11975 
      return
11976 
    iprot.readStructBegin()
11977 
    while True:
11978 
      (fname, ftype, fid) = iprot.readFieldBegin()
11979 
      if ftype == TType.STOP:
11980 
        break
11981 
      if fid == 1:
11982 
        if ftype == TType.STRING:
11983 
          self.displayName = iprot.readString();
11984 
        else:
11985 
          iprot.skip(ftype)
11986 
      elif fid == 2:
11987 
        if ftype == TType.I64:
11988 
          self.itemId = iprot.readI64();
11989 
        else:
11990 
          iprot.skip(ftype)
11991 
      else:
11992 
        iprot.skip(ftype)
11993 
      iprot.readFieldEnd()
11994 
    iprot.readStructEnd()
11995 
 
11996 
  def write(self, oprot):
11997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11999 
      return
12000 
    oprot.writeStructBegin('deleteEntityTag_args')
12001 
    if self.displayName is not None:
12002 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12003 
      oprot.writeString(self.displayName)
12004 
      oprot.writeFieldEnd()
12005 
    if self.itemId is not None:
12006 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12007 
      oprot.writeI64(self.itemId)
12008 
      oprot.writeFieldEnd()
12009 
    oprot.writeFieldStop()
12010 
    oprot.writeStructEnd()
12011 
 
12012 
  def validate(self):
12013 
    return
12014 
 
12015 
 
12016 
  def __repr__(self):
12017 
    L = ['%s=%r' % (key, value)
12018 
      for key, value in self.__dict__.iteritems()]
12019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12020 
 
12021 
  def __eq__(self, other):
12022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12023 
 
12024 
  def __ne__(self, other):
12025 
    return not (self == other)
12026 
 
12027 
class deleteEntityTag_result:
12028 
  """
12029 
  Attributes:
12030 
   - success
12031 
  """
12032 
 
12033 
  thrift_spec = (
12034 
    (0, TType.BOOL, 'success', None, None, ), # 0
12035 
  )
12036 
 
12037 
  def __init__(self, success=None,):
12038 
    self.success = success
12039 
 
12040 
  def read(self, iprot):
12041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12043 
      return
12044 
    iprot.readStructBegin()
12045 
    while True:
12046 
      (fname, ftype, fid) = iprot.readFieldBegin()
12047 
      if ftype == TType.STOP:
12048 
        break
12049 
      if fid == 0:
12050 
        if ftype == TType.BOOL:
12051 
          self.success = iprot.readBool();
12052 
        else:
12053 
          iprot.skip(ftype)
12054 
      else:
12055 
        iprot.skip(ftype)
12056 
      iprot.readFieldEnd()
12057 
    iprot.readStructEnd()
12058 
 
12059 
  def write(self, oprot):
12060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12062 
      return
12063 
    oprot.writeStructBegin('deleteEntityTag_result')
12064 
    if self.success is not None:
12065 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12066 
      oprot.writeBool(self.success)
12067 
      oprot.writeFieldEnd()
12068 
    oprot.writeFieldStop()
12069 
    oprot.writeStructEnd()
12070 
 
12071 
  def validate(self):
12072 
    return
12073 
 
12074 
 
12075 
  def __repr__(self):
12076 
    L = ['%s=%r' % (key, value)
12077 
      for key, value in self.__dict__.iteritems()]
12078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12079 
 
12080 
  def __eq__(self, other):
12081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12082 
 
12083 
  def __ne__(self, other):
12084 
    return not (self == other)
12085 
 
12086 
class deleteTag_args:
12087 
  """
12088 
  Attributes:
12089 
   - displayName
12090 
  """
12091 
 
12092 
  thrift_spec = (
12093 
    None, # 0
12094 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12095 
  )
12096 
 
12097 
  def __init__(self, displayName=None,):
12098 
    self.displayName = displayName
12099 
 
12100 
  def read(self, iprot):
12101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12103 
      return
12104 
    iprot.readStructBegin()
12105 
    while True:
12106 
      (fname, ftype, fid) = iprot.readFieldBegin()
12107 
      if ftype == TType.STOP:
12108 
        break
12109 
      if fid == 1:
12110 
        if ftype == TType.STRING:
12111 
          self.displayName = iprot.readString();
12112 
        else:
12113 
          iprot.skip(ftype)
12114 
      else:
12115 
        iprot.skip(ftype)
12116 
      iprot.readFieldEnd()
12117 
    iprot.readStructEnd()
12118 
 
12119 
  def write(self, oprot):
12120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12122 
      return
12123 
    oprot.writeStructBegin('deleteTag_args')
12124 
    if self.displayName is not None:
12125 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12126 
      oprot.writeString(self.displayName)
12127 
      oprot.writeFieldEnd()
12128 
    oprot.writeFieldStop()
12129 
    oprot.writeStructEnd()
12130 
 
12131 
  def validate(self):
12132 
    return
12133 
 
12134 
 
12135 
  def __repr__(self):
12136 
    L = ['%s=%r' % (key, value)
12137 
      for key, value in self.__dict__.iteritems()]
12138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12139 
 
12140 
  def __eq__(self, other):
12141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12142 
 
12143 
  def __ne__(self, other):
12144 
    return not (self == other)
12145 
 
12146 
class deleteTag_result:
12147 
  """
12148 
  Attributes:
12149 
   - success
12150 
  """
12151 
 
12152 
  thrift_spec = (
12153 
    (0, TType.BOOL, 'success', None, None, ), # 0
12154 
  )
12155 
 
12156 
  def __init__(self, success=None,):
12157 
    self.success = success
12158 
 
12159 
  def read(self, iprot):
12160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12162 
      return
12163 
    iprot.readStructBegin()
12164 
    while True:
12165 
      (fname, ftype, fid) = iprot.readFieldBegin()
12166 
      if ftype == TType.STOP:
12167 
        break
12168 
      if fid == 0:
12169 
        if ftype == TType.BOOL:
12170 
          self.success = iprot.readBool();
12171 
        else:
12172 
          iprot.skip(ftype)
12173 
      else:
12174 
        iprot.skip(ftype)
12175 
      iprot.readFieldEnd()
12176 
    iprot.readStructEnd()
12177 
 
12178 
  def write(self, oprot):
12179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12181 
      return
12182 
    oprot.writeStructBegin('deleteTag_result')
12183 
    if self.success is not None:
12184 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12185 
      oprot.writeBool(self.success)
12186 
      oprot.writeFieldEnd()
12187 
    oprot.writeFieldStop()
12188 
    oprot.writeStructEnd()
12189 
 
12190 
  def validate(self):
12191 
    return
12192 
 
12193 
 
12194 
  def __repr__(self):
12195 
    L = ['%s=%r' % (key, value)
12196 
      for key, value in self.__dict__.iteritems()]
12197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12198 
 
12199 
  def __eq__(self, other):
12200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12201 
 
12202 
  def __ne__(self, other):
12203 
    return not (self == other)
12204 
 
12205 
class getAllTags_args:
12206 
 
12207 
  thrift_spec = (
12208 
  )
12209 
 
12210 
  def read(self, iprot):
12211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12213 
      return
12214 
    iprot.readStructBegin()
12215 
    while True:
12216 
      (fname, ftype, fid) = iprot.readFieldBegin()
12217 
      if ftype == TType.STOP:
12218 
        break
12219 
      else:
12220 
        iprot.skip(ftype)
12221 
      iprot.readFieldEnd()
12222 
    iprot.readStructEnd()
12223 
 
12224 
  def write(self, oprot):
12225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12227 
      return
12228 
    oprot.writeStructBegin('getAllTags_args')
12229 
    oprot.writeFieldStop()
12230 
    oprot.writeStructEnd()
12231 
 
12232 
  def validate(self):
12233 
    return
12234 
 
12235 
 
12236 
  def __repr__(self):
12237 
    L = ['%s=%r' % (key, value)
12238 
      for key, value in self.__dict__.iteritems()]
12239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12240 
 
12241 
  def __eq__(self, other):
12242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12243 
 
12244 
  def __ne__(self, other):
12245 
    return not (self == other)
12246 
 
12247 
class getAllTags_result:
12248 
  """
12249 
  Attributes:
12250 
   - success
12251 
  """
12252 
 
12253 
  thrift_spec = (
12254 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12255 
  )
12256 
 
12257 
  def __init__(self, success=None,):
12258 
    self.success = success
12259 
 
12260 
  def read(self, iprot):
12261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12263 
      return
12264 
    iprot.readStructBegin()
12265 
    while True:
12266 
      (fname, ftype, fid) = iprot.readFieldBegin()
12267 
      if ftype == TType.STOP:
12268 
        break
12269 
      if fid == 0:
12270 
        if ftype == TType.LIST:
12271 
          self.success = []
8590 kshitij.so 12272 
          (_etype168, _size165) = iprot.readListBegin()
12273 
          for _i169 in xrange(_size165):
12274 
            _elem170 = iprot.readString();
12275 
            self.success.append(_elem170)
6512 kshitij.so 12276 
          iprot.readListEnd()
12277 
        else:
12278 
          iprot.skip(ftype)
12279 
      else:
12280 
        iprot.skip(ftype)
12281 
      iprot.readFieldEnd()
12282 
    iprot.readStructEnd()
12283 
 
12284 
  def write(self, oprot):
12285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12287 
      return
12288 
    oprot.writeStructBegin('getAllTags_result')
12289 
    if self.success is not None:
12290 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12291 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 12292 
      for iter171 in self.success:
12293 
        oprot.writeString(iter171)
6512 kshitij.so 12294 
      oprot.writeListEnd()
12295 
      oprot.writeFieldEnd()
12296 
    oprot.writeFieldStop()
12297 
    oprot.writeStructEnd()
12298 
 
12299 
  def validate(self):
12300 
    return
12301 
 
12302 
 
12303 
  def __repr__(self):
12304 
    L = ['%s=%r' % (key, value)
12305 
      for key, value in self.__dict__.iteritems()]
12306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12307 
 
12308 
  def __eq__(self, other):
12309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12310 
 
12311 
  def __ne__(self, other):
12312 
    return not (self == other)
12313 
 
12314 
class getAllEntitiesByTagName_args:
12315 
  """
12316 
  Attributes:
12317 
   - displayName
12318 
  """
12319 
 
12320 
  thrift_spec = (
12321 
    None, # 0
12322 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12323 
  )
12324 
 
12325 
  def __init__(self, displayName=None,):
12326 
    self.displayName = displayName
12327 
 
12328 
  def read(self, iprot):
12329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12331 
      return
12332 
    iprot.readStructBegin()
12333 
    while True:
12334 
      (fname, ftype, fid) = iprot.readFieldBegin()
12335 
      if ftype == TType.STOP:
12336 
        break
12337 
      if fid == 1:
12338 
        if ftype == TType.STRING:
12339 
          self.displayName = iprot.readString();
12340 
        else:
12341 
          iprot.skip(ftype)
12342 
      else:
12343 
        iprot.skip(ftype)
12344 
      iprot.readFieldEnd()
12345 
    iprot.readStructEnd()
12346 
 
12347 
  def write(self, oprot):
12348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12350 
      return
12351 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
12352 
    if self.displayName is not None:
12353 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12354 
      oprot.writeString(self.displayName)
12355 
      oprot.writeFieldEnd()
12356 
    oprot.writeFieldStop()
12357 
    oprot.writeStructEnd()
12358 
 
12359 
  def validate(self):
12360 
    return
12361 
 
12362 
 
12363 
  def __repr__(self):
12364 
    L = ['%s=%r' % (key, value)
12365 
      for key, value in self.__dict__.iteritems()]
12366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12367 
 
12368 
  def __eq__(self, other):
12369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12370 
 
12371 
  def __ne__(self, other):
12372 
    return not (self == other)
12373 
 
12374 
class getAllEntitiesByTagName_result:
12375 
  """
12376 
  Attributes:
12377 
   - success
12378 
  """
12379 
 
12380 
  thrift_spec = (
12381 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12382 
  )
12383 
 
12384 
  def __init__(self, success=None,):
12385 
    self.success = success
12386 
 
12387 
  def read(self, iprot):
12388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12390 
      return
12391 
    iprot.readStructBegin()
12392 
    while True:
12393 
      (fname, ftype, fid) = iprot.readFieldBegin()
12394 
      if ftype == TType.STOP:
12395 
        break
12396 
      if fid == 0:
12397 
        if ftype == TType.LIST:
12398 
          self.success = []
8590 kshitij.so 12399 
          (_etype175, _size172) = iprot.readListBegin()
12400 
          for _i176 in xrange(_size172):
12401 
            _elem177 = iprot.readI64();
12402 
            self.success.append(_elem177)
6512 kshitij.so 12403 
          iprot.readListEnd()
12404 
        else:
12405 
          iprot.skip(ftype)
12406 
      else:
12407 
        iprot.skip(ftype)
12408 
      iprot.readFieldEnd()
12409 
    iprot.readStructEnd()
12410 
 
12411 
  def write(self, oprot):
12412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12414 
      return
12415 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12416 
    if self.success is not None:
12417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12418 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12419 
      for iter178 in self.success:
12420 
        oprot.writeI64(iter178)
6512 kshitij.so 12421 
      oprot.writeListEnd()
12422 
      oprot.writeFieldEnd()
12423 
    oprot.writeFieldStop()
12424 
    oprot.writeStructEnd()
12425 
 
12426 
  def validate(self):
12427 
    return
12428 
 
12429 
 
12430 
  def __repr__(self):
12431 
    L = ['%s=%r' % (key, value)
12432 
      for key, value in self.__dict__.iteritems()]
12433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12434 
 
12435 
  def __eq__(self, other):
12436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12437 
 
12438 
  def __ne__(self, other):
12439 
    return not (self == other)
12440 
 
6845 amit.gupta 12441 
class getAllEntityTags_args:
12442 
 
12443 
  thrift_spec = (
12444 
  )
12445 
 
12446 
  def read(self, iprot):
12447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12449 
      return
12450 
    iprot.readStructBegin()
12451 
    while True:
12452 
      (fname, ftype, fid) = iprot.readFieldBegin()
12453 
      if ftype == TType.STOP:
12454 
        break
12455 
      else:
12456 
        iprot.skip(ftype)
12457 
      iprot.readFieldEnd()
12458 
    iprot.readStructEnd()
12459 
 
12460 
  def write(self, oprot):
12461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12463 
      return
12464 
    oprot.writeStructBegin('getAllEntityTags_args')
12465 
    oprot.writeFieldStop()
12466 
    oprot.writeStructEnd()
12467 
 
12468 
  def validate(self):
12469 
    return
12470 
 
12471 
 
12472 
  def __repr__(self):
12473 
    L = ['%s=%r' % (key, value)
12474 
      for key, value in self.__dict__.iteritems()]
12475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12476 
 
12477 
  def __eq__(self, other):
12478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12479 
 
12480 
  def __ne__(self, other):
12481 
    return not (self == other)
12482 
 
12483 
class getAllEntityTags_result:
12484 
  """
12485 
  Attributes:
12486 
   - success
12487 
  """
12488 
 
12489 
  thrift_spec = (
12490 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12491 
  )
12492 
 
12493 
  def __init__(self, success=None,):
12494 
    self.success = success
12495 
 
12496 
  def read(self, iprot):
12497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12499 
      return
12500 
    iprot.readStructBegin()
12501 
    while True:
12502 
      (fname, ftype, fid) = iprot.readFieldBegin()
12503 
      if ftype == TType.STOP:
12504 
        break
12505 
      if fid == 0:
12506 
        if ftype == TType.MAP:
12507 
          self.success = {}
8590 kshitij.so 12508 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12509 
          for _i183 in xrange(_size179):
12510 
            _key184 = iprot.readI64();
12511 
            _val185 = []
12512 
            (_etype189, _size186) = iprot.readListBegin()
12513 
            for _i190 in xrange(_size186):
12514 
              _elem191 = iprot.readString();
12515 
              _val185.append(_elem191)
6845 amit.gupta 12516 
            iprot.readListEnd()
8590 kshitij.so 12517 
            self.success[_key184] = _val185
6845 amit.gupta 12518 
          iprot.readMapEnd()
12519 
        else:
12520 
          iprot.skip(ftype)
12521 
      else:
12522 
        iprot.skip(ftype)
12523 
      iprot.readFieldEnd()
12524 
    iprot.readStructEnd()
12525 
 
12526 
  def write(self, oprot):
12527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12529 
      return
12530 
    oprot.writeStructBegin('getAllEntityTags_result')
12531 
    if self.success is not None:
12532 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12533 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12534 
      for kiter192,viter193 in self.success.items():
12535 
        oprot.writeI64(kiter192)
12536 
        oprot.writeListBegin(TType.STRING, len(viter193))
12537 
        for iter194 in viter193:
12538 
          oprot.writeString(iter194)
6845 amit.gupta 12539 
        oprot.writeListEnd()
12540 
      oprot.writeMapEnd()
12541 
      oprot.writeFieldEnd()
12542 
    oprot.writeFieldStop()
12543 
    oprot.writeStructEnd()
12544 
 
12545 
  def validate(self):
12546 
    return
12547 
 
12548 
 
12549 
  def __repr__(self):
12550 
    L = ['%s=%r' % (key, value)
12551 
      for key, value in self.__dict__.iteritems()]
12552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12553 
 
12554 
  def __eq__(self, other):
12555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12556 
 
12557 
  def __ne__(self, other):
12558 
    return not (self == other)
12559 
 
6850 kshitij.so 12560 
class addBanner_args:
12561 
  """
12562 
  Attributes:
8590 kshitij.so 12563 
   - bannerCongregate
6850 kshitij.so 12564 
  """
12565 
 
12566 
  thrift_spec = (
12567 
    None, # 0
8590 kshitij.so 12568 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12569 
  )
12570 
 
8590 kshitij.so 12571 
  def __init__(self, bannerCongregate=None,):
12572 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12573 
 
12574 
  def read(self, iprot):
12575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12577 
      return
12578 
    iprot.readStructBegin()
12579 
    while True:
12580 
      (fname, ftype, fid) = iprot.readFieldBegin()
12581 
      if ftype == TType.STOP:
12582 
        break
12583 
      if fid == 1:
8579 kshitij.so 12584 
        if ftype == TType.STRUCT:
8590 kshitij.so 12585 
          self.bannerCongregate = BannerCongregate()
12586 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12587 
        else:
12588 
          iprot.skip(ftype)
8579 kshitij.so 12589 
      else:
12590 
        iprot.skip(ftype)
12591 
      iprot.readFieldEnd()
12592 
    iprot.readStructEnd()
12593 
 
12594 
  def write(self, oprot):
12595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12597 
      return
12598 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 12599 
    if self.bannerCongregate is not None:
12600 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12601 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12602 
      oprot.writeFieldEnd()
12603 
    oprot.writeFieldStop()
12604 
    oprot.writeStructEnd()
12605 
 
12606 
  def validate(self):
12607 
    return
12608 
 
12609 
 
12610 
  def __repr__(self):
12611 
    L = ['%s=%r' % (key, value)
12612 
      for key, value in self.__dict__.iteritems()]
12613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12614 
 
12615 
  def __eq__(self, other):
12616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12617 
 
12618 
  def __ne__(self, other):
12619 
    return not (self == other)
12620 
 
12621 
class addBanner_result:
12622 
 
12623 
  thrift_spec = (
12624 
  )
12625 
 
12626 
  def read(self, iprot):
12627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12629 
      return
12630 
    iprot.readStructBegin()
12631 
    while True:
12632 
      (fname, ftype, fid) = iprot.readFieldBegin()
12633 
      if ftype == TType.STOP:
12634 
        break
12635 
      else:
12636 
        iprot.skip(ftype)
12637 
      iprot.readFieldEnd()
12638 
    iprot.readStructEnd()
12639 
 
12640 
  def write(self, oprot):
12641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12643 
      return
12644 
    oprot.writeStructBegin('addBanner_result')
12645 
    oprot.writeFieldStop()
12646 
    oprot.writeStructEnd()
12647 
 
12648 
  def validate(self):
12649 
    return
12650 
 
12651 
 
12652 
  def __repr__(self):
12653 
    L = ['%s=%r' % (key, value)
12654 
      for key, value in self.__dict__.iteritems()]
12655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12656 
 
12657 
  def __eq__(self, other):
12658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12659 
 
12660 
  def __ne__(self, other):
12661 
    return not (self == other)
12662 
 
12663 
class updateBanner_args:
12664 
  """
12665 
  Attributes:
12666 
   - banner
12667 
  """
12668 
 
12669 
  thrift_spec = (
12670 
    None, # 0
12671 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12672 
  )
12673 
 
12674 
  def __init__(self, banner=None,):
12675 
    self.banner = banner
12676 
 
12677 
  def read(self, iprot):
12678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12680 
      return
12681 
    iprot.readStructBegin()
12682 
    while True:
12683 
      (fname, ftype, fid) = iprot.readFieldBegin()
12684 
      if ftype == TType.STOP:
12685 
        break
12686 
      if fid == 1:
12687 
        if ftype == TType.STRUCT:
12688 
          self.banner = Banner()
12689 
          self.banner.read(iprot)
6850 kshitij.so 12690 
        else:
12691 
          iprot.skip(ftype)
12692 
      else:
12693 
        iprot.skip(ftype)
12694 
      iprot.readFieldEnd()
12695 
    iprot.readStructEnd()
12696 
 
12697 
  def write(self, oprot):
12698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12700 
      return
8579 kshitij.so 12701 
    oprot.writeStructBegin('updateBanner_args')
12702 
    if self.banner is not None:
12703 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12704 
      self.banner.write(oprot)
6850 kshitij.so 12705 
      oprot.writeFieldEnd()
12706 
    oprot.writeFieldStop()
12707 
    oprot.writeStructEnd()
12708 
 
12709 
  def validate(self):
12710 
    return
12711 
 
12712 
 
12713 
  def __repr__(self):
12714 
    L = ['%s=%r' % (key, value)
12715 
      for key, value in self.__dict__.iteritems()]
12716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12717 
 
12718 
  def __eq__(self, other):
12719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12720 
 
12721 
  def __ne__(self, other):
12722 
    return not (self == other)
12723 
 
8579 kshitij.so 12724 
class updateBanner_result:
6850 kshitij.so 12725 
  """
12726 
  Attributes:
12727 
   - success
12728 
  """
12729 
 
12730 
  thrift_spec = (
12731 
    (0, TType.BOOL, 'success', None, None, ), # 0
12732 
  )
12733 
 
12734 
  def __init__(self, success=None,):
12735 
    self.success = success
12736 
 
12737 
  def read(self, iprot):
12738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12740 
      return
12741 
    iprot.readStructBegin()
12742 
    while True:
12743 
      (fname, ftype, fid) = iprot.readFieldBegin()
12744 
      if ftype == TType.STOP:
12745 
        break
12746 
      if fid == 0:
12747 
        if ftype == TType.BOOL:
12748 
          self.success = iprot.readBool();
12749 
        else:
12750 
          iprot.skip(ftype)
12751 
      else:
12752 
        iprot.skip(ftype)
12753 
      iprot.readFieldEnd()
12754 
    iprot.readStructEnd()
12755 
 
12756 
  def write(self, oprot):
12757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12759 
      return
8579 kshitij.so 12760 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 12761 
    if self.success is not None:
12762 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12763 
      oprot.writeBool(self.success)
12764 
      oprot.writeFieldEnd()
12765 
    oprot.writeFieldStop()
12766 
    oprot.writeStructEnd()
12767 
 
12768 
  def validate(self):
12769 
    return
12770 
 
12771 
 
12772 
  def __repr__(self):
12773 
    L = ['%s=%r' % (key, value)
12774 
      for key, value in self.__dict__.iteritems()]
12775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12776 
 
12777 
  def __eq__(self, other):
12778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12779 
 
12780 
  def __ne__(self, other):
12781 
    return not (self == other)
12782 
 
12783 
class getAllBanners_args:
12784 
 
12785 
  thrift_spec = (
12786 
  )
12787 
 
12788 
  def read(self, iprot):
12789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12791 
      return
12792 
    iprot.readStructBegin()
12793 
    while True:
12794 
      (fname, ftype, fid) = iprot.readFieldBegin()
12795 
      if ftype == TType.STOP:
12796 
        break
12797 
      else:
12798 
        iprot.skip(ftype)
12799 
      iprot.readFieldEnd()
12800 
    iprot.readStructEnd()
12801 
 
12802 
  def write(self, oprot):
12803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12805 
      return
12806 
    oprot.writeStructBegin('getAllBanners_args')
12807 
    oprot.writeFieldStop()
12808 
    oprot.writeStructEnd()
12809 
 
12810 
  def validate(self):
12811 
    return
12812 
 
12813 
 
12814 
  def __repr__(self):
12815 
    L = ['%s=%r' % (key, value)
12816 
      for key, value in self.__dict__.iteritems()]
12817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12818 
 
12819 
  def __eq__(self, other):
12820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12821 
 
12822 
  def __ne__(self, other):
12823 
    return not (self == other)
12824 
 
12825 
class getAllBanners_result:
12826 
  """
12827 
  Attributes:
12828 
   - success
12829 
  """
12830 
 
12831 
  thrift_spec = (
8579 kshitij.so 12832 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 12833 
  )
12834 
 
12835 
  def __init__(self, success=None,):
12836 
    self.success = success
12837 
 
12838 
  def read(self, iprot):
12839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12841 
      return
12842 
    iprot.readStructBegin()
12843 
    while True:
12844 
      (fname, ftype, fid) = iprot.readFieldBegin()
12845 
      if ftype == TType.STOP:
12846 
        break
12847 
      if fid == 0:
12848 
        if ftype == TType.LIST:
12849 
          self.success = []
8590 kshitij.so 12850 
          (_etype198, _size195) = iprot.readListBegin()
12851 
          for _i199 in xrange(_size195):
12852 
            _elem200 = Banner()
12853 
            _elem200.read(iprot)
12854 
            self.success.append(_elem200)
6850 kshitij.so 12855 
          iprot.readListEnd()
12856 
        else:
12857 
          iprot.skip(ftype)
12858 
      else:
12859 
        iprot.skip(ftype)
12860 
      iprot.readFieldEnd()
12861 
    iprot.readStructEnd()
12862 
 
12863 
  def write(self, oprot):
12864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12866 
      return
12867 
    oprot.writeStructBegin('getAllBanners_result')
12868 
    if self.success is not None:
12869 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 12870 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12871 
      for iter201 in self.success:
12872 
        iter201.write(oprot)
6850 kshitij.so 12873 
      oprot.writeListEnd()
12874 
      oprot.writeFieldEnd()
12875 
    oprot.writeFieldStop()
12876 
    oprot.writeStructEnd()
12877 
 
12878 
  def validate(self):
12879 
    return
12880 
 
12881 
 
12882 
  def __repr__(self):
12883 
    L = ['%s=%r' % (key, value)
12884 
      for key, value in self.__dict__.iteritems()]
12885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12886 
 
12887 
  def __eq__(self, other):
12888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12889 
 
12890 
  def __ne__(self, other):
12891 
    return not (self == other)
12892 
 
12893 
class deleteBanner_args:
12894 
  """
12895 
  Attributes:
12896 
   - bannerName
9155 kshitij.so 12897 
   - bannerType
6850 kshitij.so 12898 
  """
12899 
 
12900 
  thrift_spec = (
12901 
    None, # 0
12902 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12903 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12904 
  )
12905 
 
9155 kshitij.so 12906 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12907 
    self.bannerName = bannerName
9155 kshitij.so 12908 
    self.bannerType = bannerType
6850 kshitij.so 12909 
 
12910 
  def read(self, iprot):
12911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12913 
      return
12914 
    iprot.readStructBegin()
12915 
    while True:
12916 
      (fname, ftype, fid) = iprot.readFieldBegin()
12917 
      if ftype == TType.STOP:
12918 
        break
12919 
      if fid == 1:
12920 
        if ftype == TType.STRING:
12921 
          self.bannerName = iprot.readString();
12922 
        else:
12923 
          iprot.skip(ftype)
9155 kshitij.so 12924 
      elif fid == 2:
12925 
        if ftype == TType.I32:
12926 
          self.bannerType = iprot.readI32();
12927 
        else:
12928 
          iprot.skip(ftype)
6850 kshitij.so 12929 
      else:
12930 
        iprot.skip(ftype)
12931 
      iprot.readFieldEnd()
12932 
    iprot.readStructEnd()
12933 
 
12934 
  def write(self, oprot):
12935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12937 
      return
12938 
    oprot.writeStructBegin('deleteBanner_args')
12939 
    if self.bannerName is not None:
12940 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12941 
      oprot.writeString(self.bannerName)
12942 
      oprot.writeFieldEnd()
9155 kshitij.so 12943 
    if self.bannerType is not None:
12944 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12945 
      oprot.writeI32(self.bannerType)
12946 
      oprot.writeFieldEnd()
6850 kshitij.so 12947 
    oprot.writeFieldStop()
12948 
    oprot.writeStructEnd()
12949 
 
12950 
  def validate(self):
12951 
    return
12952 
 
12953 
 
12954 
  def __repr__(self):
12955 
    L = ['%s=%r' % (key, value)
12956 
      for key, value in self.__dict__.iteritems()]
12957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12958 
 
12959 
  def __eq__(self, other):
12960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12961 
 
12962 
  def __ne__(self, other):
12963 
    return not (self == other)
12964 
 
12965 
class deleteBanner_result:
12966 
  """
12967 
  Attributes:
12968 
   - success
12969 
  """
12970 
 
12971 
  thrift_spec = (
12972 
    (0, TType.BOOL, 'success', None, None, ), # 0
12973 
  )
12974 
 
12975 
  def __init__(self, success=None,):
12976 
    self.success = success
12977 
 
12978 
  def read(self, iprot):
12979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12981 
      return
12982 
    iprot.readStructBegin()
12983 
    while True:
12984 
      (fname, ftype, fid) = iprot.readFieldBegin()
12985 
      if ftype == TType.STOP:
12986 
        break
12987 
      if fid == 0:
12988 
        if ftype == TType.BOOL:
12989 
          self.success = iprot.readBool();
12990 
        else:
12991 
          iprot.skip(ftype)
12992 
      else:
12993 
        iprot.skip(ftype)
12994 
      iprot.readFieldEnd()
12995 
    iprot.readStructEnd()
12996 
 
12997 
  def write(self, oprot):
12998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13000 
      return
13001 
    oprot.writeStructBegin('deleteBanner_result')
13002 
    if self.success is not None:
13003 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13004 
      oprot.writeBool(self.success)
13005 
      oprot.writeFieldEnd()
13006 
    oprot.writeFieldStop()
13007 
    oprot.writeStructEnd()
13008 
 
13009 
  def validate(self):
13010 
    return
13011 
 
13012 
 
13013 
  def __repr__(self):
13014 
    L = ['%s=%r' % (key, value)
13015 
      for key, value in self.__dict__.iteritems()]
13016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13017 
 
13018 
  def __eq__(self, other):
13019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13020 
 
13021 
  def __ne__(self, other):
13022 
    return not (self == other)
13023 
 
13024 
class getBannerDetails_args:
13025 
  """
13026 
  Attributes:
13027 
   - bannerName
9155 kshitij.so 13028 
   - bannerType
6850 kshitij.so 13029 
  """
13030 
 
13031 
  thrift_spec = (
13032 
    None, # 0
13033 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13034 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 13035 
  )
13036 
 
9155 kshitij.so 13037 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 13038 
    self.bannerName = bannerName
9155 kshitij.so 13039 
    self.bannerType = bannerType
6850 kshitij.so 13040 
 
13041 
  def read(self, iprot):
13042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13044 
      return
13045 
    iprot.readStructBegin()
13046 
    while True:
13047 
      (fname, ftype, fid) = iprot.readFieldBegin()
13048 
      if ftype == TType.STOP:
13049 
        break
13050 
      if fid == 1:
13051 
        if ftype == TType.STRING:
13052 
          self.bannerName = iprot.readString();
13053 
        else:
13054 
          iprot.skip(ftype)
9155 kshitij.so 13055 
      elif fid == 2:
13056 
        if ftype == TType.I32:
13057 
          self.bannerType = iprot.readI32();
13058 
        else:
13059 
          iprot.skip(ftype)
6850 kshitij.so 13060 
      else:
13061 
        iprot.skip(ftype)
13062 
      iprot.readFieldEnd()
13063 
    iprot.readStructEnd()
13064 
 
13065 
  def write(self, oprot):
13066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13068 
      return
13069 
    oprot.writeStructBegin('getBannerDetails_args')
13070 
    if self.bannerName is not None:
13071 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13072 
      oprot.writeString(self.bannerName)
13073 
      oprot.writeFieldEnd()
9155 kshitij.so 13074 
    if self.bannerType is not None:
13075 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13076 
      oprot.writeI32(self.bannerType)
13077 
      oprot.writeFieldEnd()
6850 kshitij.so 13078 
    oprot.writeFieldStop()
13079 
    oprot.writeStructEnd()
13080 
 
13081 
  def validate(self):
13082 
    return
13083 
 
13084 
 
13085 
  def __repr__(self):
13086 
    L = ['%s=%r' % (key, value)
13087 
      for key, value in self.__dict__.iteritems()]
13088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13089 
 
13090 
  def __eq__(self, other):
13091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13092 
 
13093 
  def __ne__(self, other):
13094 
    return not (self == other)
13095 
 
13096 
class getBannerDetails_result:
13097 
  """
13098 
  Attributes:
13099 
   - success
13100 
  """
13101 
 
13102 
  thrift_spec = (
13103 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
13104 
  )
13105 
 
13106 
  def __init__(self, success=None,):
13107 
    self.success = success
13108 
 
13109 
  def read(self, iprot):
13110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13112 
      return
13113 
    iprot.readStructBegin()
13114 
    while True:
13115 
      (fname, ftype, fid) = iprot.readFieldBegin()
13116 
      if ftype == TType.STOP:
13117 
        break
13118 
      if fid == 0:
13119 
        if ftype == TType.STRUCT:
13120 
          self.success = Banner()
13121 
          self.success.read(iprot)
13122 
        else:
13123 
          iprot.skip(ftype)
13124 
      else:
13125 
        iprot.skip(ftype)
13126 
      iprot.readFieldEnd()
13127 
    iprot.readStructEnd()
13128 
 
13129 
  def write(self, oprot):
13130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13132 
      return
13133 
    oprot.writeStructBegin('getBannerDetails_result')
13134 
    if self.success is not None:
13135 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13136 
      self.success.write(oprot)
13137 
      oprot.writeFieldEnd()
13138 
    oprot.writeFieldStop()
13139 
    oprot.writeStructEnd()
13140 
 
13141 
  def validate(self):
13142 
    return
13143 
 
13144 
 
13145 
  def __repr__(self):
13146 
    L = ['%s=%r' % (key, value)
13147 
      for key, value in self.__dict__.iteritems()]
13148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13149 
 
13150 
  def __eq__(self, other):
13151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13152 
 
13153 
  def __ne__(self, other):
13154 
    return not (self == other)
13155 
 
13156 
class getActiveBanners_args:
13157 
 
13158 
  thrift_spec = (
13159 
  )
13160 
 
13161 
  def read(self, iprot):
13162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13164 
      return
13165 
    iprot.readStructBegin()
13166 
    while True:
13167 
      (fname, ftype, fid) = iprot.readFieldBegin()
13168 
      if ftype == TType.STOP:
13169 
        break
13170 
      else:
13171 
        iprot.skip(ftype)
13172 
      iprot.readFieldEnd()
13173 
    iprot.readStructEnd()
13174 
 
13175 
  def write(self, oprot):
13176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13178 
      return
13179 
    oprot.writeStructBegin('getActiveBanners_args')
13180 
    oprot.writeFieldStop()
13181 
    oprot.writeStructEnd()
13182 
 
13183 
  def validate(self):
13184 
    return
13185 
 
13186 
 
13187 
  def __repr__(self):
13188 
    L = ['%s=%r' % (key, value)
13189 
      for key, value in self.__dict__.iteritems()]
13190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13191 
 
13192 
  def __eq__(self, other):
13193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13194 
 
13195 
  def __ne__(self, other):
13196 
    return not (self == other)
13197 
 
13198 
class getActiveBanners_result:
13199 
  """
13200 
  Attributes:
13201 
   - success
13202 
  """
13203 
 
13204 
  thrift_spec = (
8579 kshitij.so 13205 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 13206 
  )
13207 
 
13208 
  def __init__(self, success=None,):
13209 
    self.success = success
13210 
 
13211 
  def read(self, iprot):
13212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13214 
      return
13215 
    iprot.readStructBegin()
13216 
    while True:
13217 
      (fname, ftype, fid) = iprot.readFieldBegin()
13218 
      if ftype == TType.STOP:
13219 
        break
13220 
      if fid == 0:
8579 kshitij.so 13221 
        if ftype == TType.MAP:
13222 
          self.success = {}
8590 kshitij.so 13223 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
13224 
          for _i206 in xrange(_size202):
13225 
            _key207 = iprot.readString();
13226 
            _val208 = []
13227 
            (_etype212, _size209) = iprot.readListBegin()
13228 
            for _i213 in xrange(_size209):
13229 
              _elem214 = Banner()
13230 
              _elem214.read(iprot)
13231 
              _val208.append(_elem214)
8579 kshitij.so 13232 
            iprot.readListEnd()
8590 kshitij.so 13233 
            self.success[_key207] = _val208
8579 kshitij.so 13234 
          iprot.readMapEnd()
6850 kshitij.so 13235 
        else:
13236 
          iprot.skip(ftype)
13237 
      else:
13238 
        iprot.skip(ftype)
13239 
      iprot.readFieldEnd()
13240 
    iprot.readStructEnd()
13241 
 
13242 
  def write(self, oprot):
13243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13245 
      return
13246 
    oprot.writeStructBegin('getActiveBanners_result')
13247 
    if self.success is not None:
8579 kshitij.so 13248 
      oprot.writeFieldBegin('success', TType.MAP, 0)
13249 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 13250 
      for kiter215,viter216 in self.success.items():
13251 
        oprot.writeString(kiter215)
13252 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
13253 
        for iter217 in viter216:
13254 
          iter217.write(oprot)
8579 kshitij.so 13255 
        oprot.writeListEnd()
13256 
      oprot.writeMapEnd()
6850 kshitij.so 13257 
      oprot.writeFieldEnd()
13258 
    oprot.writeFieldStop()
13259 
    oprot.writeStructEnd()
13260 
 
13261 
  def validate(self):
13262 
    return
13263 
 
13264 
 
13265 
  def __repr__(self):
13266 
    L = ['%s=%r' % (key, value)
13267 
      for key, value in self.__dict__.iteritems()]
13268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13269 
 
13270 
  def __eq__(self, other):
13271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13272 
 
13273 
  def __ne__(self, other):
13274 
    return not (self == other)
13275 
 
6849 kshitij.so 13276 
class addBannerMap_args:
13277 
  """
13278 
  Attributes:
8579 kshitij.so 13279 
   - bannerMaps
6849 kshitij.so 13280 
  """
13281 
 
13282 
  thrift_spec = (
13283 
    None, # 0
8579 kshitij.so 13284 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 13285 
  )
13286 
 
8579 kshitij.so 13287 
  def __init__(self, bannerMaps=None,):
13288 
    self.bannerMaps = bannerMaps
6849 kshitij.so 13289 
 
13290 
  def read(self, iprot):
13291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13293 
      return
13294 
    iprot.readStructBegin()
13295 
    while True:
13296 
      (fname, ftype, fid) = iprot.readFieldBegin()
13297 
      if ftype == TType.STOP:
13298 
        break
13299 
      if fid == 1:
8579 kshitij.so 13300 
        if ftype == TType.LIST:
13301 
          self.bannerMaps = []
8590 kshitij.so 13302 
          (_etype221, _size218) = iprot.readListBegin()
13303 
          for _i222 in xrange(_size218):
13304 
            _elem223 = BannerMap()
13305 
            _elem223.read(iprot)
13306 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 13307 
          iprot.readListEnd()
6849 kshitij.so 13308 
        else:
13309 
          iprot.skip(ftype)
8579 kshitij.so 13310 
      else:
13311 
        iprot.skip(ftype)
13312 
      iprot.readFieldEnd()
13313 
    iprot.readStructEnd()
13314 
 
13315 
  def write(self, oprot):
13316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13318 
      return
13319 
    oprot.writeStructBegin('addBannerMap_args')
13320 
    if self.bannerMaps is not None:
13321 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
13322 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 13323 
      for iter224 in self.bannerMaps:
13324 
        iter224.write(oprot)
8579 kshitij.so 13325 
      oprot.writeListEnd()
13326 
      oprot.writeFieldEnd()
13327 
    oprot.writeFieldStop()
13328 
    oprot.writeStructEnd()
13329 
 
13330 
  def validate(self):
13331 
    return
13332 
 
13333 
 
13334 
  def __repr__(self):
13335 
    L = ['%s=%r' % (key, value)
13336 
      for key, value in self.__dict__.iteritems()]
13337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13338 
 
13339 
  def __eq__(self, other):
13340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13341 
 
13342 
  def __ne__(self, other):
13343 
    return not (self == other)
13344 
 
13345 
class addBannerMap_result:
13346 
  """
13347 
  Attributes:
13348 
   - success
13349 
  """
13350 
 
13351 
  thrift_spec = (
13352 
    (0, TType.BOOL, 'success', None, None, ), # 0
13353 
  )
13354 
 
13355 
  def __init__(self, success=None,):
13356 
    self.success = success
13357 
 
13358 
  def read(self, iprot):
13359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13361 
      return
13362 
    iprot.readStructBegin()
13363 
    while True:
13364 
      (fname, ftype, fid) = iprot.readFieldBegin()
13365 
      if ftype == TType.STOP:
13366 
        break
13367 
      if fid == 0:
13368 
        if ftype == TType.BOOL:
13369 
          self.success = iprot.readBool();
6849 kshitij.so 13370 
        else:
13371 
          iprot.skip(ftype)
8579 kshitij.so 13372 
      else:
13373 
        iprot.skip(ftype)
13374 
      iprot.readFieldEnd()
13375 
    iprot.readStructEnd()
13376 
 
13377 
  def write(self, oprot):
13378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13380 
      return
13381 
    oprot.writeStructBegin('addBannerMap_result')
13382 
    if self.success is not None:
13383 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13384 
      oprot.writeBool(self.success)
13385 
      oprot.writeFieldEnd()
13386 
    oprot.writeFieldStop()
13387 
    oprot.writeStructEnd()
13388 
 
13389 
  def validate(self):
13390 
    return
13391 
 
13392 
 
13393 
  def __repr__(self):
13394 
    L = ['%s=%r' % (key, value)
13395 
      for key, value in self.__dict__.iteritems()]
13396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13397 
 
13398 
  def __eq__(self, other):
13399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13400 
 
13401 
  def __ne__(self, other):
13402 
    return not (self == other)
13403 
 
13404 
class updateBannerMap_args:
13405 
  """
13406 
  Attributes:
13407 
   - bannerMap
13408 
  """
13409 
 
13410 
  thrift_spec = (
13411 
    None, # 0
13412 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13413 
  )
13414 
 
13415 
  def __init__(self, bannerMap=None,):
13416 
    self.bannerMap = bannerMap
13417 
 
13418 
  def read(self, iprot):
13419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13421 
      return
13422 
    iprot.readStructBegin()
13423 
    while True:
13424 
      (fname, ftype, fid) = iprot.readFieldBegin()
13425 
      if ftype == TType.STOP:
13426 
        break
13427 
      if fid == 1:
13428 
        if ftype == TType.STRUCT:
13429 
          self.bannerMap = BannerMap()
13430 
          self.bannerMap.read(iprot)
6849 kshitij.so 13431 
        else:
13432 
          iprot.skip(ftype)
13433 
      else:
13434 
        iprot.skip(ftype)
13435 
      iprot.readFieldEnd()
13436 
    iprot.readStructEnd()
13437 
 
13438 
  def write(self, oprot):
13439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13441 
      return
8579 kshitij.so 13442 
    oprot.writeStructBegin('updateBannerMap_args')
13443 
    if self.bannerMap is not None:
13444 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13445 
      self.bannerMap.write(oprot)
6849 kshitij.so 13446 
      oprot.writeFieldEnd()
13447 
    oprot.writeFieldStop()
13448 
    oprot.writeStructEnd()
13449 
 
13450 
  def validate(self):
13451 
    return
13452 
 
13453 
 
13454 
  def __repr__(self):
13455 
    L = ['%s=%r' % (key, value)
13456 
      for key, value in self.__dict__.iteritems()]
13457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13458 
 
13459 
  def __eq__(self, other):
13460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13461 
 
13462 
  def __ne__(self, other):
13463 
    return not (self == other)
13464 
 
8579 kshitij.so 13465 
class updateBannerMap_result:
6849 kshitij.so 13466 
  """
13467 
  Attributes:
13468 
   - success
13469 
  """
13470 
 
13471 
  thrift_spec = (
13472 
    (0, TType.BOOL, 'success', None, None, ), # 0
13473 
  )
13474 
 
13475 
  def __init__(self, success=None,):
13476 
    self.success = success
13477 
 
13478 
  def read(self, iprot):
13479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13481 
      return
13482 
    iprot.readStructBegin()
13483 
    while True:
13484 
      (fname, ftype, fid) = iprot.readFieldBegin()
13485 
      if ftype == TType.STOP:
13486 
        break
13487 
      if fid == 0:
13488 
        if ftype == TType.BOOL:
13489 
          self.success = iprot.readBool();
13490 
        else:
13491 
          iprot.skip(ftype)
13492 
      else:
13493 
        iprot.skip(ftype)
13494 
      iprot.readFieldEnd()
13495 
    iprot.readStructEnd()
13496 
 
13497 
  def write(self, oprot):
13498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13500 
      return
8579 kshitij.so 13501 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13502 
    if self.success is not None:
13503 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13504 
      oprot.writeBool(self.success)
13505 
      oprot.writeFieldEnd()
13506 
    oprot.writeFieldStop()
13507 
    oprot.writeStructEnd()
13508 
 
13509 
  def validate(self):
13510 
    return
13511 
 
13512 
 
13513 
  def __repr__(self):
13514 
    L = ['%s=%r' % (key, value)
13515 
      for key, value in self.__dict__.iteritems()]
13516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13517 
 
13518 
  def __eq__(self, other):
13519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13520 
 
13521 
  def __ne__(self, other):
13522 
    return not (self == other)
13523 
 
13524 
class deleteBannerMap_args:
13525 
  """
13526 
  Attributes:
13527 
   - bannerName
13528 
  """
13529 
 
13530 
  thrift_spec = (
13531 
    None, # 0
13532 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13533 
  )
13534 
 
13535 
  def __init__(self, bannerName=None,):
13536 
    self.bannerName = bannerName
13537 
 
13538 
  def read(self, iprot):
13539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13541 
      return
13542 
    iprot.readStructBegin()
13543 
    while True:
13544 
      (fname, ftype, fid) = iprot.readFieldBegin()
13545 
      if ftype == TType.STOP:
13546 
        break
13547 
      if fid == 1:
13548 
        if ftype == TType.STRING:
13549 
          self.bannerName = iprot.readString();
13550 
        else:
13551 
          iprot.skip(ftype)
13552 
      else:
13553 
        iprot.skip(ftype)
13554 
      iprot.readFieldEnd()
13555 
    iprot.readStructEnd()
13556 
 
13557 
  def write(self, oprot):
13558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13560 
      return
13561 
    oprot.writeStructBegin('deleteBannerMap_args')
13562 
    if self.bannerName is not None:
13563 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13564 
      oprot.writeString(self.bannerName)
13565 
      oprot.writeFieldEnd()
13566 
    oprot.writeFieldStop()
13567 
    oprot.writeStructEnd()
13568 
 
13569 
  def validate(self):
13570 
    return
13571 
 
13572 
 
13573 
  def __repr__(self):
13574 
    L = ['%s=%r' % (key, value)
13575 
      for key, value in self.__dict__.iteritems()]
13576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13577 
 
13578 
  def __eq__(self, other):
13579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13580 
 
13581 
  def __ne__(self, other):
13582 
    return not (self == other)
13583 
 
13584 
class deleteBannerMap_result:
13585 
  """
13586 
  Attributes:
13587 
   - success
13588 
  """
13589 
 
13590 
  thrift_spec = (
13591 
    (0, TType.BOOL, 'success', None, None, ), # 0
13592 
  )
13593 
 
13594 
  def __init__(self, success=None,):
13595 
    self.success = success
13596 
 
13597 
  def read(self, iprot):
13598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13600 
      return
13601 
    iprot.readStructBegin()
13602 
    while True:
13603 
      (fname, ftype, fid) = iprot.readFieldBegin()
13604 
      if ftype == TType.STOP:
13605 
        break
13606 
      if fid == 0:
13607 
        if ftype == TType.BOOL:
13608 
          self.success = iprot.readBool();
13609 
        else:
13610 
          iprot.skip(ftype)
13611 
      else:
13612 
        iprot.skip(ftype)
13613 
      iprot.readFieldEnd()
13614 
    iprot.readStructEnd()
13615 
 
13616 
  def write(self, oprot):
13617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13619 
      return
13620 
    oprot.writeStructBegin('deleteBannerMap_result')
13621 
    if self.success is not None:
13622 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13623 
      oprot.writeBool(self.success)
13624 
      oprot.writeFieldEnd()
13625 
    oprot.writeFieldStop()
13626 
    oprot.writeStructEnd()
13627 
 
13628 
  def validate(self):
13629 
    return
13630 
 
13631 
 
13632 
  def __repr__(self):
13633 
    L = ['%s=%r' % (key, value)
13634 
      for key, value in self.__dict__.iteritems()]
13635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13636 
 
13637 
  def __eq__(self, other):
13638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13639 
 
13640 
  def __ne__(self, other):
13641 
    return not (self == other)
13642 
 
13643 
class getBannerMapDetails_args:
13644 
  """
13645 
  Attributes:
13646 
   - bannerName
9155 kshitij.so 13647 
   - bannerType
6849 kshitij.so 13648 
  """
13649 
 
13650 
  thrift_spec = (
13651 
    None, # 0
13652 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13653 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13654 
  )
13655 
 
9155 kshitij.so 13656 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13657 
    self.bannerName = bannerName
9155 kshitij.so 13658 
    self.bannerType = bannerType
6849 kshitij.so 13659 
 
13660 
  def read(self, iprot):
13661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13663 
      return
13664 
    iprot.readStructBegin()
13665 
    while True:
13666 
      (fname, ftype, fid) = iprot.readFieldBegin()
13667 
      if ftype == TType.STOP:
13668 
        break
13669 
      if fid == 1:
13670 
        if ftype == TType.STRING:
13671 
          self.bannerName = iprot.readString();
13672 
        else:
13673 
          iprot.skip(ftype)
9155 kshitij.so 13674 
      elif fid == 2:
13675 
        if ftype == TType.I32:
13676 
          self.bannerType = iprot.readI32();
13677 
        else:
13678 
          iprot.skip(ftype)
6849 kshitij.so 13679 
      else:
13680 
        iprot.skip(ftype)
13681 
      iprot.readFieldEnd()
13682 
    iprot.readStructEnd()
13683 
 
13684 
  def write(self, oprot):
13685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13687 
      return
13688 
    oprot.writeStructBegin('getBannerMapDetails_args')
13689 
    if self.bannerName is not None:
13690 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13691 
      oprot.writeString(self.bannerName)
13692 
      oprot.writeFieldEnd()
9155 kshitij.so 13693 
    if self.bannerType is not None:
13694 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13695 
      oprot.writeI32(self.bannerType)
13696 
      oprot.writeFieldEnd()
6849 kshitij.so 13697 
    oprot.writeFieldStop()
13698 
    oprot.writeStructEnd()
13699 
 
13700 
  def validate(self):
13701 
    return
13702 
 
13703 
 
13704 
  def __repr__(self):
13705 
    L = ['%s=%r' % (key, value)
13706 
      for key, value in self.__dict__.iteritems()]
13707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13708 
 
13709 
  def __eq__(self, other):
13710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13711 
 
13712 
  def __ne__(self, other):
13713 
    return not (self == other)
13714 
 
13715 
class getBannerMapDetails_result:
13716 
  """
13717 
  Attributes:
13718 
   - success
13719 
  """
13720 
 
13721 
  thrift_spec = (
13722 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13723 
  )
13724 
 
13725 
  def __init__(self, success=None,):
13726 
    self.success = success
13727 
 
13728 
  def read(self, iprot):
13729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13731 
      return
13732 
    iprot.readStructBegin()
13733 
    while True:
13734 
      (fname, ftype, fid) = iprot.readFieldBegin()
13735 
      if ftype == TType.STOP:
13736 
        break
13737 
      if fid == 0:
13738 
        if ftype == TType.LIST:
13739 
          self.success = []
8590 kshitij.so 13740 
          (_etype228, _size225) = iprot.readListBegin()
13741 
          for _i229 in xrange(_size225):
13742 
            _elem230 = BannerMap()
13743 
            _elem230.read(iprot)
13744 
            self.success.append(_elem230)
6849 kshitij.so 13745 
          iprot.readListEnd()
13746 
        else:
13747 
          iprot.skip(ftype)
13748 
      else:
13749 
        iprot.skip(ftype)
13750 
      iprot.readFieldEnd()
13751 
    iprot.readStructEnd()
13752 
 
13753 
  def write(self, oprot):
13754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13756 
      return
13757 
    oprot.writeStructBegin('getBannerMapDetails_result')
13758 
    if self.success is not None:
13759 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13760 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13761 
      for iter231 in self.success:
13762 
        iter231.write(oprot)
6849 kshitij.so 13763 
      oprot.writeListEnd()
13764 
      oprot.writeFieldEnd()
13765 
    oprot.writeFieldStop()
13766 
    oprot.writeStructEnd()
13767 
 
13768 
  def validate(self):
13769 
    return
13770 
 
13771 
 
13772 
  def __repr__(self):
13773 
    L = ['%s=%r' % (key, value)
13774 
      for key, value in self.__dict__.iteritems()]
13775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13776 
 
13777 
  def __eq__(self, other):
13778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13779 
 
13780 
  def __ne__(self, other):
13781 
    return not (self == other)
13782 
 
8579 kshitij.so 13783 
class addBannerUri_args:
13784 
  """
13785 
  Attributes:
13786 
   - bannerUriMappings
13787 
  """
13788 
 
13789 
  thrift_spec = (
13790 
    None, # 0
13791 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
13792 
  )
13793 
 
13794 
  def __init__(self, bannerUriMappings=None,):
13795 
    self.bannerUriMappings = bannerUriMappings
13796 
 
13797 
  def read(self, iprot):
13798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13800 
      return
13801 
    iprot.readStructBegin()
13802 
    while True:
13803 
      (fname, ftype, fid) = iprot.readFieldBegin()
13804 
      if ftype == TType.STOP:
13805 
        break
13806 
      if fid == 1:
13807 
        if ftype == TType.LIST:
13808 
          self.bannerUriMappings = []
8590 kshitij.so 13809 
          (_etype235, _size232) = iprot.readListBegin()
13810 
          for _i236 in xrange(_size232):
13811 
            _elem237 = BannerUriMapping()
13812 
            _elem237.read(iprot)
13813 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 13814 
          iprot.readListEnd()
13815 
        else:
13816 
          iprot.skip(ftype)
13817 
      else:
13818 
        iprot.skip(ftype)
13819 
      iprot.readFieldEnd()
13820 
    iprot.readStructEnd()
13821 
 
13822 
  def write(self, oprot):
13823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13825 
      return
13826 
    oprot.writeStructBegin('addBannerUri_args')
13827 
    if self.bannerUriMappings is not None:
13828 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
13829 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 13830 
      for iter238 in self.bannerUriMappings:
13831 
        iter238.write(oprot)
8579 kshitij.so 13832 
      oprot.writeListEnd()
13833 
      oprot.writeFieldEnd()
13834 
    oprot.writeFieldStop()
13835 
    oprot.writeStructEnd()
13836 
 
13837 
  def validate(self):
13838 
    return
13839 
 
13840 
 
13841 
  def __repr__(self):
13842 
    L = ['%s=%r' % (key, value)
13843 
      for key, value in self.__dict__.iteritems()]
13844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13845 
 
13846 
  def __eq__(self, other):
13847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13848 
 
13849 
  def __ne__(self, other):
13850 
    return not (self == other)
13851 
 
13852 
class addBannerUri_result:
13853 
 
13854 
  thrift_spec = (
13855 
  )
13856 
 
13857 
  def read(self, iprot):
13858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13860 
      return
13861 
    iprot.readStructBegin()
13862 
    while True:
13863 
      (fname, ftype, fid) = iprot.readFieldBegin()
13864 
      if ftype == TType.STOP:
13865 
        break
13866 
      else:
13867 
        iprot.skip(ftype)
13868 
      iprot.readFieldEnd()
13869 
    iprot.readStructEnd()
13870 
 
13871 
  def write(self, oprot):
13872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13874 
      return
13875 
    oprot.writeStructBegin('addBannerUri_result')
13876 
    oprot.writeFieldStop()
13877 
    oprot.writeStructEnd()
13878 
 
13879 
  def validate(self):
13880 
    return
13881 
 
13882 
 
13883 
  def __repr__(self):
13884 
    L = ['%s=%r' % (key, value)
13885 
      for key, value in self.__dict__.iteritems()]
13886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13887 
 
13888 
  def __eq__(self, other):
13889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13890 
 
13891 
  def __ne__(self, other):
13892 
    return not (self == other)
13893 
 
13894 
class getUriMapping_args:
13895 
  """
13896 
  Attributes:
13897 
   - bannerName
9155 kshitij.so 13898 
   - bannerType
8579 kshitij.so 13899 
  """
13900 
 
13901 
  thrift_spec = (
13902 
    None, # 0
13903 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13904 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 13905 
  )
13906 
 
9155 kshitij.so 13907 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 13908 
    self.bannerName = bannerName
9155 kshitij.so 13909 
    self.bannerType = bannerType
8579 kshitij.so 13910 
 
13911 
  def read(self, iprot):
13912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13914 
      return
13915 
    iprot.readStructBegin()
13916 
    while True:
13917 
      (fname, ftype, fid) = iprot.readFieldBegin()
13918 
      if ftype == TType.STOP:
13919 
        break
13920 
      if fid == 1:
13921 
        if ftype == TType.STRING:
13922 
          self.bannerName = iprot.readString();
13923 
        else:
13924 
          iprot.skip(ftype)
9155 kshitij.so 13925 
      elif fid == 2:
13926 
        if ftype == TType.I32:
13927 
          self.bannerType = iprot.readI32();
13928 
        else:
13929 
          iprot.skip(ftype)
8579 kshitij.so 13930 
      else:
13931 
        iprot.skip(ftype)
13932 
      iprot.readFieldEnd()
13933 
    iprot.readStructEnd()
13934 
 
13935 
  def write(self, oprot):
13936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13938 
      return
13939 
    oprot.writeStructBegin('getUriMapping_args')
13940 
    if self.bannerName is not None:
13941 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13942 
      oprot.writeString(self.bannerName)
13943 
      oprot.writeFieldEnd()
9155 kshitij.so 13944 
    if self.bannerType is not None:
13945 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13946 
      oprot.writeI32(self.bannerType)
13947 
      oprot.writeFieldEnd()
8579 kshitij.so 13948 
    oprot.writeFieldStop()
13949 
    oprot.writeStructEnd()
13950 
 
13951 
  def validate(self):
13952 
    return
13953 
 
13954 
 
13955 
  def __repr__(self):
13956 
    L = ['%s=%r' % (key, value)
13957 
      for key, value in self.__dict__.iteritems()]
13958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13959 
 
13960 
  def __eq__(self, other):
13961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13962 
 
13963 
  def __ne__(self, other):
13964 
    return not (self == other)
13965 
 
13966 
class getUriMapping_result:
13967 
  """
13968 
  Attributes:
13969 
   - success
13970 
  """
13971 
 
13972 
  thrift_spec = (
13973 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
13974 
  )
13975 
 
13976 
  def __init__(self, success=None,):
13977 
    self.success = success
13978 
 
13979 
  def read(self, iprot):
13980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13982 
      return
13983 
    iprot.readStructBegin()
13984 
    while True:
13985 
      (fname, ftype, fid) = iprot.readFieldBegin()
13986 
      if ftype == TType.STOP:
13987 
        break
13988 
      if fid == 0:
13989 
        if ftype == TType.LIST:
13990 
          self.success = []
8590 kshitij.so 13991 
          (_etype242, _size239) = iprot.readListBegin()
13992 
          for _i243 in xrange(_size239):
13993 
            _elem244 = BannerUriMapping()
13994 
            _elem244.read(iprot)
13995 
            self.success.append(_elem244)
8579 kshitij.so 13996 
          iprot.readListEnd()
13997 
        else:
13998 
          iprot.skip(ftype)
13999 
      else:
14000 
        iprot.skip(ftype)
14001 
      iprot.readFieldEnd()
14002 
    iprot.readStructEnd()
14003 
 
14004 
  def write(self, oprot):
14005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14007 
      return
14008 
    oprot.writeStructBegin('getUriMapping_result')
14009 
    if self.success is not None:
14010 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14011 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14012 
      for iter245 in self.success:
14013 
        iter245.write(oprot)
8579 kshitij.so 14014 
      oprot.writeListEnd()
14015 
      oprot.writeFieldEnd()
14016 
    oprot.writeFieldStop()
14017 
    oprot.writeStructEnd()
14018 
 
14019 
  def validate(self):
14020 
    return
14021 
 
14022 
 
14023 
  def __repr__(self):
14024 
    L = ['%s=%r' % (key, value)
14025 
      for key, value in self.__dict__.iteritems()]
14026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14027 
 
14028 
  def __eq__(self, other):
14029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14030 
 
14031 
  def __ne__(self, other):
14032 
    return not (self == other)
14033 
 
14034 
class addCampaign_args:
14035 
  """
14036 
  Attributes:
14037 
   - campaign
14038 
  """
14039 
 
14040 
  thrift_spec = (
14041 
    None, # 0
14042 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
14043 
  )
14044 
 
14045 
  def __init__(self, campaign=None,):
14046 
    self.campaign = campaign
14047 
 
14048 
  def read(self, iprot):
14049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14051 
      return
14052 
    iprot.readStructBegin()
14053 
    while True:
14054 
      (fname, ftype, fid) = iprot.readFieldBegin()
14055 
      if ftype == TType.STOP:
14056 
        break
14057 
      if fid == 1:
14058 
        if ftype == TType.STRUCT:
14059 
          self.campaign = Campaign()
14060 
          self.campaign.read(iprot)
14061 
        else:
14062 
          iprot.skip(ftype)
14063 
      else:
14064 
        iprot.skip(ftype)
14065 
      iprot.readFieldEnd()
14066 
    iprot.readStructEnd()
14067 
 
14068 
  def write(self, oprot):
14069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14071 
      return
14072 
    oprot.writeStructBegin('addCampaign_args')
14073 
    if self.campaign is not None:
14074 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
14075 
      self.campaign.write(oprot)
14076 
      oprot.writeFieldEnd()
14077 
    oprot.writeFieldStop()
14078 
    oprot.writeStructEnd()
14079 
 
14080 
  def validate(self):
14081 
    return
14082 
 
14083 
 
14084 
  def __repr__(self):
14085 
    L = ['%s=%r' % (key, value)
14086 
      for key, value in self.__dict__.iteritems()]
14087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14088 
 
14089 
  def __eq__(self, other):
14090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14091 
 
14092 
  def __ne__(self, other):
14093 
    return not (self == other)
14094 
 
14095 
class addCampaign_result:
14096 
 
14097 
  thrift_spec = (
14098 
  )
14099 
 
14100 
  def read(self, iprot):
14101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14103 
      return
14104 
    iprot.readStructBegin()
14105 
    while True:
14106 
      (fname, ftype, fid) = iprot.readFieldBegin()
14107 
      if ftype == TType.STOP:
14108 
        break
14109 
      else:
14110 
        iprot.skip(ftype)
14111 
      iprot.readFieldEnd()
14112 
    iprot.readStructEnd()
14113 
 
14114 
  def write(self, oprot):
14115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14117 
      return
14118 
    oprot.writeStructBegin('addCampaign_result')
14119 
    oprot.writeFieldStop()
14120 
    oprot.writeStructEnd()
14121 
 
14122 
  def validate(self):
14123 
    return
14124 
 
14125 
 
14126 
  def __repr__(self):
14127 
    L = ['%s=%r' % (key, value)
14128 
      for key, value in self.__dict__.iteritems()]
14129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14130 
 
14131 
  def __eq__(self, other):
14132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14133 
 
14134 
  def __ne__(self, other):
14135 
    return not (self == other)
14136 
 
14137 
class getCampaigns_args:
14138 
  """
14139 
  Attributes:
14140 
   - campaignName
14141 
  """
14142 
 
14143 
  thrift_spec = (
14144 
    None, # 0
14145 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
14146 
  )
14147 
 
14148 
  def __init__(self, campaignName=None,):
14149 
    self.campaignName = campaignName
14150 
 
14151 
  def read(self, iprot):
14152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14154 
      return
14155 
    iprot.readStructBegin()
14156 
    while True:
14157 
      (fname, ftype, fid) = iprot.readFieldBegin()
14158 
      if ftype == TType.STOP:
14159 
        break
14160 
      if fid == 1:
14161 
        if ftype == TType.STRING:
14162 
          self.campaignName = iprot.readString();
14163 
        else:
14164 
          iprot.skip(ftype)
14165 
      else:
14166 
        iprot.skip(ftype)
14167 
      iprot.readFieldEnd()
14168 
    iprot.readStructEnd()
14169 
 
14170 
  def write(self, oprot):
14171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14173 
      return
14174 
    oprot.writeStructBegin('getCampaigns_args')
14175 
    if self.campaignName is not None:
14176 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
14177 
      oprot.writeString(self.campaignName)
14178 
      oprot.writeFieldEnd()
14179 
    oprot.writeFieldStop()
14180 
    oprot.writeStructEnd()
14181 
 
14182 
  def validate(self):
14183 
    return
14184 
 
14185 
 
14186 
  def __repr__(self):
14187 
    L = ['%s=%r' % (key, value)
14188 
      for key, value in self.__dict__.iteritems()]
14189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14190 
 
14191 
  def __eq__(self, other):
14192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14193 
 
14194 
  def __ne__(self, other):
14195 
    return not (self == other)
14196 
 
14197 
class getCampaigns_result:
14198 
  """
14199 
  Attributes:
14200 
   - success
14201 
  """
14202 
 
14203 
  thrift_spec = (
14204 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
14205 
  )
14206 
 
14207 
  def __init__(self, success=None,):
14208 
    self.success = success
14209 
 
14210 
  def read(self, iprot):
14211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14213 
      return
14214 
    iprot.readStructBegin()
14215 
    while True:
14216 
      (fname, ftype, fid) = iprot.readFieldBegin()
14217 
      if ftype == TType.STOP:
14218 
        break
14219 
      if fid == 0:
14220 
        if ftype == TType.LIST:
14221 
          self.success = []
8590 kshitij.so 14222 
          (_etype249, _size246) = iprot.readListBegin()
14223 
          for _i250 in xrange(_size246):
14224 
            _elem251 = Campaign()
14225 
            _elem251.read(iprot)
14226 
            self.success.append(_elem251)
8579 kshitij.so 14227 
          iprot.readListEnd()
14228 
        else:
14229 
          iprot.skip(ftype)
14230 
      else:
14231 
        iprot.skip(ftype)
14232 
      iprot.readFieldEnd()
14233 
    iprot.readStructEnd()
14234 
 
14235 
  def write(self, oprot):
14236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14238 
      return
14239 
    oprot.writeStructBegin('getCampaigns_result')
14240 
    if self.success is not None:
14241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14242 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14243 
      for iter252 in self.success:
14244 
        iter252.write(oprot)
8579 kshitij.so 14245 
      oprot.writeListEnd()
14246 
      oprot.writeFieldEnd()
14247 
    oprot.writeFieldStop()
14248 
    oprot.writeStructEnd()
14249 
 
14250 
  def validate(self):
14251 
    return
14252 
 
14253 
 
14254 
  def __repr__(self):
14255 
    L = ['%s=%r' % (key, value)
14256 
      for key, value in self.__dict__.iteritems()]
14257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14258 
 
14259 
  def __eq__(self, other):
14260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14261 
 
14262 
  def __ne__(self, other):
14263 
    return not (self == other)
14264 
 
14265 
class deleteCampaign_args:
14266 
  """
14267 
  Attributes:
14268 
   - campaignId
14269 
  """
14270 
 
14271 
  thrift_spec = (
14272 
    None, # 0
14273 
    (1, TType.I64, 'campaignId', None, None, ), # 1
14274 
  )
14275 
 
14276 
  def __init__(self, campaignId=None,):
14277 
    self.campaignId = campaignId
14278 
 
14279 
  def read(self, iprot):
14280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14282 
      return
14283 
    iprot.readStructBegin()
14284 
    while True:
14285 
      (fname, ftype, fid) = iprot.readFieldBegin()
14286 
      if ftype == TType.STOP:
14287 
        break
14288 
      if fid == 1:
14289 
        if ftype == TType.I64:
14290 
          self.campaignId = iprot.readI64();
14291 
        else:
14292 
          iprot.skip(ftype)
14293 
      else:
14294 
        iprot.skip(ftype)
14295 
      iprot.readFieldEnd()
14296 
    iprot.readStructEnd()
14297 
 
14298 
  def write(self, oprot):
14299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14301 
      return
14302 
    oprot.writeStructBegin('deleteCampaign_args')
14303 
    if self.campaignId is not None:
14304 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
14305 
      oprot.writeI64(self.campaignId)
14306 
      oprot.writeFieldEnd()
14307 
    oprot.writeFieldStop()
14308 
    oprot.writeStructEnd()
14309 
 
14310 
  def validate(self):
14311 
    return
14312 
 
14313 
 
14314 
  def __repr__(self):
14315 
    L = ['%s=%r' % (key, value)
14316 
      for key, value in self.__dict__.iteritems()]
14317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14318 
 
14319 
  def __eq__(self, other):
14320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14321 
 
14322 
  def __ne__(self, other):
14323 
    return not (self == other)
14324 
 
14325 
class deleteCampaign_result:
14326 
 
14327 
  thrift_spec = (
14328 
  )
14329 
 
14330 
  def read(self, iprot):
14331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14333 
      return
14334 
    iprot.readStructBegin()
14335 
    while True:
14336 
      (fname, ftype, fid) = iprot.readFieldBegin()
14337 
      if ftype == TType.STOP:
14338 
        break
14339 
      else:
14340 
        iprot.skip(ftype)
14341 
      iprot.readFieldEnd()
14342 
    iprot.readStructEnd()
14343 
 
14344 
  def write(self, oprot):
14345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14347 
      return
14348 
    oprot.writeStructBegin('deleteCampaign_result')
14349 
    oprot.writeFieldStop()
14350 
    oprot.writeStructEnd()
14351 
 
14352 
  def validate(self):
14353 
    return
14354 
 
14355 
 
14356 
  def __repr__(self):
14357 
    L = ['%s=%r' % (key, value)
14358 
      for key, value in self.__dict__.iteritems()]
14359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14360 
 
14361 
  def __eq__(self, other):
14362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14363 
 
14364 
  def __ne__(self, other):
14365 
    return not (self == other)
14366 
 
14367 
class getAllCampaigns_args:
14368 
 
14369 
  thrift_spec = (
14370 
  )
14371 
 
14372 
  def read(self, iprot):
14373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14375 
      return
14376 
    iprot.readStructBegin()
14377 
    while True:
14378 
      (fname, ftype, fid) = iprot.readFieldBegin()
14379 
      if ftype == TType.STOP:
14380 
        break
14381 
      else:
14382 
        iprot.skip(ftype)
14383 
      iprot.readFieldEnd()
14384 
    iprot.readStructEnd()
14385 
 
14386 
  def write(self, oprot):
14387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14389 
      return
14390 
    oprot.writeStructBegin('getAllCampaigns_args')
14391 
    oprot.writeFieldStop()
14392 
    oprot.writeStructEnd()
14393 
 
14394 
  def validate(self):
14395 
    return
14396 
 
14397 
 
14398 
  def __repr__(self):
14399 
    L = ['%s=%r' % (key, value)
14400 
      for key, value in self.__dict__.iteritems()]
14401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14402 
 
14403 
  def __eq__(self, other):
14404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14405 
 
14406 
  def __ne__(self, other):
14407 
    return not (self == other)
14408 
 
14409 
class getAllCampaigns_result:
14410 
  """
14411 
  Attributes:
14412 
   - success
14413 
  """
14414 
 
14415 
  thrift_spec = (
14416 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14417 
  )
14418 
 
14419 
  def __init__(self, success=None,):
14420 
    self.success = success
14421 
 
14422 
  def read(self, iprot):
14423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14425 
      return
14426 
    iprot.readStructBegin()
14427 
    while True:
14428 
      (fname, ftype, fid) = iprot.readFieldBegin()
14429 
      if ftype == TType.STOP:
14430 
        break
14431 
      if fid == 0:
14432 
        if ftype == TType.LIST:
14433 
          self.success = []
8590 kshitij.so 14434 
          (_etype256, _size253) = iprot.readListBegin()
14435 
          for _i257 in xrange(_size253):
14436 
            _elem258 = iprot.readString();
14437 
            self.success.append(_elem258)
8579 kshitij.so 14438 
          iprot.readListEnd()
14439 
        else:
14440 
          iprot.skip(ftype)
14441 
      else:
14442 
        iprot.skip(ftype)
14443 
      iprot.readFieldEnd()
14444 
    iprot.readStructEnd()
14445 
 
14446 
  def write(self, oprot):
14447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14449 
      return
14450 
    oprot.writeStructBegin('getAllCampaigns_result')
14451 
    if self.success is not None:
14452 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14453 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14454 
      for iter259 in self.success:
14455 
        oprot.writeString(iter259)
8579 kshitij.so 14456 
      oprot.writeListEnd()
14457 
      oprot.writeFieldEnd()
14458 
    oprot.writeFieldStop()
14459 
    oprot.writeStructEnd()
14460 
 
14461 
  def validate(self):
14462 
    return
14463 
 
14464 
 
14465 
  def __repr__(self):
14466 
    L = ['%s=%r' % (key, value)
14467 
      for key, value in self.__dict__.iteritems()]
14468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14469 
 
14470 
  def __eq__(self, other):
14471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14472 
 
14473 
  def __ne__(self, other):
14474 
    return not (self == other)
14475 
 
9155 kshitij.so 14476 
class getActiveBannersForMobileSite_args:
14477 
 
14478 
  thrift_spec = (
14479 
  )
14480 
 
14481 
  def read(self, iprot):
14482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14484 
      return
14485 
    iprot.readStructBegin()
14486 
    while True:
14487 
      (fname, ftype, fid) = iprot.readFieldBegin()
14488 
      if ftype == TType.STOP:
14489 
        break
14490 
      else:
14491 
        iprot.skip(ftype)
14492 
      iprot.readFieldEnd()
14493 
    iprot.readStructEnd()
14494 
 
14495 
  def write(self, oprot):
14496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14498 
      return
14499 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14500 
    oprot.writeFieldStop()
14501 
    oprot.writeStructEnd()
14502 
 
14503 
  def validate(self):
14504 
    return
14505 
 
14506 
 
14507 
  def __repr__(self):
14508 
    L = ['%s=%r' % (key, value)
14509 
      for key, value in self.__dict__.iteritems()]
14510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14511 
 
14512 
  def __eq__(self, other):
14513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14514 
 
14515 
  def __ne__(self, other):
14516 
    return not (self == other)
14517 
 
14518 
class getActiveBannersForMobileSite_result:
14519 
  """
14520 
  Attributes:
14521 
   - success
14522 
  """
14523 
 
14524 
  thrift_spec = (
14525 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14526 
  )
14527 
 
14528 
  def __init__(self, success=None,):
14529 
    self.success = success
14530 
 
14531 
  def read(self, iprot):
14532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14534 
      return
14535 
    iprot.readStructBegin()
14536 
    while True:
14537 
      (fname, ftype, fid) = iprot.readFieldBegin()
14538 
      if ftype == TType.STOP:
14539 
        break
14540 
      if fid == 0:
14541 
        if ftype == TType.MAP:
14542 
          self.success = {}
14543 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14544 
          for _i264 in xrange(_size260):
14545 
            _key265 = iprot.readString();
14546 
            _val266 = []
14547 
            (_etype270, _size267) = iprot.readListBegin()
14548 
            for _i271 in xrange(_size267):
14549 
              _elem272 = Banner()
14550 
              _elem272.read(iprot)
14551 
              _val266.append(_elem272)
14552 
            iprot.readListEnd()
14553 
            self.success[_key265] = _val266
14554 
          iprot.readMapEnd()
14555 
        else:
14556 
          iprot.skip(ftype)
14557 
      else:
14558 
        iprot.skip(ftype)
14559 
      iprot.readFieldEnd()
14560 
    iprot.readStructEnd()
14561 
 
14562 
  def write(self, oprot):
14563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14565 
      return
14566 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14567 
    if self.success is not None:
14568 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14569 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14570 
      for kiter273,viter274 in self.success.items():
14571 
        oprot.writeString(kiter273)
14572 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14573 
        for iter275 in viter274:
14574 
          iter275.write(oprot)
14575 
        oprot.writeListEnd()
14576 
      oprot.writeMapEnd()
14577 
      oprot.writeFieldEnd()
14578 
    oprot.writeFieldStop()
14579 
    oprot.writeStructEnd()
14580 
 
14581 
  def validate(self):
14582 
    return
14583 
 
14584 
 
14585 
  def __repr__(self):
14586 
    L = ['%s=%r' % (key, value)
14587 
      for key, value in self.__dict__.iteritems()]
14588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14589 
 
14590 
  def __eq__(self, other):
14591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14592 
 
14593 
  def __ne__(self, other):
14594 
    return not (self == other)
14595 
 
5944 mandeep.dh 14596 
class deleteSimilarItem_args:
14597 
  """
14598 
  Attributes:
14599 
   - itemId
14600 
   - catalogItemId
14601 
  """
14602 
 
14603 
  thrift_spec = (
14604 
    None, # 0
14605 
    (1, TType.I64, 'itemId', None, None, ), # 1
14606 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14607 
  )
14608 
 
14609 
  def __init__(self, itemId=None, catalogItemId=None,):
14610 
    self.itemId = itemId
14611 
    self.catalogItemId = catalogItemId
14612 
 
14613 
  def read(self, iprot):
14614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14616 
      return
14617 
    iprot.readStructBegin()
14618 
    while True:
14619 
      (fname, ftype, fid) = iprot.readFieldBegin()
14620 
      if ftype == TType.STOP:
14621 
        break
14622 
      if fid == 1:
14623 
        if ftype == TType.I64:
14624 
          self.itemId = iprot.readI64();
14625 
        else:
14626 
          iprot.skip(ftype)
14627 
      elif fid == 2:
14628 
        if ftype == TType.I64:
14629 
          self.catalogItemId = iprot.readI64();
14630 
        else:
14631 
          iprot.skip(ftype)
14632 
      else:
14633 
        iprot.skip(ftype)
14634 
      iprot.readFieldEnd()
14635 
    iprot.readStructEnd()
14636 
 
14637 
  def write(self, oprot):
14638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14640 
      return
14641 
    oprot.writeStructBegin('deleteSimilarItem_args')
14642 
    if self.itemId is not None:
14643 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14644 
      oprot.writeI64(self.itemId)
14645 
      oprot.writeFieldEnd()
14646 
    if self.catalogItemId is not None:
14647 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14648 
      oprot.writeI64(self.catalogItemId)
14649 
      oprot.writeFieldEnd()
14650 
    oprot.writeFieldStop()
14651 
    oprot.writeStructEnd()
14652 
 
14653 
  def validate(self):
14654 
    return
14655 
 
14656 
 
14657 
  def __repr__(self):
14658 
    L = ['%s=%r' % (key, value)
14659 
      for key, value in self.__dict__.iteritems()]
14660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14661 
 
14662 
  def __eq__(self, other):
14663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14664 
 
14665 
  def __ne__(self, other):
14666 
    return not (self == other)
14667 
 
14668 
class deleteSimilarItem_result:
14669 
  """
14670 
  Attributes:
14671 
   - success
14672 
   - cex
14673 
  """
14674 
 
14675 
  thrift_spec = (
14676 
    (0, TType.BOOL, 'success', None, None, ), # 0
14677 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14678 
  )
14679 
 
14680 
  def __init__(self, success=None, cex=None,):
14681 
    self.success = success
14682 
    self.cex = cex
14683 
 
14684 
  def read(self, iprot):
14685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14687 
      return
14688 
    iprot.readStructBegin()
14689 
    while True:
14690 
      (fname, ftype, fid) = iprot.readFieldBegin()
14691 
      if ftype == TType.STOP:
14692 
        break
14693 
      if fid == 0:
14694 
        if ftype == TType.BOOL:
14695 
          self.success = iprot.readBool();
14696 
        else:
14697 
          iprot.skip(ftype)
14698 
      elif fid == 1:
14699 
        if ftype == TType.STRUCT:
14700 
          self.cex = CatalogServiceException()
14701 
          self.cex.read(iprot)
14702 
        else:
14703 
          iprot.skip(ftype)
14704 
      else:
14705 
        iprot.skip(ftype)
14706 
      iprot.readFieldEnd()
14707 
    iprot.readStructEnd()
14708 
 
14709 
  def write(self, oprot):
14710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14712 
      return
14713 
    oprot.writeStructBegin('deleteSimilarItem_result')
14714 
    if self.success is not None:
14715 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14716 
      oprot.writeBool(self.success)
14717 
      oprot.writeFieldEnd()
14718 
    if self.cex is not None:
14719 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14720 
      self.cex.write(oprot)
14721 
      oprot.writeFieldEnd()
14722 
    oprot.writeFieldStop()
14723 
    oprot.writeStructEnd()
14724 
 
14725 
  def validate(self):
14726 
    return
14727 
 
14728 
 
14729 
  def __repr__(self):
14730 
    L = ['%s=%r' % (key, value)
14731 
      for key, value in self.__dict__.iteritems()]
14732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14733 
 
14734 
  def __eq__(self, other):
14735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14736 
 
14737 
  def __ne__(self, other):
14738 
    return not (self == other)
14739 
 
14740 
class checkSimilarItem_args:
14741 
  """
14742 
  Attributes:
14743 
   - brand
14744 
   - modelNumber
14745 
   - modelName
14746 
   - color
14747 
  """
14748 
 
14749 
  thrift_spec = (
14750 
    None, # 0
14751 
    (1, TType.STRING, 'brand', None, None, ), # 1
14752 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
14753 
    (3, TType.STRING, 'modelName', None, None, ), # 3
14754 
    (4, TType.STRING, 'color', None, None, ), # 4
14755 
  )
14756 
 
14757 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
14758 
    self.brand = brand
14759 
    self.modelNumber = modelNumber
14760 
    self.modelName = modelName
14761 
    self.color = color
14762 
 
14763 
  def read(self, iprot):
14764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14766 
      return
14767 
    iprot.readStructBegin()
14768 
    while True:
14769 
      (fname, ftype, fid) = iprot.readFieldBegin()
14770 
      if ftype == TType.STOP:
14771 
        break
14772 
      if fid == 1:
14773 
        if ftype == TType.STRING:
14774 
          self.brand = iprot.readString();
14775 
        else:
14776 
          iprot.skip(ftype)
14777 
      elif fid == 2:
14778 
        if ftype == TType.STRING:
14779 
          self.modelNumber = iprot.readString();
14780 
        else:
14781 
          iprot.skip(ftype)
14782 
      elif fid == 3:
14783 
        if ftype == TType.STRING:
14784 
          self.modelName = iprot.readString();
14785 
        else:
14786 
          iprot.skip(ftype)
14787 
      elif fid == 4:
14788 
        if ftype == TType.STRING:
14789 
          self.color = iprot.readString();
14790 
        else:
14791 
          iprot.skip(ftype)
14792 
      else:
14793 
        iprot.skip(ftype)
14794 
      iprot.readFieldEnd()
14795 
    iprot.readStructEnd()
14796 
 
14797 
  def write(self, oprot):
14798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14800 
      return
14801 
    oprot.writeStructBegin('checkSimilarItem_args')
14802 
    if self.brand is not None:
14803 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
14804 
      oprot.writeString(self.brand)
14805 
      oprot.writeFieldEnd()
14806 
    if self.modelNumber is not None:
14807 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
14808 
      oprot.writeString(self.modelNumber)
14809 
      oprot.writeFieldEnd()
14810 
    if self.modelName is not None:
14811 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
14812 
      oprot.writeString(self.modelName)
14813 
      oprot.writeFieldEnd()
14814 
    if self.color is not None:
14815 
      oprot.writeFieldBegin('color', TType.STRING, 4)
14816 
      oprot.writeString(self.color)
14817 
      oprot.writeFieldEnd()
14818 
    oprot.writeFieldStop()
14819 
    oprot.writeStructEnd()
14820 
 
14821 
  def validate(self):
14822 
    return
14823 
 
14824 
 
14825 
  def __repr__(self):
14826 
    L = ['%s=%r' % (key, value)
14827 
      for key, value in self.__dict__.iteritems()]
14828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14829 
 
14830 
  def __eq__(self, other):
14831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14832 
 
14833 
  def __ne__(self, other):
14834 
    return not (self == other)
14835 
 
14836 
class checkSimilarItem_result:
14837 
  """
14838 
  Attributes:
14839 
   - success
14840 
  """
14841 
 
14842 
  thrift_spec = (
14843 
    (0, TType.I64, 'success', None, None, ), # 0
14844 
  )
14845 
 
14846 
  def __init__(self, success=None,):
14847 
    self.success = success
14848 
 
14849 
  def read(self, iprot):
14850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14852 
      return
14853 
    iprot.readStructBegin()
14854 
    while True:
14855 
      (fname, ftype, fid) = iprot.readFieldBegin()
14856 
      if ftype == TType.STOP:
14857 
        break
14858 
      if fid == 0:
14859 
        if ftype == TType.I64:
14860 
          self.success = iprot.readI64();
14861 
        else:
14862 
          iprot.skip(ftype)
14863 
      else:
14864 
        iprot.skip(ftype)
14865 
      iprot.readFieldEnd()
14866 
    iprot.readStructEnd()
14867 
 
14868 
  def write(self, oprot):
14869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14871 
      return
14872 
    oprot.writeStructBegin('checkSimilarItem_result')
14873 
    if self.success is not None:
14874 
      oprot.writeFieldBegin('success', TType.I64, 0)
14875 
      oprot.writeI64(self.success)
14876 
      oprot.writeFieldEnd()
14877 
    oprot.writeFieldStop()
14878 
    oprot.writeStructEnd()
14879 
 
14880 
  def validate(self):
14881 
    return
14882 
 
14883 
 
14884 
  def __repr__(self):
14885 
    L = ['%s=%r' % (key, value)
14886 
      for key, value in self.__dict__.iteritems()]
14887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14888 
 
14889 
  def __eq__(self, other):
14890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14891 
 
14892 
  def __ne__(self, other):
14893 
    return not (self == other)
14894 
 
14895 
class validateRiskyStatus_args:
14896 
  """
14897 
  Attributes:
14898 
   - itemId
14899 
  """
14900 
 
14901 
  thrift_spec = (
14902 
    None, # 0
14903 
    (1, TType.I64, 'itemId', None, None, ), # 1
14904 
  )
14905 
 
14906 
  def __init__(self, itemId=None,):
14907 
    self.itemId = itemId
14908 
 
14909 
  def read(self, iprot):
14910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14912 
      return
14913 
    iprot.readStructBegin()
14914 
    while True:
14915 
      (fname, ftype, fid) = iprot.readFieldBegin()
14916 
      if ftype == TType.STOP:
14917 
        break
14918 
      if fid == 1:
14919 
        if ftype == TType.I64:
14920 
          self.itemId = iprot.readI64();
14921 
        else:
14922 
          iprot.skip(ftype)
14923 
      else:
14924 
        iprot.skip(ftype)
14925 
      iprot.readFieldEnd()
14926 
    iprot.readStructEnd()
14927 
 
14928 
  def write(self, oprot):
14929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14931 
      return
14932 
    oprot.writeStructBegin('validateRiskyStatus_args')
14933 
    if self.itemId is not None:
14934 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14935 
      oprot.writeI64(self.itemId)
14936 
      oprot.writeFieldEnd()
14937 
    oprot.writeFieldStop()
14938 
    oprot.writeStructEnd()
14939 
 
14940 
  def validate(self):
14941 
    return
14942 
 
14943 
 
14944 
  def __repr__(self):
14945 
    L = ['%s=%r' % (key, value)
14946 
      for key, value in self.__dict__.iteritems()]
14947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14948 
 
14949 
  def __eq__(self, other):
14950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14951 
 
14952 
  def __ne__(self, other):
14953 
    return not (self == other)
14954 
 
14955 
class validateRiskyStatus_result:
14956 
 
14957 
  thrift_spec = (
14958 
  )
14959 
 
14960 
  def read(self, iprot):
14961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14963 
      return
14964 
    iprot.readStructBegin()
14965 
    while True:
14966 
      (fname, ftype, fid) = iprot.readFieldBegin()
14967 
      if ftype == TType.STOP:
14968 
        break
14969 
      else:
14970 
        iprot.skip(ftype)
14971 
      iprot.readFieldEnd()
14972 
    iprot.readStructEnd()
14973 
 
14974 
  def write(self, oprot):
14975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14977 
      return
14978 
    oprot.writeStructBegin('validateRiskyStatus_result')
14979 
    oprot.writeFieldStop()
14980 
    oprot.writeStructEnd()
14981 
 
14982 
  def validate(self):
14983 
    return
14984 
 
14985 
 
14986 
  def __repr__(self):
14987 
    L = ['%s=%r' % (key, value)
14988 
      for key, value in self.__dict__.iteritems()]
14989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14990 
 
14991 
  def __eq__(self, other):
14992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14993 
 
14994 
  def __ne__(self, other):
14995 
    return not (self == other)
14996 
 
14997 
class changeItemRiskyFlag_args:
14998 
  """
14999 
  Attributes:
15000 
   - itemId
15001 
   - risky
15002 
  """
15003 
 
15004 
  thrift_spec = (
15005 
    None, # 0
15006 
    (1, TType.I64, 'itemId', None, None, ), # 1
15007 
    (2, TType.BOOL, 'risky', None, None, ), # 2
15008 
  )
15009 
 
15010 
  def __init__(self, itemId=None, risky=None,):
15011 
    self.itemId = itemId
15012 
    self.risky = risky
15013 
 
15014 
  def read(self, iprot):
15015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15017 
      return
15018 
    iprot.readStructBegin()
15019 
    while True:
15020 
      (fname, ftype, fid) = iprot.readFieldBegin()
15021 
      if ftype == TType.STOP:
15022 
        break
15023 
      if fid == 1:
15024 
        if ftype == TType.I64:
15025 
          self.itemId = iprot.readI64();
15026 
        else:
15027 
          iprot.skip(ftype)
15028 
      elif fid == 2:
15029 
        if ftype == TType.BOOL:
15030 
          self.risky = iprot.readBool();
15031 
        else:
15032 
          iprot.skip(ftype)
15033 
      else:
15034 
        iprot.skip(ftype)
15035 
      iprot.readFieldEnd()
15036 
    iprot.readStructEnd()
15037 
 
15038 
  def write(self, oprot):
15039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15041 
      return
15042 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
15043 
    if self.itemId is not None:
15044 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15045 
      oprot.writeI64(self.itemId)
15046 
      oprot.writeFieldEnd()
15047 
    if self.risky is not None:
15048 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
15049 
      oprot.writeBool(self.risky)
15050 
      oprot.writeFieldEnd()
15051 
    oprot.writeFieldStop()
15052 
    oprot.writeStructEnd()
15053 
 
15054 
  def validate(self):
15055 
    return
15056 
 
15057 
 
15058 
  def __repr__(self):
15059 
    L = ['%s=%r' % (key, value)
15060 
      for key, value in self.__dict__.iteritems()]
15061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15062 
 
15063 
  def __eq__(self, other):
15064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15065 
 
15066 
  def __ne__(self, other):
15067 
    return not (self == other)
15068 
 
15069 
class changeItemRiskyFlag_result:
15070 
 
15071 
  thrift_spec = (
15072 
  )
15073 
 
15074 
  def read(self, iprot):
15075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15077 
      return
15078 
    iprot.readStructBegin()
15079 
    while True:
15080 
      (fname, ftype, fid) = iprot.readFieldBegin()
15081 
      if ftype == TType.STOP:
15082 
        break
15083 
      else:
15084 
        iprot.skip(ftype)
15085 
      iprot.readFieldEnd()
15086 
    iprot.readStructEnd()
15087 
 
15088 
  def write(self, oprot):
15089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15091 
      return
15092 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
15093 
    oprot.writeFieldStop()
15094 
    oprot.writeStructEnd()
15095 
 
15096 
  def validate(self):
15097 
    return
15098 
 
15099 
 
15100 
  def __repr__(self):
15101 
    L = ['%s=%r' % (key, value)
15102 
      for key, value in self.__dict__.iteritems()]
15103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15104 
 
15105 
  def __eq__(self, other):
15106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15107 
 
15108 
  def __ne__(self, other):
15109 
    return not (self == other)
15110 
 
15111 
class getItemsByRiskyFlag_args:
15112 
 
15113 
  thrift_spec = (
15114 
  )
15115 
 
15116 
  def read(self, iprot):
15117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15119 
      return
15120 
    iprot.readStructBegin()
15121 
    while True:
15122 
      (fname, ftype, fid) = iprot.readFieldBegin()
15123 
      if ftype == TType.STOP:
15124 
        break
15125 
      else:
15126 
        iprot.skip(ftype)
15127 
      iprot.readFieldEnd()
15128 
    iprot.readStructEnd()
15129 
 
15130 
  def write(self, oprot):
15131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15133 
      return
15134 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
15135 
    oprot.writeFieldStop()
15136 
    oprot.writeStructEnd()
15137 
 
15138 
  def validate(self):
15139 
    return
15140 
 
15141 
 
15142 
  def __repr__(self):
15143 
    L = ['%s=%r' % (key, value)
15144 
      for key, value in self.__dict__.iteritems()]
15145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15146 
 
15147 
  def __eq__(self, other):
15148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15149 
 
15150 
  def __ne__(self, other):
15151 
    return not (self == other)
15152 
 
15153 
class getItemsByRiskyFlag_result:
15154 
  """
15155 
  Attributes:
15156 
   - success
15157 
  """
15158 
 
15159 
  thrift_spec = (
15160 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15161 
  )
15162 
 
15163 
  def __init__(self, success=None,):
15164 
    self.success = success
15165 
 
15166 
  def read(self, iprot):
15167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15169 
      return
15170 
    iprot.readStructBegin()
15171 
    while True:
15172 
      (fname, ftype, fid) = iprot.readFieldBegin()
15173 
      if ftype == TType.STOP:
15174 
        break
15175 
      if fid == 0:
15176 
        if ftype == TType.LIST:
15177 
          self.success = []
9155 kshitij.so 15178 
          (_etype279, _size276) = iprot.readListBegin()
15179 
          for _i280 in xrange(_size276):
15180 
            _elem281 = Item()
15181 
            _elem281.read(iprot)
15182 
            self.success.append(_elem281)
5944 mandeep.dh 15183 
          iprot.readListEnd()
15184 
        else:
15185 
          iprot.skip(ftype)
15186 
      else:
15187 
        iprot.skip(ftype)
15188 
      iprot.readFieldEnd()
15189 
    iprot.readStructEnd()
15190 
 
15191 
  def write(self, oprot):
15192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15194 
      return
15195 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
15196 
    if self.success is not None:
15197 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15198 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15199 
      for iter282 in self.success:
15200 
        iter282.write(oprot)
5944 mandeep.dh 15201 
      oprot.writeListEnd()
15202 
      oprot.writeFieldEnd()
15203 
    oprot.writeFieldStop()
15204 
    oprot.writeStructEnd()
15205 
 
15206 
  def validate(self):
15207 
    return
15208 
 
15209 
 
15210 
  def __repr__(self):
15211 
    L = ['%s=%r' % (key, value)
15212 
      for key, value in self.__dict__.iteritems()]
15213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15214 
 
15215 
  def __eq__(self, other):
15216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15217 
 
15218 
  def __ne__(self, other):
15219 
    return not (self == other)
15220 
 
15221 
class getItemsForMasterSheet_args:
15222 
  """
15223 
  Attributes:
15224 
   - category
15225 
   - brand
15226 
  """
15227 
 
15228 
  thrift_spec = (
15229 
    None, # 0
15230 
    (1, TType.STRING, 'category', None, None, ), # 1
15231 
    (2, TType.STRING, 'brand', None, None, ), # 2
15232 
  )
15233 
 
15234 
  def __init__(self, category=None, brand=None,):
15235 
    self.category = category
15236 
    self.brand = brand
15237 
 
15238 
  def read(self, iprot):
15239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15241 
      return
15242 
    iprot.readStructBegin()
15243 
    while True:
15244 
      (fname, ftype, fid) = iprot.readFieldBegin()
15245 
      if ftype == TType.STOP:
15246 
        break
15247 
      if fid == 1:
15248 
        if ftype == TType.STRING:
15249 
          self.category = iprot.readString();
15250 
        else:
15251 
          iprot.skip(ftype)
15252 
      elif fid == 2:
15253 
        if ftype == TType.STRING:
15254 
          self.brand = iprot.readString();
15255 
        else:
15256 
          iprot.skip(ftype)
15257 
      else:
15258 
        iprot.skip(ftype)
15259 
      iprot.readFieldEnd()
15260 
    iprot.readStructEnd()
15261 
 
15262 
  def write(self, oprot):
15263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15265 
      return
15266 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
15267 
    if self.category is not None:
15268 
      oprot.writeFieldBegin('category', TType.STRING, 1)
15269 
      oprot.writeString(self.category)
15270 
      oprot.writeFieldEnd()
15271 
    if self.brand is not None:
15272 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
15273 
      oprot.writeString(self.brand)
15274 
      oprot.writeFieldEnd()
15275 
    oprot.writeFieldStop()
15276 
    oprot.writeStructEnd()
15277 
 
15278 
  def validate(self):
15279 
    return
15280 
 
15281 
 
15282 
  def __repr__(self):
15283 
    L = ['%s=%r' % (key, value)
15284 
      for key, value in self.__dict__.iteritems()]
15285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15286 
 
15287 
  def __eq__(self, other):
15288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15289 
 
15290 
  def __ne__(self, other):
15291 
    return not (self == other)
15292 
 
15293 
class getItemsForMasterSheet_result:
15294 
  """
15295 
  Attributes:
15296 
   - success
15297 
  """
15298 
 
15299 
  thrift_spec = (
15300 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15301 
  )
15302 
 
15303 
  def __init__(self, success=None,):
15304 
    self.success = success
15305 
 
15306 
  def read(self, iprot):
15307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15309 
      return
15310 
    iprot.readStructBegin()
15311 
    while True:
15312 
      (fname, ftype, fid) = iprot.readFieldBegin()
15313 
      if ftype == TType.STOP:
15314 
        break
15315 
      if fid == 0:
15316 
        if ftype == TType.LIST:
15317 
          self.success = []
9155 kshitij.so 15318 
          (_etype286, _size283) = iprot.readListBegin()
15319 
          for _i287 in xrange(_size283):
15320 
            _elem288 = Item()
15321 
            _elem288.read(iprot)
15322 
            self.success.append(_elem288)
5944 mandeep.dh 15323 
          iprot.readListEnd()
15324 
        else:
15325 
          iprot.skip(ftype)
15326 
      else:
15327 
        iprot.skip(ftype)
15328 
      iprot.readFieldEnd()
15329 
    iprot.readStructEnd()
15330 
 
15331 
  def write(self, oprot):
15332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15334 
      return
15335 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
15336 
    if self.success is not None:
15337 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15338 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15339 
      for iter289 in self.success:
15340 
        iter289.write(oprot)
5944 mandeep.dh 15341 
      oprot.writeListEnd()
15342 
      oprot.writeFieldEnd()
15343 
    oprot.writeFieldStop()
15344 
    oprot.writeStructEnd()
15345 
 
15346 
  def validate(self):
15347 
    return
15348 
 
15349 
 
15350 
  def __repr__(self):
15351 
    L = ['%s=%r' % (key, value)
15352 
      for key, value in self.__dict__.iteritems()]
15353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15354 
 
15355 
  def __eq__(self, other):
15356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15357 
 
15358 
  def __ne__(self, other):
15359 
    return not (self == other)
15360 
 
15361 
class getSimilarItemsCatalogIds_args:
15362 
  """
15363 
  Attributes:
15364 
   - beginIndex
15365 
   - totalItems
15366 
   - itemId
15367 
  """
15368 
 
15369 
  thrift_spec = (
15370 
    None, # 0
15371 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15372 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15373 
    (3, TType.I64, 'itemId', None, None, ), # 3
15374 
  )
15375 
 
15376 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15377 
    self.beginIndex = beginIndex
15378 
    self.totalItems = totalItems
15379 
    self.itemId = itemId
15380 
 
15381 
  def read(self, iprot):
15382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15384 
      return
15385 
    iprot.readStructBegin()
15386 
    while True:
15387 
      (fname, ftype, fid) = iprot.readFieldBegin()
15388 
      if ftype == TType.STOP:
15389 
        break
15390 
      if fid == 1:
15391 
        if ftype == TType.I64:
15392 
          self.beginIndex = iprot.readI64();
15393 
        else:
15394 
          iprot.skip(ftype)
15395 
      elif fid == 2:
15396 
        if ftype == TType.I64:
15397 
          self.totalItems = iprot.readI64();
15398 
        else:
15399 
          iprot.skip(ftype)
15400 
      elif fid == 3:
15401 
        if ftype == TType.I64:
15402 
          self.itemId = iprot.readI64();
15403 
        else:
15404 
          iprot.skip(ftype)
15405 
      else:
15406 
        iprot.skip(ftype)
15407 
      iprot.readFieldEnd()
15408 
    iprot.readStructEnd()
15409 
 
15410 
  def write(self, oprot):
15411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15413 
      return
15414 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15415 
    if self.beginIndex is not None:
15416 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15417 
      oprot.writeI64(self.beginIndex)
15418 
      oprot.writeFieldEnd()
15419 
    if self.totalItems is not None:
15420 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15421 
      oprot.writeI64(self.totalItems)
15422 
      oprot.writeFieldEnd()
15423 
    if self.itemId is not None:
15424 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15425 
      oprot.writeI64(self.itemId)
15426 
      oprot.writeFieldEnd()
15427 
    oprot.writeFieldStop()
15428 
    oprot.writeStructEnd()
15429 
 
15430 
  def validate(self):
15431 
    return
15432 
 
15433 
 
15434 
  def __repr__(self):
15435 
    L = ['%s=%r' % (key, value)
15436 
      for key, value in self.__dict__.iteritems()]
15437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15438 
 
15439 
  def __eq__(self, other):
15440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15441 
 
15442 
  def __ne__(self, other):
15443 
    return not (self == other)
15444 
 
15445 
class getSimilarItemsCatalogIds_result:
15446 
  """
15447 
  Attributes:
15448 
   - success
15449 
  """
15450 
 
15451 
  thrift_spec = (
15452 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15453 
  )
15454 
 
15455 
  def __init__(self, success=None,):
15456 
    self.success = success
15457 
 
15458 
  def read(self, iprot):
15459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15461 
      return
15462 
    iprot.readStructBegin()
15463 
    while True:
15464 
      (fname, ftype, fid) = iprot.readFieldBegin()
15465 
      if ftype == TType.STOP:
15466 
        break
15467 
      if fid == 0:
15468 
        if ftype == TType.LIST:
15469 
          self.success = []
9155 kshitij.so 15470 
          (_etype293, _size290) = iprot.readListBegin()
15471 
          for _i294 in xrange(_size290):
15472 
            _elem295 = iprot.readI64();
15473 
            self.success.append(_elem295)
5944 mandeep.dh 15474 
          iprot.readListEnd()
15475 
        else:
15476 
          iprot.skip(ftype)
15477 
      else:
15478 
        iprot.skip(ftype)
15479 
      iprot.readFieldEnd()
15480 
    iprot.readStructEnd()
15481 
 
15482 
  def write(self, oprot):
15483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15485 
      return
15486 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15487 
    if self.success is not None:
15488 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15489 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15490 
      for iter296 in self.success:
15491 
        oprot.writeI64(iter296)
5944 mandeep.dh 15492 
      oprot.writeListEnd()
15493 
      oprot.writeFieldEnd()
15494 
    oprot.writeFieldStop()
15495 
    oprot.writeStructEnd()
15496 
 
15497 
  def validate(self):
15498 
    return
15499 
 
15500 
 
15501 
  def __repr__(self):
15502 
    L = ['%s=%r' % (key, value)
15503 
      for key, value in self.__dict__.iteritems()]
15504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15505 
 
15506 
  def __eq__(self, other):
15507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15508 
 
15509 
  def __ne__(self, other):
15510 
    return not (self == other)
15511 
 
15512 
class addProductNotification_args:
15513 
  """
15514 
  Attributes:
15515 
   - itemId
15516 
   - email
15517 
  """
15518 
 
15519 
  thrift_spec = None
15520 
  def __init__(self, itemId=None, email=None,):
15521 
    self.itemId = itemId
15522 
    self.email = email
15523 
 
15524 
  def read(self, iprot):
15525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15527 
      return
15528 
    iprot.readStructBegin()
15529 
    while True:
15530 
      (fname, ftype, fid) = iprot.readFieldBegin()
15531 
      if ftype == TType.STOP:
15532 
        break
15533 
      if fid == -1:
15534 
        if ftype == TType.I64:
15535 
          self.itemId = iprot.readI64();
15536 
        else:
15537 
          iprot.skip(ftype)
15538 
      elif fid == -2:
15539 
        if ftype == TType.STRING:
15540 
          self.email = iprot.readString();
15541 
        else:
15542 
          iprot.skip(ftype)
15543 
      else:
15544 
        iprot.skip(ftype)
15545 
      iprot.readFieldEnd()
15546 
    iprot.readStructEnd()
15547 
 
15548 
  def write(self, oprot):
15549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15551 
      return
15552 
    oprot.writeStructBegin('addProductNotification_args')
15553 
    if self.email is not None:
15554 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15555 
      oprot.writeString(self.email)
15556 
      oprot.writeFieldEnd()
15557 
    if self.itemId is not None:
15558 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15559 
      oprot.writeI64(self.itemId)
15560 
      oprot.writeFieldEnd()
15561 
    oprot.writeFieldStop()
15562 
    oprot.writeStructEnd()
15563 
 
15564 
  def validate(self):
15565 
    return
15566 
 
15567 
 
15568 
  def __repr__(self):
15569 
    L = ['%s=%r' % (key, value)
15570 
      for key, value in self.__dict__.iteritems()]
15571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15572 
 
15573 
  def __eq__(self, other):
15574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15575 
 
15576 
  def __ne__(self, other):
15577 
    return not (self == other)
15578 
 
15579 
class addProductNotification_result:
15580 
  """
15581 
  Attributes:
15582 
   - success
15583 
  """
15584 
 
15585 
  thrift_spec = (
15586 
    (0, TType.BOOL, 'success', None, None, ), # 0
15587 
  )
15588 
 
15589 
  def __init__(self, success=None,):
15590 
    self.success = success
15591 
 
15592 
  def read(self, iprot):
15593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15595 
      return
15596 
    iprot.readStructBegin()
15597 
    while True:
15598 
      (fname, ftype, fid) = iprot.readFieldBegin()
15599 
      if ftype == TType.STOP:
15600 
        break
15601 
      if fid == 0:
15602 
        if ftype == TType.BOOL:
15603 
          self.success = iprot.readBool();
15604 
        else:
15605 
          iprot.skip(ftype)
15606 
      else:
15607 
        iprot.skip(ftype)
15608 
      iprot.readFieldEnd()
15609 
    iprot.readStructEnd()
15610 
 
15611 
  def write(self, oprot):
15612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15614 
      return
15615 
    oprot.writeStructBegin('addProductNotification_result')
15616 
    if self.success is not None:
15617 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15618 
      oprot.writeBool(self.success)
15619 
      oprot.writeFieldEnd()
15620 
    oprot.writeFieldStop()
15621 
    oprot.writeStructEnd()
15622 
 
15623 
  def validate(self):
15624 
    return
15625 
 
15626 
 
15627 
  def __repr__(self):
15628 
    L = ['%s=%r' % (key, value)
15629 
      for key, value in self.__dict__.iteritems()]
15630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15631 
 
15632 
  def __eq__(self, other):
15633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15634 
 
15635 
  def __ne__(self, other):
15636 
    return not (self == other)
15637 
 
15638 
class sendProductNotifications_args:
15639 
 
15640 
  thrift_spec = (
15641 
  )
15642 
 
15643 
  def read(self, iprot):
15644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15646 
      return
15647 
    iprot.readStructBegin()
15648 
    while True:
15649 
      (fname, ftype, fid) = iprot.readFieldBegin()
15650 
      if ftype == TType.STOP:
15651 
        break
15652 
      else:
15653 
        iprot.skip(ftype)
15654 
      iprot.readFieldEnd()
15655 
    iprot.readStructEnd()
15656 
 
15657 
  def write(self, oprot):
15658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15660 
      return
15661 
    oprot.writeStructBegin('sendProductNotifications_args')
15662 
    oprot.writeFieldStop()
15663 
    oprot.writeStructEnd()
15664 
 
15665 
  def validate(self):
15666 
    return
15667 
 
15668 
 
15669 
  def __repr__(self):
15670 
    L = ['%s=%r' % (key, value)
15671 
      for key, value in self.__dict__.iteritems()]
15672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15673 
 
15674 
  def __eq__(self, other):
15675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15676 
 
15677 
  def __ne__(self, other):
15678 
    return not (self == other)
15679 
 
15680 
class sendProductNotifications_result:
15681 
  """
15682 
  Attributes:
15683 
   - success
15684 
  """
15685 
 
15686 
  thrift_spec = (
15687 
    (0, TType.BOOL, 'success', None, None, ), # 0
15688 
  )
15689 
 
15690 
  def __init__(self, success=None,):
15691 
    self.success = success
15692 
 
15693 
  def read(self, iprot):
15694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15696 
      return
15697 
    iprot.readStructBegin()
15698 
    while True:
15699 
      (fname, ftype, fid) = iprot.readFieldBegin()
15700 
      if ftype == TType.STOP:
15701 
        break
15702 
      if fid == 0:
15703 
        if ftype == TType.BOOL:
15704 
          self.success = iprot.readBool();
15705 
        else:
15706 
          iprot.skip(ftype)
15707 
      else:
15708 
        iprot.skip(ftype)
15709 
      iprot.readFieldEnd()
15710 
    iprot.readStructEnd()
15711 
 
15712 
  def write(self, oprot):
15713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15715 
      return
15716 
    oprot.writeStructBegin('sendProductNotifications_result')
15717 
    if self.success is not None:
15718 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15719 
      oprot.writeBool(self.success)
15720 
      oprot.writeFieldEnd()
15721 
    oprot.writeFieldStop()
15722 
    oprot.writeStructEnd()
15723 
 
15724 
  def validate(self):
15725 
    return
15726 
 
15727 
 
15728 
  def __repr__(self):
15729 
    L = ['%s=%r' % (key, value)
15730 
      for key, value in self.__dict__.iteritems()]
15731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15732 
 
15733 
  def __eq__(self, other):
15734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15735 
 
15736 
  def __ne__(self, other):
15737 
    return not (self == other)
15738 
 
15739 
class getAllBrandsByCategory_args:
15740 
  """
15741 
  Attributes:
15742 
   - categoryId
15743 
  """
15744 
 
15745 
  thrift_spec = (
15746 
    None, # 0
15747 
    (1, TType.I64, 'categoryId', None, None, ), # 1
15748 
  )
15749 
 
15750 
  def __init__(self, categoryId=None,):
15751 
    self.categoryId = categoryId
15752 
 
15753 
  def read(self, iprot):
15754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15756 
      return
15757 
    iprot.readStructBegin()
15758 
    while True:
15759 
      (fname, ftype, fid) = iprot.readFieldBegin()
15760 
      if ftype == TType.STOP:
15761 
        break
15762 
      if fid == 1:
15763 
        if ftype == TType.I64:
15764 
          self.categoryId = iprot.readI64();
15765 
        else:
15766 
          iprot.skip(ftype)
15767 
      else:
15768 
        iprot.skip(ftype)
15769 
      iprot.readFieldEnd()
15770 
    iprot.readStructEnd()
15771 
 
15772 
  def write(self, oprot):
15773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15775 
      return
15776 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
15777 
    if self.categoryId is not None:
15778 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
15779 
      oprot.writeI64(self.categoryId)
15780 
      oprot.writeFieldEnd()
15781 
    oprot.writeFieldStop()
15782 
    oprot.writeStructEnd()
15783 
 
15784 
  def validate(self):
15785 
    return
15786 
 
15787 
 
15788 
  def __repr__(self):
15789 
    L = ['%s=%r' % (key, value)
15790 
      for key, value in self.__dict__.iteritems()]
15791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15792 
 
15793 
  def __eq__(self, other):
15794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15795 
 
15796 
  def __ne__(self, other):
15797 
    return not (self == other)
15798 
 
15799 
class getAllBrandsByCategory_result:
15800 
  """
15801 
  Attributes:
15802 
   - success
15803 
  """
15804 
 
15805 
  thrift_spec = (
15806 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15807 
  )
15808 
 
15809 
  def __init__(self, success=None,):
15810 
    self.success = success
15811 
 
15812 
  def read(self, iprot):
15813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15815 
      return
15816 
    iprot.readStructBegin()
15817 
    while True:
15818 
      (fname, ftype, fid) = iprot.readFieldBegin()
15819 
      if ftype == TType.STOP:
15820 
        break
15821 
      if fid == 0:
15822 
        if ftype == TType.LIST:
15823 
          self.success = []
9155 kshitij.so 15824 
          (_etype300, _size297) = iprot.readListBegin()
15825 
          for _i301 in xrange(_size297):
15826 
            _elem302 = iprot.readString();
15827 
            self.success.append(_elem302)
5944 mandeep.dh 15828 
          iprot.readListEnd()
15829 
        else:
15830 
          iprot.skip(ftype)
15831 
      else:
15832 
        iprot.skip(ftype)
15833 
      iprot.readFieldEnd()
15834 
    iprot.readStructEnd()
15835 
 
15836 
  def write(self, oprot):
15837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15839 
      return
15840 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
15841 
    if self.success is not None:
15842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15843 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15844 
      for iter303 in self.success:
15845 
        oprot.writeString(iter303)
5944 mandeep.dh 15846 
      oprot.writeListEnd()
15847 
      oprot.writeFieldEnd()
15848 
    oprot.writeFieldStop()
15849 
    oprot.writeStructEnd()
15850 
 
15851 
  def validate(self):
15852 
    return
15853 
 
15854 
 
15855 
  def __repr__(self):
15856 
    L = ['%s=%r' % (key, value)
15857 
      for key, value in self.__dict__.iteritems()]
15858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15859 
 
15860 
  def __eq__(self, other):
15861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15862 
 
15863 
  def __ne__(self, other):
15864 
    return not (self == other)
15865 
 
15866 
class getAllBrands_args:
15867 
 
15868 
  thrift_spec = (
15869 
  )
15870 
 
15871 
  def read(self, iprot):
15872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15874 
      return
15875 
    iprot.readStructBegin()
15876 
    while True:
15877 
      (fname, ftype, fid) = iprot.readFieldBegin()
15878 
      if ftype == TType.STOP:
15879 
        break
15880 
      else:
15881 
        iprot.skip(ftype)
15882 
      iprot.readFieldEnd()
15883 
    iprot.readStructEnd()
15884 
 
15885 
  def write(self, oprot):
15886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15888 
      return
15889 
    oprot.writeStructBegin('getAllBrands_args')
15890 
    oprot.writeFieldStop()
15891 
    oprot.writeStructEnd()
15892 
 
15893 
  def validate(self):
15894 
    return
15895 
 
15896 
 
15897 
  def __repr__(self):
15898 
    L = ['%s=%r' % (key, value)
15899 
      for key, value in self.__dict__.iteritems()]
15900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15901 
 
15902 
  def __eq__(self, other):
15903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15904 
 
15905 
  def __ne__(self, other):
15906 
    return not (self == other)
15907 
 
15908 
class getAllBrands_result:
15909 
  """
15910 
  Attributes:
15911 
   - success
15912 
  """
15913 
 
15914 
  thrift_spec = (
15915 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15916 
  )
15917 
 
15918 
  def __init__(self, success=None,):
15919 
    self.success = success
15920 
 
15921 
  def read(self, iprot):
15922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15924 
      return
15925 
    iprot.readStructBegin()
15926 
    while True:
15927 
      (fname, ftype, fid) = iprot.readFieldBegin()
15928 
      if ftype == TType.STOP:
15929 
        break
15930 
      if fid == 0:
15931 
        if ftype == TType.LIST:
15932 
          self.success = []
9155 kshitij.so 15933 
          (_etype307, _size304) = iprot.readListBegin()
15934 
          for _i308 in xrange(_size304):
15935 
            _elem309 = iprot.readString();
15936 
            self.success.append(_elem309)
5944 mandeep.dh 15937 
          iprot.readListEnd()
15938 
        else:
15939 
          iprot.skip(ftype)
15940 
      else:
15941 
        iprot.skip(ftype)
15942 
      iprot.readFieldEnd()
15943 
    iprot.readStructEnd()
15944 
 
15945 
  def write(self, oprot):
15946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15948 
      return
15949 
    oprot.writeStructBegin('getAllBrands_result')
15950 
    if self.success is not None:
15951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15952 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15953 
      for iter310 in self.success:
15954 
        oprot.writeString(iter310)
5944 mandeep.dh 15955 
      oprot.writeListEnd()
15956 
      oprot.writeFieldEnd()
15957 
    oprot.writeFieldStop()
15958 
    oprot.writeStructEnd()
15959 
 
15960 
  def validate(self):
15961 
    return
15962 
 
15963 
 
15964 
  def __repr__(self):
15965 
    L = ['%s=%r' % (key, value)
15966 
      for key, value in self.__dict__.iteritems()]
15967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15968 
 
15969 
  def __eq__(self, other):
15970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15971 
 
15972 
  def __ne__(self, other):
15973 
    return not (self == other)
15974 
 
15975 
class getAllSources_args:
15976 
 
15977 
  thrift_spec = (
15978 
  )
15979 
 
15980 
  def read(self, iprot):
15981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15983 
      return
15984 
    iprot.readStructBegin()
15985 
    while True:
15986 
      (fname, ftype, fid) = iprot.readFieldBegin()
15987 
      if ftype == TType.STOP:
15988 
        break
15989 
      else:
15990 
        iprot.skip(ftype)
15991 
      iprot.readFieldEnd()
15992 
    iprot.readStructEnd()
15993 
 
15994 
  def write(self, oprot):
15995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15997 
      return
15998 
    oprot.writeStructBegin('getAllSources_args')
15999 
    oprot.writeFieldStop()
16000 
    oprot.writeStructEnd()
16001 
 
16002 
  def validate(self):
16003 
    return
16004 
 
16005 
 
16006 
  def __repr__(self):
16007 
    L = ['%s=%r' % (key, value)
16008 
      for key, value in self.__dict__.iteritems()]
16009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16010 
 
16011 
  def __eq__(self, other):
16012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16013 
 
16014 
  def __ne__(self, other):
16015 
    return not (self == other)
16016 
 
16017 
class getAllSources_result:
16018 
  """
16019 
  Attributes:
16020 
   - success
16021 
  """
16022 
 
16023 
  thrift_spec = (
16024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
16025 
  )
16026 
 
16027 
  def __init__(self, success=None,):
16028 
    self.success = success
16029 
 
16030 
  def read(self, iprot):
16031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16033 
      return
16034 
    iprot.readStructBegin()
16035 
    while True:
16036 
      (fname, ftype, fid) = iprot.readFieldBegin()
16037 
      if ftype == TType.STOP:
16038 
        break
16039 
      if fid == 0:
16040 
        if ftype == TType.LIST:
16041 
          self.success = []
9155 kshitij.so 16042 
          (_etype314, _size311) = iprot.readListBegin()
16043 
          for _i315 in xrange(_size311):
16044 
            _elem316 = Source()
16045 
            _elem316.read(iprot)
16046 
            self.success.append(_elem316)
5944 mandeep.dh 16047 
          iprot.readListEnd()
16048 
        else:
16049 
          iprot.skip(ftype)
16050 
      else:
16051 
        iprot.skip(ftype)
16052 
      iprot.readFieldEnd()
16053 
    iprot.readStructEnd()
16054 
 
16055 
  def write(self, oprot):
16056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16058 
      return
16059 
    oprot.writeStructBegin('getAllSources_result')
16060 
    if self.success is not None:
16061 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16062 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16063 
      for iter317 in self.success:
16064 
        iter317.write(oprot)
5944 mandeep.dh 16065 
      oprot.writeListEnd()
16066 
      oprot.writeFieldEnd()
16067 
    oprot.writeFieldStop()
16068 
    oprot.writeStructEnd()
16069 
 
16070 
  def validate(self):
16071 
    return
16072 
 
16073 
 
16074 
  def __repr__(self):
16075 
    L = ['%s=%r' % (key, value)
16076 
      for key, value in self.__dict__.iteritems()]
16077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16078 
 
16079 
  def __eq__(self, other):
16080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16081 
 
16082 
  def __ne__(self, other):
16083 
    return not (self == other)
16084 
 
16085 
class getItemPricingBySource_args:
16086 
  """
16087 
  Attributes:
16088 
   - itemId
16089 
   - sourceId
16090 
  """
16091 
 
16092 
  thrift_spec = (
16093 
    None, # 0
16094 
    (1, TType.I64, 'itemId', None, None, ), # 1
16095 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16096 
  )
16097 
 
16098 
  def __init__(self, itemId=None, sourceId=None,):
16099 
    self.itemId = itemId
16100 
    self.sourceId = sourceId
16101 
 
16102 
  def read(self, iprot):
16103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16105 
      return
16106 
    iprot.readStructBegin()
16107 
    while True:
16108 
      (fname, ftype, fid) = iprot.readFieldBegin()
16109 
      if ftype == TType.STOP:
16110 
        break
16111 
      if fid == 1:
16112 
        if ftype == TType.I64:
16113 
          self.itemId = iprot.readI64();
16114 
        else:
16115 
          iprot.skip(ftype)
16116 
      elif fid == 2:
16117 
        if ftype == TType.I64:
16118 
          self.sourceId = iprot.readI64();
16119 
        else:
16120 
          iprot.skip(ftype)
16121 
      else:
16122 
        iprot.skip(ftype)
16123 
      iprot.readFieldEnd()
16124 
    iprot.readStructEnd()
16125 
 
16126 
  def write(self, oprot):
16127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16129 
      return
16130 
    oprot.writeStructBegin('getItemPricingBySource_args')
16131 
    if self.itemId is not None:
16132 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16133 
      oprot.writeI64(self.itemId)
16134 
      oprot.writeFieldEnd()
16135 
    if self.sourceId is not None:
16136 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16137 
      oprot.writeI64(self.sourceId)
16138 
      oprot.writeFieldEnd()
16139 
    oprot.writeFieldStop()
16140 
    oprot.writeStructEnd()
16141 
 
16142 
  def validate(self):
16143 
    return
16144 
 
16145 
 
16146 
  def __repr__(self):
16147 
    L = ['%s=%r' % (key, value)
16148 
      for key, value in self.__dict__.iteritems()]
16149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16150 
 
16151 
  def __eq__(self, other):
16152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16153 
 
16154 
  def __ne__(self, other):
16155 
    return not (self == other)
16156 
 
16157 
class getItemPricingBySource_result:
16158 
  """
16159 
  Attributes:
16160 
   - success
16161 
   - cex
16162 
  """
16163 
 
16164 
  thrift_spec = (
16165 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
16166 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16167 
  )
16168 
 
16169 
  def __init__(self, success=None, cex=None,):
16170 
    self.success = success
16171 
    self.cex = cex
16172 
 
16173 
  def read(self, iprot):
16174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16176 
      return
16177 
    iprot.readStructBegin()
16178 
    while True:
16179 
      (fname, ftype, fid) = iprot.readFieldBegin()
16180 
      if ftype == TType.STOP:
16181 
        break
16182 
      if fid == 0:
16183 
        if ftype == TType.STRUCT:
16184 
          self.success = SourceItemPricing()
16185 
          self.success.read(iprot)
16186 
        else:
16187 
          iprot.skip(ftype)
16188 
      elif fid == 1:
16189 
        if ftype == TType.STRUCT:
16190 
          self.cex = CatalogServiceException()
16191 
          self.cex.read(iprot)
16192 
        else:
16193 
          iprot.skip(ftype)
16194 
      else:
16195 
        iprot.skip(ftype)
16196 
      iprot.readFieldEnd()
16197 
    iprot.readStructEnd()
16198 
 
16199 
  def write(self, oprot):
16200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16202 
      return
16203 
    oprot.writeStructBegin('getItemPricingBySource_result')
16204 
    if self.success is not None:
16205 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16206 
      self.success.write(oprot)
16207 
      oprot.writeFieldEnd()
16208 
    if self.cex is not None:
16209 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16210 
      self.cex.write(oprot)
16211 
      oprot.writeFieldEnd()
16212 
    oprot.writeFieldStop()
16213 
    oprot.writeStructEnd()
16214 
 
16215 
  def validate(self):
16216 
    return
16217 
 
16218 
 
16219 
  def __repr__(self):
16220 
    L = ['%s=%r' % (key, value)
16221 
      for key, value in self.__dict__.iteritems()]
16222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16223 
 
16224 
  def __eq__(self, other):
16225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16226 
 
16227 
  def __ne__(self, other):
16228 
    return not (self == other)
16229 
 
16230 
class addSourceItemPricing_args:
16231 
  """
16232 
  Attributes:
16233 
   - sourceItemPricing
16234 
  """
16235 
 
16236 
  thrift_spec = (
16237 
    None, # 0
16238 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
16239 
  )
16240 
 
16241 
  def __init__(self, sourceItemPricing=None,):
16242 
    self.sourceItemPricing = sourceItemPricing
16243 
 
16244 
  def read(self, iprot):
16245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16247 
      return
16248 
    iprot.readStructBegin()
16249 
    while True:
16250 
      (fname, ftype, fid) = iprot.readFieldBegin()
16251 
      if ftype == TType.STOP:
16252 
        break
16253 
      if fid == 1:
16254 
        if ftype == TType.STRUCT:
16255 
          self.sourceItemPricing = SourceItemPricing()
16256 
          self.sourceItemPricing.read(iprot)
16257 
        else:
16258 
          iprot.skip(ftype)
16259 
      else:
16260 
        iprot.skip(ftype)
16261 
      iprot.readFieldEnd()
16262 
    iprot.readStructEnd()
16263 
 
16264 
  def write(self, oprot):
16265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16267 
      return
16268 
    oprot.writeStructBegin('addSourceItemPricing_args')
16269 
    if self.sourceItemPricing is not None:
16270 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
16271 
      self.sourceItemPricing.write(oprot)
16272 
      oprot.writeFieldEnd()
16273 
    oprot.writeFieldStop()
16274 
    oprot.writeStructEnd()
16275 
 
16276 
  def validate(self):
16277 
    return
16278 
 
16279 
 
16280 
  def __repr__(self):
16281 
    L = ['%s=%r' % (key, value)
16282 
      for key, value in self.__dict__.iteritems()]
16283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16284 
 
16285 
  def __eq__(self, other):
16286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16287 
 
16288 
  def __ne__(self, other):
16289 
    return not (self == other)
16290 
 
16291 
class addSourceItemPricing_result:
16292 
  """
16293 
  Attributes:
16294 
   - cex
16295 
  """
16296 
 
16297 
  thrift_spec = (
16298 
    None, # 0
16299 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16300 
  )
16301 
 
16302 
  def __init__(self, cex=None,):
16303 
    self.cex = cex
16304 
 
16305 
  def read(self, iprot):
16306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16308 
      return
16309 
    iprot.readStructBegin()
16310 
    while True:
16311 
      (fname, ftype, fid) = iprot.readFieldBegin()
16312 
      if ftype == TType.STOP:
16313 
        break
16314 
      if fid == 1:
16315 
        if ftype == TType.STRUCT:
16316 
          self.cex = CatalogServiceException()
16317 
          self.cex.read(iprot)
16318 
        else:
16319 
          iprot.skip(ftype)
16320 
      else:
16321 
        iprot.skip(ftype)
16322 
      iprot.readFieldEnd()
16323 
    iprot.readStructEnd()
16324 
 
16325 
  def write(self, oprot):
16326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16328 
      return
16329 
    oprot.writeStructBegin('addSourceItemPricing_result')
16330 
    if self.cex is not None:
16331 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16332 
      self.cex.write(oprot)
16333 
      oprot.writeFieldEnd()
16334 
    oprot.writeFieldStop()
16335 
    oprot.writeStructEnd()
16336 
 
16337 
  def validate(self):
16338 
    return
16339 
 
16340 
 
16341 
  def __repr__(self):
16342 
    L = ['%s=%r' % (key, value)
16343 
      for key, value in self.__dict__.iteritems()]
16344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16345 
 
16346 
  def __eq__(self, other):
16347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16348 
 
16349 
  def __ne__(self, other):
16350 
    return not (self == other)
16351 
 
16352 
class getAllSourcePricing_args:
16353 
  """
16354 
  Attributes:
16355 
   - itemId
16356 
  """
16357 
 
16358 
  thrift_spec = (
16359 
    None, # 0
16360 
    (1, TType.I64, 'itemId', None, None, ), # 1
16361 
  )
16362 
 
16363 
  def __init__(self, itemId=None,):
16364 
    self.itemId = itemId
16365 
 
16366 
  def read(self, iprot):
16367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16369 
      return
16370 
    iprot.readStructBegin()
16371 
    while True:
16372 
      (fname, ftype, fid) = iprot.readFieldBegin()
16373 
      if ftype == TType.STOP:
16374 
        break
16375 
      if fid == 1:
16376 
        if ftype == TType.I64:
16377 
          self.itemId = iprot.readI64();
16378 
        else:
16379 
          iprot.skip(ftype)
16380 
      else:
16381 
        iprot.skip(ftype)
16382 
      iprot.readFieldEnd()
16383 
    iprot.readStructEnd()
16384 
 
16385 
  def write(self, oprot):
16386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16388 
      return
16389 
    oprot.writeStructBegin('getAllSourcePricing_args')
16390 
    if self.itemId is not None:
16391 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16392 
      oprot.writeI64(self.itemId)
16393 
      oprot.writeFieldEnd()
16394 
    oprot.writeFieldStop()
16395 
    oprot.writeStructEnd()
16396 
 
16397 
  def validate(self):
16398 
    return
16399 
 
16400 
 
16401 
  def __repr__(self):
16402 
    L = ['%s=%r' % (key, value)
16403 
      for key, value in self.__dict__.iteritems()]
16404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16405 
 
16406 
  def __eq__(self, other):
16407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16408 
 
16409 
  def __ne__(self, other):
16410 
    return not (self == other)
16411 
 
16412 
class getAllSourcePricing_result:
16413 
  """
16414 
  Attributes:
16415 
   - success
16416 
   - cex
16417 
  """
16418 
 
16419 
  thrift_spec = (
16420 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16421 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16422 
  )
16423 
 
16424 
  def __init__(self, success=None, cex=None,):
16425 
    self.success = success
16426 
    self.cex = cex
16427 
 
16428 
  def read(self, iprot):
16429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16431 
      return
16432 
    iprot.readStructBegin()
16433 
    while True:
16434 
      (fname, ftype, fid) = iprot.readFieldBegin()
16435 
      if ftype == TType.STOP:
16436 
        break
16437 
      if fid == 0:
16438 
        if ftype == TType.LIST:
16439 
          self.success = []
9155 kshitij.so 16440 
          (_etype321, _size318) = iprot.readListBegin()
16441 
          for _i322 in xrange(_size318):
16442 
            _elem323 = SourceItemPricing()
16443 
            _elem323.read(iprot)
16444 
            self.success.append(_elem323)
5944 mandeep.dh 16445 
          iprot.readListEnd()
16446 
        else:
16447 
          iprot.skip(ftype)
16448 
      elif fid == 1:
16449 
        if ftype == TType.STRUCT:
16450 
          self.cex = CatalogServiceException()
16451 
          self.cex.read(iprot)
16452 
        else:
16453 
          iprot.skip(ftype)
16454 
      else:
16455 
        iprot.skip(ftype)
16456 
      iprot.readFieldEnd()
16457 
    iprot.readStructEnd()
16458 
 
16459 
  def write(self, oprot):
16460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16462 
      return
16463 
    oprot.writeStructBegin('getAllSourcePricing_result')
16464 
    if self.success is not None:
16465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16466 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16467 
      for iter324 in self.success:
16468 
        iter324.write(oprot)
5944 mandeep.dh 16469 
      oprot.writeListEnd()
16470 
      oprot.writeFieldEnd()
16471 
    if self.cex is not None:
16472 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16473 
      self.cex.write(oprot)
16474 
      oprot.writeFieldEnd()
16475 
    oprot.writeFieldStop()
16476 
    oprot.writeStructEnd()
16477 
 
16478 
  def validate(self):
16479 
    return
16480 
 
16481 
 
16482 
  def __repr__(self):
16483 
    L = ['%s=%r' % (key, value)
16484 
      for key, value in self.__dict__.iteritems()]
16485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16486 
 
16487 
  def __eq__(self, other):
16488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16489 
 
16490 
  def __ne__(self, other):
16491 
    return not (self == other)
16492 
 
16493 
class getItemForSource_args:
16494 
  """
16495 
  Attributes:
16496 
   - item_id
16497 
   - sourceId
16498 
  """
16499 
 
16500 
  thrift_spec = (
16501 
    None, # 0
16502 
    (1, TType.I64, 'item_id', None, None, ), # 1
16503 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16504 
  )
16505 
 
16506 
  def __init__(self, item_id=None, sourceId=None,):
16507 
    self.item_id = item_id
16508 
    self.sourceId = sourceId
16509 
 
16510 
  def read(self, iprot):
16511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16513 
      return
16514 
    iprot.readStructBegin()
16515 
    while True:
16516 
      (fname, ftype, fid) = iprot.readFieldBegin()
16517 
      if ftype == TType.STOP:
16518 
        break
16519 
      if fid == 1:
16520 
        if ftype == TType.I64:
16521 
          self.item_id = iprot.readI64();
16522 
        else:
16523 
          iprot.skip(ftype)
16524 
      elif fid == 2:
16525 
        if ftype == TType.I64:
16526 
          self.sourceId = iprot.readI64();
16527 
        else:
16528 
          iprot.skip(ftype)
16529 
      else:
16530 
        iprot.skip(ftype)
16531 
      iprot.readFieldEnd()
16532 
    iprot.readStructEnd()
16533 
 
16534 
  def write(self, oprot):
16535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16537 
      return
16538 
    oprot.writeStructBegin('getItemForSource_args')
16539 
    if self.item_id is not None:
16540 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16541 
      oprot.writeI64(self.item_id)
16542 
      oprot.writeFieldEnd()
16543 
    if self.sourceId is not None:
16544 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16545 
      oprot.writeI64(self.sourceId)
16546 
      oprot.writeFieldEnd()
16547 
    oprot.writeFieldStop()
16548 
    oprot.writeStructEnd()
16549 
 
16550 
  def validate(self):
16551 
    return
16552 
 
16553 
 
16554 
  def __repr__(self):
16555 
    L = ['%s=%r' % (key, value)
16556 
      for key, value in self.__dict__.iteritems()]
16557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16558 
 
16559 
  def __eq__(self, other):
16560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16561 
 
16562 
  def __ne__(self, other):
16563 
    return not (self == other)
16564 
 
16565 
class getItemForSource_result:
16566 
  """
16567 
  Attributes:
16568 
   - success
16569 
   - cex
16570 
  """
16571 
 
16572 
  thrift_spec = (
16573 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16574 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16575 
  )
16576 
 
16577 
  def __init__(self, success=None, cex=None,):
16578 
    self.success = success
16579 
    self.cex = cex
16580 
 
16581 
  def read(self, iprot):
16582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16584 
      return
16585 
    iprot.readStructBegin()
16586 
    while True:
16587 
      (fname, ftype, fid) = iprot.readFieldBegin()
16588 
      if ftype == TType.STOP:
16589 
        break
16590 
      if fid == 0:
16591 
        if ftype == TType.STRUCT:
16592 
          self.success = Item()
16593 
          self.success.read(iprot)
16594 
        else:
16595 
          iprot.skip(ftype)
16596 
      elif fid == 1:
16597 
        if ftype == TType.STRUCT:
16598 
          self.cex = CatalogServiceException()
16599 
          self.cex.read(iprot)
16600 
        else:
16601 
          iprot.skip(ftype)
16602 
      else:
16603 
        iprot.skip(ftype)
16604 
      iprot.readFieldEnd()
16605 
    iprot.readStructEnd()
16606 
 
16607 
  def write(self, oprot):
16608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16610 
      return
16611 
    oprot.writeStructBegin('getItemForSource_result')
16612 
    if self.success is not None:
16613 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16614 
      self.success.write(oprot)
16615 
      oprot.writeFieldEnd()
16616 
    if self.cex is not None:
16617 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16618 
      self.cex.write(oprot)
16619 
      oprot.writeFieldEnd()
16620 
    oprot.writeFieldStop()
16621 
    oprot.writeStructEnd()
16622 
 
16623 
  def validate(self):
16624 
    return
16625 
 
16626 
 
16627 
  def __repr__(self):
16628 
    L = ['%s=%r' % (key, value)
16629 
      for key, value in self.__dict__.iteritems()]
16630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16631 
 
16632 
  def __eq__(self, other):
16633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16634 
 
16635 
  def __ne__(self, other):
16636 
    return not (self == other)
16637 
 
16638 
class searchItemsInRange_args:
16639 
  """
16640 
  Attributes:
16641 
   - searchTerms
16642 
   - offset
16643 
   - limit
16644 
  """
16645 
 
16646 
  thrift_spec = (
16647 
    None, # 0
16648 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16649 
    (2, TType.I64, 'offset', None, None, ), # 2
16650 
    (3, TType.I64, 'limit', None, None, ), # 3
16651 
  )
16652 
 
16653 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16654 
    self.searchTerms = searchTerms
16655 
    self.offset = offset
16656 
    self.limit = limit
16657 
 
16658 
  def read(self, iprot):
16659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16661 
      return
16662 
    iprot.readStructBegin()
16663 
    while True:
16664 
      (fname, ftype, fid) = iprot.readFieldBegin()
16665 
      if ftype == TType.STOP:
16666 
        break
16667 
      if fid == 1:
16668 
        if ftype == TType.LIST:
16669 
          self.searchTerms = []
9155 kshitij.so 16670 
          (_etype328, _size325) = iprot.readListBegin()
16671 
          for _i329 in xrange(_size325):
16672 
            _elem330 = iprot.readString();
16673 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16674 
          iprot.readListEnd()
16675 
        else:
16676 
          iprot.skip(ftype)
16677 
      elif fid == 2:
16678 
        if ftype == TType.I64:
16679 
          self.offset = iprot.readI64();
16680 
        else:
16681 
          iprot.skip(ftype)
16682 
      elif fid == 3:
16683 
        if ftype == TType.I64:
16684 
          self.limit = iprot.readI64();
16685 
        else:
16686 
          iprot.skip(ftype)
16687 
      else:
16688 
        iprot.skip(ftype)
16689 
      iprot.readFieldEnd()
16690 
    iprot.readStructEnd()
16691 
 
16692 
  def write(self, oprot):
16693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16695 
      return
16696 
    oprot.writeStructBegin('searchItemsInRange_args')
16697 
    if self.searchTerms is not None:
16698 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16699 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16700 
      for iter331 in self.searchTerms:
16701 
        oprot.writeString(iter331)
5944 mandeep.dh 16702 
      oprot.writeListEnd()
16703 
      oprot.writeFieldEnd()
16704 
    if self.offset is not None:
16705 
      oprot.writeFieldBegin('offset', TType.I64, 2)
16706 
      oprot.writeI64(self.offset)
16707 
      oprot.writeFieldEnd()
16708 
    if self.limit is not None:
16709 
      oprot.writeFieldBegin('limit', TType.I64, 3)
16710 
      oprot.writeI64(self.limit)
16711 
      oprot.writeFieldEnd()
16712 
    oprot.writeFieldStop()
16713 
    oprot.writeStructEnd()
16714 
 
16715 
  def validate(self):
16716 
    return
16717 
 
16718 
 
16719 
  def __repr__(self):
16720 
    L = ['%s=%r' % (key, value)
16721 
      for key, value in self.__dict__.iteritems()]
16722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16723 
 
16724 
  def __eq__(self, other):
16725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16726 
 
16727 
  def __ne__(self, other):
16728 
    return not (self == other)
16729 
 
16730 
class searchItemsInRange_result:
16731 
  """
16732 
  Attributes:
16733 
   - success
16734 
  """
16735 
 
16736 
  thrift_spec = (
16737 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16738 
  )
16739 
 
16740 
  def __init__(self, success=None,):
16741 
    self.success = success
16742 
 
16743 
  def read(self, iprot):
16744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16746 
      return
16747 
    iprot.readStructBegin()
16748 
    while True:
16749 
      (fname, ftype, fid) = iprot.readFieldBegin()
16750 
      if ftype == TType.STOP:
16751 
        break
16752 
      if fid == 0:
16753 
        if ftype == TType.LIST:
16754 
          self.success = []
9155 kshitij.so 16755 
          (_etype335, _size332) = iprot.readListBegin()
16756 
          for _i336 in xrange(_size332):
16757 
            _elem337 = Item()
16758 
            _elem337.read(iprot)
16759 
            self.success.append(_elem337)
5944 mandeep.dh 16760 
          iprot.readListEnd()
16761 
        else:
16762 
          iprot.skip(ftype)
16763 
      else:
16764 
        iprot.skip(ftype)
16765 
      iprot.readFieldEnd()
16766 
    iprot.readStructEnd()
16767 
 
16768 
  def write(self, oprot):
16769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16771 
      return
16772 
    oprot.writeStructBegin('searchItemsInRange_result')
16773 
    if self.success is not None:
16774 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16775 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16776 
      for iter338 in self.success:
16777 
        iter338.write(oprot)
5944 mandeep.dh 16778 
      oprot.writeListEnd()
16779 
      oprot.writeFieldEnd()
16780 
    oprot.writeFieldStop()
16781 
    oprot.writeStructEnd()
16782 
 
16783 
  def validate(self):
16784 
    return
16785 
 
16786 
 
16787 
  def __repr__(self):
16788 
    L = ['%s=%r' % (key, value)
16789 
      for key, value in self.__dict__.iteritems()]
16790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16791 
 
16792 
  def __eq__(self, other):
16793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16794 
 
16795 
  def __ne__(self, other):
16796 
    return not (self == other)
16797 
 
16798 
class getSearchResultCount_args:
16799 
  """
16800 
  Attributes:
16801 
   - searchTerms
16802 
  """
16803 
 
16804 
  thrift_spec = (
16805 
    None, # 0
16806 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16807 
  )
16808 
 
16809 
  def __init__(self, searchTerms=None,):
16810 
    self.searchTerms = searchTerms
16811 
 
16812 
  def read(self, iprot):
16813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16815 
      return
16816 
    iprot.readStructBegin()
16817 
    while True:
16818 
      (fname, ftype, fid) = iprot.readFieldBegin()
16819 
      if ftype == TType.STOP:
16820 
        break
16821 
      if fid == 1:
16822 
        if ftype == TType.LIST:
16823 
          self.searchTerms = []
9155 kshitij.so 16824 
          (_etype342, _size339) = iprot.readListBegin()
16825 
          for _i343 in xrange(_size339):
16826 
            _elem344 = iprot.readString();
16827 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 16828 
          iprot.readListEnd()
16829 
        else:
16830 
          iprot.skip(ftype)
16831 
      else:
16832 
        iprot.skip(ftype)
16833 
      iprot.readFieldEnd()
16834 
    iprot.readStructEnd()
16835 
 
16836 
  def write(self, oprot):
16837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16839 
      return
16840 
    oprot.writeStructBegin('getSearchResultCount_args')
16841 
    if self.searchTerms is not None:
16842 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16843 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16844 
      for iter345 in self.searchTerms:
16845 
        oprot.writeString(iter345)
5944 mandeep.dh 16846 
      oprot.writeListEnd()
16847 
      oprot.writeFieldEnd()
16848 
    oprot.writeFieldStop()
16849 
    oprot.writeStructEnd()
16850 
 
16851 
  def validate(self):
16852 
    return
16853 
 
16854 
 
16855 
  def __repr__(self):
16856 
    L = ['%s=%r' % (key, value)
16857 
      for key, value in self.__dict__.iteritems()]
16858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16859 
 
16860 
  def __eq__(self, other):
16861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16862 
 
16863 
  def __ne__(self, other):
16864 
    return not (self == other)
16865 
 
16866 
class getSearchResultCount_result:
16867 
  """
16868 
  Attributes:
16869 
   - success
16870 
  """
16871 
 
16872 
  thrift_spec = (
16873 
    (0, TType.I32, 'success', None, None, ), # 0
16874 
  )
16875 
 
16876 
  def __init__(self, success=None,):
16877 
    self.success = success
16878 
 
16879 
  def read(self, iprot):
16880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16882 
      return
16883 
    iprot.readStructBegin()
16884 
    while True:
16885 
      (fname, ftype, fid) = iprot.readFieldBegin()
16886 
      if ftype == TType.STOP:
16887 
        break
16888 
      if fid == 0:
16889 
        if ftype == TType.I32:
16890 
          self.success = iprot.readI32();
16891 
        else:
16892 
          iprot.skip(ftype)
16893 
      else:
16894 
        iprot.skip(ftype)
16895 
      iprot.readFieldEnd()
16896 
    iprot.readStructEnd()
16897 
 
16898 
  def write(self, oprot):
16899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16901 
      return
16902 
    oprot.writeStructBegin('getSearchResultCount_result')
16903 
    if self.success is not None:
16904 
      oprot.writeFieldBegin('success', TType.I32, 0)
16905 
      oprot.writeI32(self.success)
16906 
      oprot.writeFieldEnd()
16907 
    oprot.writeFieldStop()
16908 
    oprot.writeStructEnd()
16909 
 
16910 
  def validate(self):
16911 
    return
16912 
 
16913 
 
16914 
  def __repr__(self):
16915 
    L = ['%s=%r' % (key, value)
16916 
      for key, value in self.__dict__.iteritems()]
16917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16918 
 
16919 
  def __eq__(self, other):
16920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16921 
 
16922 
  def __ne__(self, other):
16923 
    return not (self == other)
16924 
 
16925 
class getProductNotifications_args:
16926 
  """
16927 
  Attributes:
16928 
   - startDateTime
16929 
  """
16930 
 
16931 
  thrift_spec = (
16932 
    None, # 0
16933 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
16934 
  )
16935 
 
16936 
  def __init__(self, startDateTime=None,):
16937 
    self.startDateTime = startDateTime
16938 
 
16939 
  def read(self, iprot):
16940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16942 
      return
16943 
    iprot.readStructBegin()
16944 
    while True:
16945 
      (fname, ftype, fid) = iprot.readFieldBegin()
16946 
      if ftype == TType.STOP:
16947 
        break
16948 
      if fid == 1:
16949 
        if ftype == TType.I64:
16950 
          self.startDateTime = iprot.readI64();
16951 
        else:
16952 
          iprot.skip(ftype)
16953 
      else:
16954 
        iprot.skip(ftype)
16955 
      iprot.readFieldEnd()
16956 
    iprot.readStructEnd()
16957 
 
16958 
  def write(self, oprot):
16959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16961 
      return
16962 
    oprot.writeStructBegin('getProductNotifications_args')
16963 
    if self.startDateTime is not None:
16964 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16965 
      oprot.writeI64(self.startDateTime)
16966 
      oprot.writeFieldEnd()
16967 
    oprot.writeFieldStop()
16968 
    oprot.writeStructEnd()
16969 
 
16970 
  def validate(self):
16971 
    return
16972 
 
16973 
 
16974 
  def __repr__(self):
16975 
    L = ['%s=%r' % (key, value)
16976 
      for key, value in self.__dict__.iteritems()]
16977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16978 
 
16979 
  def __eq__(self, other):
16980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16981 
 
16982 
  def __ne__(self, other):
16983 
    return not (self == other)
16984 
 
16985 
class getProductNotifications_result:
16986 
  """
16987 
  Attributes:
16988 
   - success
16989 
  """
16990 
 
16991 
  thrift_spec = (
16992 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
16993 
  )
16994 
 
16995 
  def __init__(self, success=None,):
16996 
    self.success = success
16997 
 
16998 
  def read(self, iprot):
16999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17001 
      return
17002 
    iprot.readStructBegin()
17003 
    while True:
17004 
      (fname, ftype, fid) = iprot.readFieldBegin()
17005 
      if ftype == TType.STOP:
17006 
        break
17007 
      if fid == 0:
17008 
        if ftype == TType.LIST:
17009 
          self.success = []
9155 kshitij.so 17010 
          (_etype349, _size346) = iprot.readListBegin()
17011 
          for _i350 in xrange(_size346):
17012 
            _elem351 = ProductNotificationRequest()
17013 
            _elem351.read(iprot)
17014 
            self.success.append(_elem351)
5944 mandeep.dh 17015 
          iprot.readListEnd()
17016 
        else:
17017 
          iprot.skip(ftype)
17018 
      else:
17019 
        iprot.skip(ftype)
17020 
      iprot.readFieldEnd()
17021 
    iprot.readStructEnd()
17022 
 
17023 
  def write(self, oprot):
17024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17026 
      return
17027 
    oprot.writeStructBegin('getProductNotifications_result')
17028 
    if self.success is not None:
17029 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17030 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17031 
      for iter352 in self.success:
17032 
        iter352.write(oprot)
5944 mandeep.dh 17033 
      oprot.writeListEnd()
17034 
      oprot.writeFieldEnd()
17035 
    oprot.writeFieldStop()
17036 
    oprot.writeStructEnd()
17037 
 
17038 
  def validate(self):
17039 
    return
17040 
 
17041 
 
17042 
  def __repr__(self):
17043 
    L = ['%s=%r' % (key, value)
17044 
      for key, value in self.__dict__.iteritems()]
17045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17046 
 
17047 
  def __eq__(self, other):
17048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17049 
 
17050 
  def __ne__(self, other):
17051 
    return not (self == other)
17052 
 
17053 
class getProductNotificationRequestCount_args:
17054 
  """
17055 
  Attributes:
17056 
   - startDateTime
7897 amar.kumar 17057 
   - categoryId
5944 mandeep.dh 17058 
  """
17059 
 
17060 
  thrift_spec = (
17061 
    None, # 0
17062 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 17063 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 17064 
  )
17065 
 
7897 amar.kumar 17066 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 17067 
    self.startDateTime = startDateTime
7897 amar.kumar 17068 
    self.categoryId = categoryId
5944 mandeep.dh 17069 
 
17070 
  def read(self, iprot):
17071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17073 
      return
17074 
    iprot.readStructBegin()
17075 
    while True:
17076 
      (fname, ftype, fid) = iprot.readFieldBegin()
17077 
      if ftype == TType.STOP:
17078 
        break
17079 
      if fid == 1:
17080 
        if ftype == TType.I64:
17081 
          self.startDateTime = iprot.readI64();
17082 
        else:
17083 
          iprot.skip(ftype)
7897 amar.kumar 17084 
      elif fid == 2:
17085 
        if ftype == TType.I64:
17086 
          self.categoryId = iprot.readI64();
17087 
        else:
17088 
          iprot.skip(ftype)
5944 mandeep.dh 17089 
      else:
17090 
        iprot.skip(ftype)
17091 
      iprot.readFieldEnd()
17092 
    iprot.readStructEnd()
17093 
 
17094 
  def write(self, oprot):
17095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17097 
      return
17098 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
17099 
    if self.startDateTime is not None:
17100 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
17101 
      oprot.writeI64(self.startDateTime)
17102 
      oprot.writeFieldEnd()
7897 amar.kumar 17103 
    if self.categoryId is not None:
17104 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
17105 
      oprot.writeI64(self.categoryId)
17106 
      oprot.writeFieldEnd()
5944 mandeep.dh 17107 
    oprot.writeFieldStop()
17108 
    oprot.writeStructEnd()
17109 
 
17110 
  def validate(self):
17111 
    return
17112 
 
17113 
 
17114 
  def __repr__(self):
17115 
    L = ['%s=%r' % (key, value)
17116 
      for key, value in self.__dict__.iteritems()]
17117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17118 
 
17119 
  def __eq__(self, other):
17120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17121 
 
17122 
  def __ne__(self, other):
17123 
    return not (self == other)
17124 
 
17125 
class getProductNotificationRequestCount_result:
17126 
  """
17127 
  Attributes:
17128 
   - success
17129 
  """
17130 
 
17131 
  thrift_spec = (
17132 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
17133 
  )
17134 
 
17135 
  def __init__(self, success=None,):
17136 
    self.success = success
17137 
 
17138 
  def read(self, iprot):
17139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17141 
      return
17142 
    iprot.readStructBegin()
17143 
    while True:
17144 
      (fname, ftype, fid) = iprot.readFieldBegin()
17145 
      if ftype == TType.STOP:
17146 
        break
17147 
      if fid == 0:
17148 
        if ftype == TType.LIST:
17149 
          self.success = []
9155 kshitij.so 17150 
          (_etype356, _size353) = iprot.readListBegin()
17151 
          for _i357 in xrange(_size353):
17152 
            _elem358 = ProductNotificationRequestCount()
17153 
            _elem358.read(iprot)
17154 
            self.success.append(_elem358)
5944 mandeep.dh 17155 
          iprot.readListEnd()
17156 
        else:
17157 
          iprot.skip(ftype)
17158 
      else:
17159 
        iprot.skip(ftype)
17160 
      iprot.readFieldEnd()
17161 
    iprot.readStructEnd()
17162 
 
17163 
  def write(self, oprot):
17164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17166 
      return
17167 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
17168 
    if self.success is not None:
17169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17171 
      for iter359 in self.success:
17172 
        iter359.write(oprot)
5944 mandeep.dh 17173 
      oprot.writeListEnd()
17174 
      oprot.writeFieldEnd()
17175 
    oprot.writeFieldStop()
17176 
    oprot.writeStructEnd()
17177 
 
17178 
  def validate(self):
17179 
    return
17180 
 
17181 
 
17182 
  def __repr__(self):
17183 
    L = ['%s=%r' % (key, value)
17184 
      for key, value in self.__dict__.iteritems()]
17185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17186 
 
17187 
  def __eq__(self, other):
17188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17189 
 
17190 
  def __ne__(self, other):
17191 
    return not (self == other)
17192 
 
17193 
class addAuthorizationLog_args:
17194 
  """
17195 
  Attributes:
17196 
   - itemId
17197 
   - username
17198 
   - reason
17199 
  """
17200 
 
17201 
  thrift_spec = (
17202 
    None, # 0
17203 
    (1, TType.I64, 'itemId', None, None, ), # 1
17204 
    (2, TType.STRING, 'username', None, None, ), # 2
17205 
    (3, TType.STRING, 'reason', None, None, ), # 3
17206 
  )
17207 
 
17208 
  def __init__(self, itemId=None, username=None, reason=None,):
17209 
    self.itemId = itemId
17210 
    self.username = username
17211 
    self.reason = reason
17212 
 
17213 
  def read(self, iprot):
17214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17216 
      return
17217 
    iprot.readStructBegin()
17218 
    while True:
17219 
      (fname, ftype, fid) = iprot.readFieldBegin()
17220 
      if ftype == TType.STOP:
17221 
        break
17222 
      if fid == 1:
17223 
        if ftype == TType.I64:
17224 
          self.itemId = iprot.readI64();
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      elif fid == 2:
17228 
        if ftype == TType.STRING:
17229 
          self.username = iprot.readString();
17230 
        else:
17231 
          iprot.skip(ftype)
17232 
      elif fid == 3:
17233 
        if ftype == TType.STRING:
17234 
          self.reason = iprot.readString();
17235 
        else:
17236 
          iprot.skip(ftype)
17237 
      else:
17238 
        iprot.skip(ftype)
17239 
      iprot.readFieldEnd()
17240 
    iprot.readStructEnd()
17241 
 
17242 
  def write(self, oprot):
17243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17245 
      return
17246 
    oprot.writeStructBegin('addAuthorizationLog_args')
17247 
    if self.itemId is not None:
17248 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17249 
      oprot.writeI64(self.itemId)
17250 
      oprot.writeFieldEnd()
17251 
    if self.username is not None:
17252 
      oprot.writeFieldBegin('username', TType.STRING, 2)
17253 
      oprot.writeString(self.username)
17254 
      oprot.writeFieldEnd()
17255 
    if self.reason is not None:
17256 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17257 
      oprot.writeString(self.reason)
17258 
      oprot.writeFieldEnd()
17259 
    oprot.writeFieldStop()
17260 
    oprot.writeStructEnd()
17261 
 
17262 
  def validate(self):
17263 
    return
17264 
 
17265 
 
17266 
  def __repr__(self):
17267 
    L = ['%s=%r' % (key, value)
17268 
      for key, value in self.__dict__.iteritems()]
17269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17270 
 
17271 
  def __eq__(self, other):
17272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17273 
 
17274 
  def __ne__(self, other):
17275 
    return not (self == other)
17276 
 
17277 
class addAuthorizationLog_result:
17278 
  """
17279 
  Attributes:
17280 
   - success
17281 
   - cex
17282 
  """
17283 
 
17284 
  thrift_spec = (
17285 
    (0, TType.BOOL, 'success', None, None, ), # 0
17286 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17287 
  )
17288 
 
17289 
  def __init__(self, success=None, cex=None,):
17290 
    self.success = success
17291 
    self.cex = cex
17292 
 
17293 
  def read(self, iprot):
17294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17296 
      return
17297 
    iprot.readStructBegin()
17298 
    while True:
17299 
      (fname, ftype, fid) = iprot.readFieldBegin()
17300 
      if ftype == TType.STOP:
17301 
        break
17302 
      if fid == 0:
17303 
        if ftype == TType.BOOL:
17304 
          self.success = iprot.readBool();
17305 
        else:
17306 
          iprot.skip(ftype)
17307 
      elif fid == 1:
17308 
        if ftype == TType.STRUCT:
17309 
          self.cex = CatalogServiceException()
17310 
          self.cex.read(iprot)
17311 
        else:
17312 
          iprot.skip(ftype)
17313 
      else:
17314 
        iprot.skip(ftype)
17315 
      iprot.readFieldEnd()
17316 
    iprot.readStructEnd()
17317 
 
17318 
  def write(self, oprot):
17319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17321 
      return
17322 
    oprot.writeStructBegin('addAuthorizationLog_result')
17323 
    if self.success is not None:
17324 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17325 
      oprot.writeBool(self.success)
17326 
      oprot.writeFieldEnd()
17327 
    if self.cex is not None:
17328 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17329 
      self.cex.write(oprot)
17330 
      oprot.writeFieldEnd()
17331 
    oprot.writeFieldStop()
17332 
    oprot.writeStructEnd()
17333 
 
17334 
  def validate(self):
17335 
    return
17336 
 
17337 
 
17338 
  def __repr__(self):
17339 
    L = ['%s=%r' % (key, value)
17340 
      for key, value in self.__dict__.iteritems()]
17341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17342 
 
17343 
  def __eq__(self, other):
17344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17345 
 
17346 
  def __ne__(self, other):
17347 
    return not (self == other)
17348 
 
17349 
class addupdateVoucherForItem_args:
17350 
  """
17351 
  Attributes:
17352 
   - catalog_item_id
17353 
   - voucherType
17354 
   - voucherAmount
17355 
  """
17356 
 
17357 
  thrift_spec = (
17358 
    None, # 0
17359 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17360 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17361 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17362 
  )
17363 
 
17364 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17365 
    self.catalog_item_id = catalog_item_id
17366 
    self.voucherType = voucherType
17367 
    self.voucherAmount = voucherAmount
17368 
 
17369 
  def read(self, iprot):
17370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17372 
      return
17373 
    iprot.readStructBegin()
17374 
    while True:
17375 
      (fname, ftype, fid) = iprot.readFieldBegin()
17376 
      if ftype == TType.STOP:
17377 
        break
17378 
      if fid == 1:
17379 
        if ftype == TType.I64:
17380 
          self.catalog_item_id = iprot.readI64();
17381 
        else:
17382 
          iprot.skip(ftype)
17383 
      elif fid == 2:
17384 
        if ftype == TType.I64:
17385 
          self.voucherType = iprot.readI64();
17386 
        else:
17387 
          iprot.skip(ftype)
17388 
      elif fid == 3:
17389 
        if ftype == TType.I64:
17390 
          self.voucherAmount = iprot.readI64();
17391 
        else:
17392 
          iprot.skip(ftype)
17393 
      else:
17394 
        iprot.skip(ftype)
17395 
      iprot.readFieldEnd()
17396 
    iprot.readStructEnd()
17397 
 
17398 
  def write(self, oprot):
17399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17401 
      return
17402 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17403 
    if self.catalog_item_id is not None:
17404 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17405 
      oprot.writeI64(self.catalog_item_id)
17406 
      oprot.writeFieldEnd()
17407 
    if self.voucherType is not None:
17408 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17409 
      oprot.writeI64(self.voucherType)
17410 
      oprot.writeFieldEnd()
17411 
    if self.voucherAmount is not None:
17412 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17413 
      oprot.writeI64(self.voucherAmount)
17414 
      oprot.writeFieldEnd()
17415 
    oprot.writeFieldStop()
17416 
    oprot.writeStructEnd()
17417 
 
17418 
  def validate(self):
17419 
    return
17420 
 
17421 
 
17422 
  def __repr__(self):
17423 
    L = ['%s=%r' % (key, value)
17424 
      for key, value in self.__dict__.iteritems()]
17425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17426 
 
17427 
  def __eq__(self, other):
17428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17429 
 
17430 
  def __ne__(self, other):
17431 
    return not (self == other)
17432 
 
17433 
class addupdateVoucherForItem_result:
17434 
  """
17435 
  Attributes:
17436 
   - success
17437 
   - cex
17438 
  """
17439 
 
17440 
  thrift_spec = (
17441 
    (0, TType.BOOL, 'success', None, None, ), # 0
17442 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17443 
  )
17444 
 
17445 
  def __init__(self, success=None, cex=None,):
17446 
    self.success = success
17447 
    self.cex = cex
17448 
 
17449 
  def read(self, iprot):
17450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17452 
      return
17453 
    iprot.readStructBegin()
17454 
    while True:
17455 
      (fname, ftype, fid) = iprot.readFieldBegin()
17456 
      if ftype == TType.STOP:
17457 
        break
17458 
      if fid == 0:
17459 
        if ftype == TType.BOOL:
17460 
          self.success = iprot.readBool();
17461 
        else:
17462 
          iprot.skip(ftype)
17463 
      elif fid == 1:
17464 
        if ftype == TType.STRUCT:
17465 
          self.cex = CatalogServiceException()
17466 
          self.cex.read(iprot)
17467 
        else:
17468 
          iprot.skip(ftype)
17469 
      else:
17470 
        iprot.skip(ftype)
17471 
      iprot.readFieldEnd()
17472 
    iprot.readStructEnd()
17473 
 
17474 
  def write(self, oprot):
17475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17477 
      return
17478 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17479 
    if self.success is not None:
17480 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17481 
      oprot.writeBool(self.success)
17482 
      oprot.writeFieldEnd()
17483 
    if self.cex is not None:
17484 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17485 
      self.cex.write(oprot)
17486 
      oprot.writeFieldEnd()
17487 
    oprot.writeFieldStop()
17488 
    oprot.writeStructEnd()
17489 
 
17490 
  def validate(self):
17491 
    return
17492 
 
17493 
 
17494 
  def __repr__(self):
17495 
    L = ['%s=%r' % (key, value)
17496 
      for key, value in self.__dict__.iteritems()]
17497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17498 
 
17499 
  def __eq__(self, other):
17500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17501 
 
17502 
  def __ne__(self, other):
17503 
    return not (self == other)
17504 
 
17505 
class deleteVoucherForItem_args:
17506 
  """
17507 
  Attributes:
17508 
   - catalog_item_id
17509 
   - voucherType
17510 
  """
17511 
 
17512 
  thrift_spec = (
17513 
    None, # 0
17514 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17515 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17516 
  )
17517 
 
17518 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17519 
    self.catalog_item_id = catalog_item_id
17520 
    self.voucherType = voucherType
17521 
 
17522 
  def read(self, iprot):
17523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17525 
      return
17526 
    iprot.readStructBegin()
17527 
    while True:
17528 
      (fname, ftype, fid) = iprot.readFieldBegin()
17529 
      if ftype == TType.STOP:
17530 
        break
17531 
      if fid == 1:
17532 
        if ftype == TType.I64:
17533 
          self.catalog_item_id = iprot.readI64();
17534 
        else:
17535 
          iprot.skip(ftype)
17536 
      elif fid == 2:
17537 
        if ftype == TType.I64:
17538 
          self.voucherType = iprot.readI64();
17539 
        else:
17540 
          iprot.skip(ftype)
17541 
      else:
17542 
        iprot.skip(ftype)
17543 
      iprot.readFieldEnd()
17544 
    iprot.readStructEnd()
17545 
 
17546 
  def write(self, oprot):
17547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17549 
      return
17550 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17551 
    if self.catalog_item_id is not None:
17552 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17553 
      oprot.writeI64(self.catalog_item_id)
17554 
      oprot.writeFieldEnd()
17555 
    if self.voucherType is not None:
17556 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17557 
      oprot.writeI64(self.voucherType)
17558 
      oprot.writeFieldEnd()
17559 
    oprot.writeFieldStop()
17560 
    oprot.writeStructEnd()
17561 
 
17562 
  def validate(self):
17563 
    return
17564 
 
17565 
 
17566 
  def __repr__(self):
17567 
    L = ['%s=%r' % (key, value)
17568 
      for key, value in self.__dict__.iteritems()]
17569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17570 
 
17571 
  def __eq__(self, other):
17572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17573 
 
17574 
  def __ne__(self, other):
17575 
    return not (self == other)
17576 
 
17577 
class deleteVoucherForItem_result:
17578 
  """
17579 
  Attributes:
17580 
   - success
17581 
   - cex
17582 
  """
17583 
 
17584 
  thrift_spec = (
17585 
    (0, TType.BOOL, 'success', None, None, ), # 0
17586 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17587 
  )
17588 
 
17589 
  def __init__(self, success=None, cex=None,):
17590 
    self.success = success
17591 
    self.cex = cex
17592 
 
17593 
  def read(self, iprot):
17594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17596 
      return
17597 
    iprot.readStructBegin()
17598 
    while True:
17599 
      (fname, ftype, fid) = iprot.readFieldBegin()
17600 
      if ftype == TType.STOP:
17601 
        break
17602 
      if fid == 0:
17603 
        if ftype == TType.BOOL:
17604 
          self.success = iprot.readBool();
17605 
        else:
17606 
          iprot.skip(ftype)
17607 
      elif fid == 1:
17608 
        if ftype == TType.STRUCT:
17609 
          self.cex = CatalogServiceException()
17610 
          self.cex.read(iprot)
17611 
        else:
17612 
          iprot.skip(ftype)
17613 
      else:
17614 
        iprot.skip(ftype)
17615 
      iprot.readFieldEnd()
17616 
    iprot.readStructEnd()
17617 
 
17618 
  def write(self, oprot):
17619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17621 
      return
17622 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17623 
    if self.success is not None:
17624 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17625 
      oprot.writeBool(self.success)
17626 
      oprot.writeFieldEnd()
17627 
    if self.cex is not None:
17628 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17629 
      self.cex.write(oprot)
17630 
      oprot.writeFieldEnd()
17631 
    oprot.writeFieldStop()
17632 
    oprot.writeStructEnd()
17633 
 
17634 
  def validate(self):
17635 
    return
17636 
 
17637 
 
17638 
  def __repr__(self):
17639 
    L = ['%s=%r' % (key, value)
17640 
      for key, value in self.__dict__.iteritems()]
17641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17642 
 
17643 
  def __eq__(self, other):
17644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17645 
 
17646 
  def __ne__(self, other):
17647 
    return not (self == other)
17648 
 
17649 
class getVoucherAmount_args:
17650 
  """
17651 
  Attributes:
17652 
   - itemId
17653 
   - voucherType
17654 
  """
17655 
 
17656 
  thrift_spec = (
17657 
    None, # 0
17658 
    (1, TType.I64, 'itemId', None, None, ), # 1
17659 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17660 
  )
17661 
 
17662 
  def __init__(self, itemId=None, voucherType=None,):
17663 
    self.itemId = itemId
17664 
    self.voucherType = voucherType
17665 
 
17666 
  def read(self, iprot):
17667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17669 
      return
17670 
    iprot.readStructBegin()
17671 
    while True:
17672 
      (fname, ftype, fid) = iprot.readFieldBegin()
17673 
      if ftype == TType.STOP:
17674 
        break
17675 
      if fid == 1:
17676 
        if ftype == TType.I64:
17677 
          self.itemId = iprot.readI64();
17678 
        else:
17679 
          iprot.skip(ftype)
17680 
      elif fid == 2:
17681 
        if ftype == TType.I64:
17682 
          self.voucherType = iprot.readI64();
17683 
        else:
17684 
          iprot.skip(ftype)
17685 
      else:
17686 
        iprot.skip(ftype)
17687 
      iprot.readFieldEnd()
17688 
    iprot.readStructEnd()
17689 
 
17690 
  def write(self, oprot):
17691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17693 
      return
17694 
    oprot.writeStructBegin('getVoucherAmount_args')
17695 
    if self.itemId is not None:
17696 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17697 
      oprot.writeI64(self.itemId)
17698 
      oprot.writeFieldEnd()
17699 
    if self.voucherType is not None:
17700 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17701 
      oprot.writeI64(self.voucherType)
17702 
      oprot.writeFieldEnd()
17703 
    oprot.writeFieldStop()
17704 
    oprot.writeStructEnd()
17705 
 
17706 
  def validate(self):
17707 
    return
17708 
 
17709 
 
17710 
  def __repr__(self):
17711 
    L = ['%s=%r' % (key, value)
17712 
      for key, value in self.__dict__.iteritems()]
17713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17714 
 
17715 
  def __eq__(self, other):
17716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17717 
 
17718 
  def __ne__(self, other):
17719 
    return not (self == other)
17720 
 
17721 
class getVoucherAmount_result:
17722 
  """
17723 
  Attributes:
17724 
   - success
17725 
  """
17726 
 
17727 
  thrift_spec = (
17728 
    (0, TType.I64, 'success', None, None, ), # 0
17729 
  )
17730 
 
17731 
  def __init__(self, success=None,):
17732 
    self.success = success
17733 
 
17734 
  def read(self, iprot):
17735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17737 
      return
17738 
    iprot.readStructBegin()
17739 
    while True:
17740 
      (fname, ftype, fid) = iprot.readFieldBegin()
17741 
      if ftype == TType.STOP:
17742 
        break
17743 
      if fid == 0:
17744 
        if ftype == TType.I64:
17745 
          self.success = iprot.readI64();
17746 
        else:
17747 
          iprot.skip(ftype)
17748 
      else:
17749 
        iprot.skip(ftype)
17750 
      iprot.readFieldEnd()
17751 
    iprot.readStructEnd()
17752 
 
17753 
  def write(self, oprot):
17754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17756 
      return
17757 
    oprot.writeStructBegin('getVoucherAmount_result')
17758 
    if self.success is not None:
17759 
      oprot.writeFieldBegin('success', TType.I64, 0)
17760 
      oprot.writeI64(self.success)
17761 
      oprot.writeFieldEnd()
17762 
    oprot.writeFieldStop()
17763 
    oprot.writeStructEnd()
17764 
 
17765 
  def validate(self):
17766 
    return
17767 
 
17768 
 
17769 
  def __repr__(self):
17770 
    L = ['%s=%r' % (key, value)
17771 
      for key, value in self.__dict__.iteritems()]
17772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17773 
 
17774 
  def __eq__(self, other):
17775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17776 
 
17777 
  def __ne__(self, other):
17778 
    return not (self == other)
17779 
 
17780 
class getAllItemVouchers_args:
17781 
  """
17782 
  Attributes:
17783 
   - itemId
17784 
  """
17785 
 
17786 
  thrift_spec = (
17787 
    None, # 0
17788 
    (1, TType.I64, 'itemId', None, None, ), # 1
17789 
  )
17790 
 
17791 
  def __init__(self, itemId=None,):
17792 
    self.itemId = itemId
17793 
 
17794 
  def read(self, iprot):
17795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17797 
      return
17798 
    iprot.readStructBegin()
17799 
    while True:
17800 
      (fname, ftype, fid) = iprot.readFieldBegin()
17801 
      if ftype == TType.STOP:
17802 
        break
17803 
      if fid == 1:
17804 
        if ftype == TType.I64:
17805 
          self.itemId = iprot.readI64();
17806 
        else:
17807 
          iprot.skip(ftype)
17808 
      else:
17809 
        iprot.skip(ftype)
17810 
      iprot.readFieldEnd()
17811 
    iprot.readStructEnd()
17812 
 
17813 
  def write(self, oprot):
17814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17816 
      return
17817 
    oprot.writeStructBegin('getAllItemVouchers_args')
17818 
    if self.itemId is not None:
17819 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17820 
      oprot.writeI64(self.itemId)
17821 
      oprot.writeFieldEnd()
17822 
    oprot.writeFieldStop()
17823 
    oprot.writeStructEnd()
17824 
 
17825 
  def validate(self):
17826 
    return
17827 
 
17828 
 
17829 
  def __repr__(self):
17830 
    L = ['%s=%r' % (key, value)
17831 
      for key, value in self.__dict__.iteritems()]
17832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17833 
 
17834 
  def __eq__(self, other):
17835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17836 
 
17837 
  def __ne__(self, other):
17838 
    return not (self == other)
17839 
 
17840 
class getAllItemVouchers_result:
17841 
  """
17842 
  Attributes:
17843 
   - success
17844 
  """
17845 
 
17846 
  thrift_spec = (
17847 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
17848 
  )
17849 
 
17850 
  def __init__(self, success=None,):
17851 
    self.success = success
17852 
 
17853 
  def read(self, iprot):
17854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17856 
      return
17857 
    iprot.readStructBegin()
17858 
    while True:
17859 
      (fname, ftype, fid) = iprot.readFieldBegin()
17860 
      if ftype == TType.STOP:
17861 
        break
17862 
      if fid == 0:
17863 
        if ftype == TType.LIST:
17864 
          self.success = []
9155 kshitij.so 17865 
          (_etype363, _size360) = iprot.readListBegin()
17866 
          for _i364 in xrange(_size360):
17867 
            _elem365 = VoucherItemMapping()
17868 
            _elem365.read(iprot)
17869 
            self.success.append(_elem365)
5944 mandeep.dh 17870 
          iprot.readListEnd()
17871 
        else:
17872 
          iprot.skip(ftype)
17873 
      else:
17874 
        iprot.skip(ftype)
17875 
      iprot.readFieldEnd()
17876 
    iprot.readStructEnd()
17877 
 
17878 
  def write(self, oprot):
17879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17881 
      return
17882 
    oprot.writeStructBegin('getAllItemVouchers_result')
17883 
    if self.success is not None:
17884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17886 
      for iter366 in self.success:
17887 
        iter366.write(oprot)
5944 mandeep.dh 17888 
      oprot.writeListEnd()
17889 
      oprot.writeFieldEnd()
17890 
    oprot.writeFieldStop()
17891 
    oprot.writeStructEnd()
17892 
 
17893 
  def validate(self):
17894 
    return
17895 
 
17896 
 
17897 
  def __repr__(self):
17898 
    L = ['%s=%r' % (key, value)
17899 
      for key, value in self.__dict__.iteritems()]
17900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17901 
 
17902 
  def __eq__(self, other):
17903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17904 
 
17905 
  def __ne__(self, other):
17906 
    return not (self == other)
17907 
 
17908 
class isValidCatalogItemId_args:
17909 
  """
17910 
  Attributes:
17911 
   - catalog_item_id
17912 
  """
17913 
 
17914 
  thrift_spec = (
17915 
    None, # 0
17916 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17917 
  )
17918 
 
17919 
  def __init__(self, catalog_item_id=None,):
17920 
    self.catalog_item_id = catalog_item_id
17921 
 
17922 
  def read(self, iprot):
17923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17925 
      return
17926 
    iprot.readStructBegin()
17927 
    while True:
17928 
      (fname, ftype, fid) = iprot.readFieldBegin()
17929 
      if ftype == TType.STOP:
17930 
        break
17931 
      if fid == 1:
17932 
        if ftype == TType.I64:
17933 
          self.catalog_item_id = iprot.readI64();
17934 
        else:
17935 
          iprot.skip(ftype)
17936 
      else:
17937 
        iprot.skip(ftype)
17938 
      iprot.readFieldEnd()
17939 
    iprot.readStructEnd()
17940 
 
17941 
  def write(self, oprot):
17942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17944 
      return
17945 
    oprot.writeStructBegin('isValidCatalogItemId_args')
17946 
    if self.catalog_item_id is not None:
17947 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17948 
      oprot.writeI64(self.catalog_item_id)
17949 
      oprot.writeFieldEnd()
17950 
    oprot.writeFieldStop()
17951 
    oprot.writeStructEnd()
17952 
 
17953 
  def validate(self):
17954 
    return
17955 
 
17956 
 
17957 
  def __repr__(self):
17958 
    L = ['%s=%r' % (key, value)
17959 
      for key, value in self.__dict__.iteritems()]
17960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17961 
 
17962 
  def __eq__(self, other):
17963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17964 
 
17965 
  def __ne__(self, other):
17966 
    return not (self == other)
17967 
 
17968 
class isValidCatalogItemId_result:
17969 
  """
17970 
  Attributes:
17971 
   - success
17972 
  """
17973 
 
17974 
  thrift_spec = (
17975 
    (0, TType.BOOL, 'success', None, None, ), # 0
17976 
  )
17977 
 
17978 
  def __init__(self, success=None,):
17979 
    self.success = success
17980 
 
17981 
  def read(self, iprot):
17982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17984 
      return
17985 
    iprot.readStructBegin()
17986 
    while True:
17987 
      (fname, ftype, fid) = iprot.readFieldBegin()
17988 
      if ftype == TType.STOP:
17989 
        break
17990 
      if fid == 0:
17991 
        if ftype == TType.BOOL:
17992 
          self.success = iprot.readBool();
17993 
        else:
17994 
          iprot.skip(ftype)
17995 
      else:
17996 
        iprot.skip(ftype)
17997 
      iprot.readFieldEnd()
17998 
    iprot.readStructEnd()
17999 
 
18000 
  def write(self, oprot):
18001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18003 
      return
18004 
    oprot.writeStructBegin('isValidCatalogItemId_result')
18005 
    if self.success is not None:
18006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18007 
      oprot.writeBool(self.success)
18008 
      oprot.writeFieldEnd()
18009 
    oprot.writeFieldStop()
18010 
    oprot.writeStructEnd()
18011 
 
18012 
  def validate(self):
18013 
    return
18014 
 
18015 
 
18016 
  def __repr__(self):
18017 
    L = ['%s=%r' % (key, value)
18018 
      for key, value in self.__dict__.iteritems()]
18019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18020 
 
18021 
  def __eq__(self, other):
18022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18023 
 
18024 
  def __ne__(self, other):
18025 
    return not (self == other)
6039 amit.gupta 18026 
 
18027 
class getVatPercentageForItem_args:
18028 
  """
18029 
  Attributes:
18030 
   - itemId
7330 amit.gupta 18031 
   - stateId
6039 amit.gupta 18032 
   - price
18033 
  """
18034 
 
18035 
  thrift_spec = (
18036 
    None, # 0
18037 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 18038 
    (2, TType.I64, 'stateId', None, None, ), # 2
18039 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 18040 
  )
18041 
 
7330 amit.gupta 18042 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 18043 
    self.itemId = itemId
7330 amit.gupta 18044 
    self.stateId = stateId
6039 amit.gupta 18045 
    self.price = price
18046 
 
18047 
  def read(self, iprot):
18048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18050 
      return
18051 
    iprot.readStructBegin()
18052 
    while True:
18053 
      (fname, ftype, fid) = iprot.readFieldBegin()
18054 
      if ftype == TType.STOP:
18055 
        break
18056 
      if fid == 1:
18057 
        if ftype == TType.I64:
18058 
          self.itemId = iprot.readI64();
18059 
        else:
18060 
          iprot.skip(ftype)
18061 
      elif fid == 2:
7330 amit.gupta 18062 
        if ftype == TType.I64:
18063 
          self.stateId = iprot.readI64();
18064 
        else:
18065 
          iprot.skip(ftype)
18066 
      elif fid == 3:
6039 amit.gupta 18067 
        if ftype == TType.DOUBLE:
18068 
          self.price = iprot.readDouble();
18069 
        else:
18070 
          iprot.skip(ftype)
18071 
      else:
18072 
        iprot.skip(ftype)
18073 
      iprot.readFieldEnd()
18074 
    iprot.readStructEnd()
18075 
 
18076 
  def write(self, oprot):
18077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18079 
      return
18080 
    oprot.writeStructBegin('getVatPercentageForItem_args')
18081 
    if self.itemId is not None:
18082 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18083 
      oprot.writeI64(self.itemId)
18084 
      oprot.writeFieldEnd()
7330 amit.gupta 18085 
    if self.stateId is not None:
18086 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
18087 
      oprot.writeI64(self.stateId)
18088 
      oprot.writeFieldEnd()
6039 amit.gupta 18089 
    if self.price is not None:
7330 amit.gupta 18090 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 18091 
      oprot.writeDouble(self.price)
18092 
      oprot.writeFieldEnd()
18093 
    oprot.writeFieldStop()
18094 
    oprot.writeStructEnd()
18095 
 
18096 
  def validate(self):
18097 
    return
18098 
 
18099 
 
18100 
  def __repr__(self):
18101 
    L = ['%s=%r' % (key, value)
18102 
      for key, value in self.__dict__.iteritems()]
18103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18104 
 
18105 
  def __eq__(self, other):
18106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18107 
 
18108 
  def __ne__(self, other):
18109 
    return not (self == other)
18110 
 
18111 
class getVatPercentageForItem_result:
18112 
  """
18113 
  Attributes:
18114 
   - success
7340 amit.gupta 18115 
   - cex
6039 amit.gupta 18116 
  """
18117 
 
18118 
  thrift_spec = (
18119 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 18120 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 18121 
  )
18122 
 
7340 amit.gupta 18123 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 18124 
    self.success = success
7340 amit.gupta 18125 
    self.cex = cex
6039 amit.gupta 18126 
 
18127 
  def read(self, iprot):
18128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18130 
      return
18131 
    iprot.readStructBegin()
18132 
    while True:
18133 
      (fname, ftype, fid) = iprot.readFieldBegin()
18134 
      if ftype == TType.STOP:
18135 
        break
18136 
      if fid == 0:
18137 
        if ftype == TType.DOUBLE:
18138 
          self.success = iprot.readDouble();
18139 
        else:
18140 
          iprot.skip(ftype)
7340 amit.gupta 18141 
      elif fid == 1:
18142 
        if ftype == TType.STRUCT:
18143 
          self.cex = CatalogServiceException()
18144 
          self.cex.read(iprot)
18145 
        else:
18146 
          iprot.skip(ftype)
6039 amit.gupta 18147 
      else:
18148 
        iprot.skip(ftype)
18149 
      iprot.readFieldEnd()
18150 
    iprot.readStructEnd()
18151 
 
18152 
  def write(self, oprot):
18153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18155 
      return
18156 
    oprot.writeStructBegin('getVatPercentageForItem_result')
18157 
    if self.success is not None:
18158 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18159 
      oprot.writeDouble(self.success)
18160 
      oprot.writeFieldEnd()
7340 amit.gupta 18161 
    if self.cex is not None:
18162 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
18163 
      self.cex.write(oprot)
18164 
      oprot.writeFieldEnd()
6039 amit.gupta 18165 
    oprot.writeFieldStop()
18166 
    oprot.writeStructEnd()
18167 
 
18168 
  def validate(self):
18169 
    return
18170 
 
18171 
 
18172 
  def __repr__(self):
18173 
    L = ['%s=%r' % (key, value)
18174 
      for key, value in self.__dict__.iteritems()]
18175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18176 
 
18177 
  def __eq__(self, other):
18178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18179 
 
18180 
  def __ne__(self, other):
18181 
    return not (self == other)
18182 
 
18183 
class getVatAmountForItem_args:
18184 
  """
18185 
  Attributes:
18186 
   - itemId
18187 
   - price
18188 
  """
18189 
 
18190 
  thrift_spec = (
18191 
    None, # 0
18192 
    (1, TType.I64, 'itemId', None, None, ), # 1
18193 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18194 
  )
18195 
 
18196 
  def __init__(self, itemId=None, price=None,):
18197 
    self.itemId = itemId
18198 
    self.price = price
18199 
 
18200 
  def read(self, iprot):
18201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18203 
      return
18204 
    iprot.readStructBegin()
18205 
    while True:
18206 
      (fname, ftype, fid) = iprot.readFieldBegin()
18207 
      if ftype == TType.STOP:
18208 
        break
18209 
      if fid == 1:
18210 
        if ftype == TType.I64:
18211 
          self.itemId = iprot.readI64();
18212 
        else:
18213 
          iprot.skip(ftype)
18214 
      elif fid == 2:
18215 
        if ftype == TType.DOUBLE:
18216 
          self.price = iprot.readDouble();
18217 
        else:
18218 
          iprot.skip(ftype)
18219 
      else:
18220 
        iprot.skip(ftype)
18221 
      iprot.readFieldEnd()
18222 
    iprot.readStructEnd()
18223 
 
18224 
  def write(self, oprot):
18225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18227 
      return
18228 
    oprot.writeStructBegin('getVatAmountForItem_args')
18229 
    if self.itemId is not None:
18230 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18231 
      oprot.writeI64(self.itemId)
18232 
      oprot.writeFieldEnd()
18233 
    if self.price is not None:
18234 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18235 
      oprot.writeDouble(self.price)
18236 
      oprot.writeFieldEnd()
18237 
    oprot.writeFieldStop()
18238 
    oprot.writeStructEnd()
18239 
 
18240 
  def validate(self):
18241 
    return
18242 
 
18243 
 
18244 
  def __repr__(self):
18245 
    L = ['%s=%r' % (key, value)
18246 
      for key, value in self.__dict__.iteritems()]
18247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18248 
 
18249 
  def __eq__(self, other):
18250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18251 
 
18252 
  def __ne__(self, other):
18253 
    return not (self == other)
18254 
 
18255 
class getVatAmountForItem_result:
18256 
  """
18257 
  Attributes:
18258 
   - success
18259 
  """
18260 
 
18261 
  thrift_spec = (
18262 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
18263 
  )
18264 
 
18265 
  def __init__(self, success=None,):
18266 
    self.success = success
18267 
 
18268 
  def read(self, iprot):
18269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18271 
      return
18272 
    iprot.readStructBegin()
18273 
    while True:
18274 
      (fname, ftype, fid) = iprot.readFieldBegin()
18275 
      if ftype == TType.STOP:
18276 
        break
18277 
      if fid == 0:
18278 
        if ftype == TType.DOUBLE:
18279 
          self.success = iprot.readDouble();
18280 
        else:
18281 
          iprot.skip(ftype)
18282 
      else:
18283 
        iprot.skip(ftype)
18284 
      iprot.readFieldEnd()
18285 
    iprot.readStructEnd()
18286 
 
18287 
  def write(self, oprot):
18288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18290 
      return
18291 
    oprot.writeStructBegin('getVatAmountForItem_result')
18292 
    if self.success is not None:
18293 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
18294 
      oprot.writeDouble(self.success)
18295 
      oprot.writeFieldEnd()
18296 
    oprot.writeFieldStop()
18297 
    oprot.writeStructEnd()
18298 
 
18299 
  def validate(self):
18300 
    return
18301 
 
18302 
 
18303 
  def __repr__(self):
18304 
    L = ['%s=%r' % (key, value)
18305 
      for key, value in self.__dict__.iteritems()]
18306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18307 
 
18308 
  def __eq__(self, other):
18309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18310 
 
18311 
  def __ne__(self, other):
18312 
    return not (self == other)
6531 vikram.rag 18313 
 
18314 
class getAllIgnoredInventoryUpdateItemsList_args:
18315 
  """
18316 
  Attributes:
18317 
   - offset
18318 
   - limit
18319 
  """
18320 
 
18321 
  thrift_spec = (
18322 
    None, # 0
18323 
    (1, TType.I32, 'offset', None, None, ), # 1
18324 
    (2, TType.I32, 'limit', None, None, ), # 2
18325 
  )
18326 
 
18327 
  def __init__(self, offset=None, limit=None,):
18328 
    self.offset = offset
18329 
    self.limit = limit
18330 
 
18331 
  def read(self, iprot):
18332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18334 
      return
18335 
    iprot.readStructBegin()
18336 
    while True:
18337 
      (fname, ftype, fid) = iprot.readFieldBegin()
18338 
      if ftype == TType.STOP:
18339 
        break
18340 
      if fid == 1:
18341 
        if ftype == TType.I32:
18342 
          self.offset = iprot.readI32();
18343 
        else:
18344 
          iprot.skip(ftype)
18345 
      elif fid == 2:
18346 
        if ftype == TType.I32:
18347 
          self.limit = iprot.readI32();
18348 
        else:
18349 
          iprot.skip(ftype)
18350 
      else:
18351 
        iprot.skip(ftype)
18352 
      iprot.readFieldEnd()
18353 
    iprot.readStructEnd()
18354 
 
18355 
  def write(self, oprot):
18356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18358 
      return
18359 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
18360 
    if self.offset is not None:
18361 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18362 
      oprot.writeI32(self.offset)
18363 
      oprot.writeFieldEnd()
18364 
    if self.limit is not None:
18365 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18366 
      oprot.writeI32(self.limit)
18367 
      oprot.writeFieldEnd()
18368 
    oprot.writeFieldStop()
18369 
    oprot.writeStructEnd()
18370 
 
18371 
  def validate(self):
18372 
    return
18373 
 
18374 
 
18375 
  def __repr__(self):
18376 
    L = ['%s=%r' % (key, value)
18377 
      for key, value in self.__dict__.iteritems()]
18378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18379 
 
18380 
  def __eq__(self, other):
18381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18382 
 
18383 
  def __ne__(self, other):
18384 
    return not (self == other)
18385 
 
18386 
class getAllIgnoredInventoryUpdateItemsList_result:
18387 
  """
18388 
  Attributes:
18389 
   - success
18390 
  """
18391 
 
18392 
  thrift_spec = (
18393 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18394 
  )
18395 
 
18396 
  def __init__(self, success=None,):
18397 
    self.success = success
18398 
 
18399 
  def read(self, iprot):
18400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18402 
      return
18403 
    iprot.readStructBegin()
18404 
    while True:
18405 
      (fname, ftype, fid) = iprot.readFieldBegin()
18406 
      if ftype == TType.STOP:
18407 
        break
18408 
      if fid == 0:
18409 
        if ftype == TType.LIST:
18410 
          self.success = []
9155 kshitij.so 18411 
          (_etype370, _size367) = iprot.readListBegin()
18412 
          for _i371 in xrange(_size367):
18413 
            _elem372 = Item()
18414 
            _elem372.read(iprot)
18415 
            self.success.append(_elem372)
6531 vikram.rag 18416 
          iprot.readListEnd()
18417 
        else:
18418 
          iprot.skip(ftype)
18419 
      else:
18420 
        iprot.skip(ftype)
18421 
      iprot.readFieldEnd()
18422 
    iprot.readStructEnd()
18423 
 
18424 
  def write(self, oprot):
18425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18427 
      return
18428 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18429 
    if self.success is not None:
18430 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18431 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18432 
      for iter373 in self.success:
18433 
        iter373.write(oprot)
6531 vikram.rag 18434 
      oprot.writeListEnd()
18435 
      oprot.writeFieldEnd()
18436 
    oprot.writeFieldStop()
18437 
    oprot.writeStructEnd()
18438 
 
18439 
  def validate(self):
18440 
    return
18441 
 
18442 
 
18443 
  def __repr__(self):
18444 
    L = ['%s=%r' % (key, value)
18445 
      for key, value in self.__dict__.iteritems()]
18446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18447 
 
18448 
  def __eq__(self, other):
18449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18450 
 
18451 
  def __ne__(self, other):
18452 
    return not (self == other)
6805 anupam.sin 18453 
 
6821 amar.kumar 18454 
class getAllAliveItems_args:
18455 
 
18456 
  thrift_spec = (
18457 
  )
18458 
 
18459 
  def read(self, iprot):
18460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18462 
      return
18463 
    iprot.readStructBegin()
18464 
    while True:
18465 
      (fname, ftype, fid) = iprot.readFieldBegin()
18466 
      if ftype == TType.STOP:
18467 
        break
18468 
      else:
18469 
        iprot.skip(ftype)
18470 
      iprot.readFieldEnd()
18471 
    iprot.readStructEnd()
18472 
 
18473 
  def write(self, oprot):
18474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18476 
      return
18477 
    oprot.writeStructBegin('getAllAliveItems_args')
18478 
    oprot.writeFieldStop()
18479 
    oprot.writeStructEnd()
18480 
 
18481 
  def validate(self):
18482 
    return
18483 
 
18484 
 
18485 
  def __repr__(self):
18486 
    L = ['%s=%r' % (key, value)
18487 
      for key, value in self.__dict__.iteritems()]
18488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18489 
 
18490 
  def __eq__(self, other):
18491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18492 
 
18493 
  def __ne__(self, other):
18494 
    return not (self == other)
18495 
 
18496 
class getAllAliveItems_result:
18497 
  """
18498 
  Attributes:
18499 
   - success
18500 
  """
18501 
 
18502 
  thrift_spec = (
18503 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18504 
  )
18505 
 
18506 
  def __init__(self, success=None,):
18507 
    self.success = success
18508 
 
18509 
  def read(self, iprot):
18510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18512 
      return
18513 
    iprot.readStructBegin()
18514 
    while True:
18515 
      (fname, ftype, fid) = iprot.readFieldBegin()
18516 
      if ftype == TType.STOP:
18517 
        break
18518 
      if fid == 0:
18519 
        if ftype == TType.LIST:
18520 
          self.success = []
9155 kshitij.so 18521 
          (_etype377, _size374) = iprot.readListBegin()
18522 
          for _i378 in xrange(_size374):
18523 
            _elem379 = Item()
18524 
            _elem379.read(iprot)
18525 
            self.success.append(_elem379)
6821 amar.kumar 18526 
          iprot.readListEnd()
18527 
        else:
18528 
          iprot.skip(ftype)
18529 
      else:
18530 
        iprot.skip(ftype)
18531 
      iprot.readFieldEnd()
18532 
    iprot.readStructEnd()
18533 
 
18534 
  def write(self, oprot):
18535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18537 
      return
18538 
    oprot.writeStructBegin('getAllAliveItems_result')
18539 
    if self.success is not None:
18540 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18541 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18542 
      for iter380 in self.success:
18543 
        iter380.write(oprot)
6821 amar.kumar 18544 
      oprot.writeListEnd()
18545 
      oprot.writeFieldEnd()
18546 
    oprot.writeFieldStop()
18547 
    oprot.writeStructEnd()
18548 
 
18549 
  def validate(self):
18550 
    return
18551 
 
18552 
 
18553 
  def __repr__(self):
18554 
    L = ['%s=%r' % (key, value)
18555 
      for key, value in self.__dict__.iteritems()]
18556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18557 
 
18558 
  def __eq__(self, other):
18559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18560 
 
18561 
  def __ne__(self, other):
18562 
    return not (self == other)
18563 
 
6805 anupam.sin 18564 
class getInsuranceAmount_args:
18565 
  """
18566 
  Attributes:
18567 
   - itemId
6921 anupam.sin 18568 
   - price
6805 anupam.sin 18569 
   - insurerId
18570 
   - quantity
18571 
  """
18572 
 
18573 
  thrift_spec = (
18574 
    None, # 0
18575 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18576 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18577 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18578 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18579 
  )
18580 
 
6921 anupam.sin 18581 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18582 
    self.itemId = itemId
6921 anupam.sin 18583 
    self.price = price
6805 anupam.sin 18584 
    self.insurerId = insurerId
18585 
    self.quantity = quantity
18586 
 
18587 
  def read(self, iprot):
18588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18590 
      return
18591 
    iprot.readStructBegin()
18592 
    while True:
18593 
      (fname, ftype, fid) = iprot.readFieldBegin()
18594 
      if ftype == TType.STOP:
18595 
        break
18596 
      if fid == 1:
18597 
        if ftype == TType.I64:
18598 
          self.itemId = iprot.readI64();
18599 
        else:
18600 
          iprot.skip(ftype)
18601 
      elif fid == 2:
6921 anupam.sin 18602 
        if ftype == TType.DOUBLE:
18603 
          self.price = iprot.readDouble();
18604 
        else:
18605 
          iprot.skip(ftype)
18606 
      elif fid == 3:
6805 anupam.sin 18607 
        if ftype == TType.I64:
18608 
          self.insurerId = iprot.readI64();
18609 
        else:
18610 
          iprot.skip(ftype)
6921 anupam.sin 18611 
      elif fid == 4:
6805 anupam.sin 18612 
        if ftype == TType.I64:
18613 
          self.quantity = iprot.readI64();
18614 
        else:
18615 
          iprot.skip(ftype)
18616 
      else:
18617 
        iprot.skip(ftype)
18618 
      iprot.readFieldEnd()
18619 
    iprot.readStructEnd()
18620 
 
18621 
  def write(self, oprot):
18622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18624 
      return
18625 
    oprot.writeStructBegin('getInsuranceAmount_args')
18626 
    if self.itemId is not None:
18627 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18628 
      oprot.writeI64(self.itemId)
18629 
      oprot.writeFieldEnd()
6921 anupam.sin 18630 
    if self.price is not None:
18631 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18632 
      oprot.writeDouble(self.price)
18633 
      oprot.writeFieldEnd()
6805 anupam.sin 18634 
    if self.insurerId is not None:
6921 anupam.sin 18635 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18636 
      oprot.writeI64(self.insurerId)
18637 
      oprot.writeFieldEnd()
18638 
    if self.quantity is not None:
6921 anupam.sin 18639 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18640 
      oprot.writeI64(self.quantity)
18641 
      oprot.writeFieldEnd()
18642 
    oprot.writeFieldStop()
18643 
    oprot.writeStructEnd()
18644 
 
18645 
  def validate(self):
18646 
    return
18647 
 
18648 
 
18649 
  def __repr__(self):
18650 
    L = ['%s=%r' % (key, value)
18651 
      for key, value in self.__dict__.iteritems()]
18652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18653 
 
18654 
  def __eq__(self, other):
18655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18656 
 
18657 
  def __ne__(self, other):
18658 
    return not (self == other)
18659 
 
18660 
class getInsuranceAmount_result:
18661 
  """
18662 
  Attributes:
18663 
   - success
18664 
  """
18665 
 
18666 
  thrift_spec = (
18667 
    (0, TType.I64, 'success', None, None, ), # 0
18668 
  )
18669 
 
18670 
  def __init__(self, success=None,):
18671 
    self.success = success
18672 
 
18673 
  def read(self, iprot):
18674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18676 
      return
18677 
    iprot.readStructBegin()
18678 
    while True:
18679 
      (fname, ftype, fid) = iprot.readFieldBegin()
18680 
      if ftype == TType.STOP:
18681 
        break
18682 
      if fid == 0:
18683 
        if ftype == TType.I64:
18684 
          self.success = iprot.readI64();
18685 
        else:
18686 
          iprot.skip(ftype)
18687 
      else:
18688 
        iprot.skip(ftype)
18689 
      iprot.readFieldEnd()
18690 
    iprot.readStructEnd()
18691 
 
18692 
  def write(self, oprot):
18693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18695 
      return
18696 
    oprot.writeStructBegin('getInsuranceAmount_result')
18697 
    if self.success is not None:
18698 
      oprot.writeFieldBegin('success', TType.I64, 0)
18699 
      oprot.writeI64(self.success)
18700 
      oprot.writeFieldEnd()
18701 
    oprot.writeFieldStop()
18702 
    oprot.writeStructEnd()
18703 
 
18704 
  def validate(self):
18705 
    return
18706 
 
18707 
 
18708 
  def __repr__(self):
18709 
    L = ['%s=%r' % (key, value)
18710 
      for key, value in self.__dict__.iteritems()]
18711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18712 
 
18713 
  def __eq__(self, other):
18714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18715 
 
18716 
  def __ne__(self, other):
18717 
    return not (self == other)
18718 
 
18719 
class getInsurer_args:
18720 
  """
18721 
  Attributes:
18722 
   - insurerId
18723 
  """
18724 
 
18725 
  thrift_spec = (
18726 
    None, # 0
18727 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18728 
  )
18729 
 
18730 
  def __init__(self, insurerId=None,):
18731 
    self.insurerId = insurerId
18732 
 
18733 
  def read(self, iprot):
18734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18736 
      return
18737 
    iprot.readStructBegin()
18738 
    while True:
18739 
      (fname, ftype, fid) = iprot.readFieldBegin()
18740 
      if ftype == TType.STOP:
18741 
        break
18742 
      if fid == 1:
18743 
        if ftype == TType.I64:
18744 
          self.insurerId = iprot.readI64();
18745 
        else:
18746 
          iprot.skip(ftype)
18747 
      else:
18748 
        iprot.skip(ftype)
18749 
      iprot.readFieldEnd()
18750 
    iprot.readStructEnd()
18751 
 
18752 
  def write(self, oprot):
18753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18755 
      return
18756 
    oprot.writeStructBegin('getInsurer_args')
18757 
    if self.insurerId is not None:
18758 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18759 
      oprot.writeI64(self.insurerId)
18760 
      oprot.writeFieldEnd()
18761 
    oprot.writeFieldStop()
18762 
    oprot.writeStructEnd()
18763 
 
18764 
  def validate(self):
18765 
    return
18766 
 
18767 
 
18768 
  def __repr__(self):
18769 
    L = ['%s=%r' % (key, value)
18770 
      for key, value in self.__dict__.iteritems()]
18771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18772 
 
18773 
  def __eq__(self, other):
18774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18775 
 
18776 
  def __ne__(self, other):
18777 
    return not (self == other)
18778 
 
18779 
class getInsurer_result:
18780 
  """
18781 
  Attributes:
18782 
   - success
18783 
  """
18784 
 
18785 
  thrift_spec = (
18786 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
18787 
  )
18788 
 
18789 
  def __init__(self, success=None,):
18790 
    self.success = success
18791 
 
18792 
  def read(self, iprot):
18793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18795 
      return
18796 
    iprot.readStructBegin()
18797 
    while True:
18798 
      (fname, ftype, fid) = iprot.readFieldBegin()
18799 
      if ftype == TType.STOP:
18800 
        break
18801 
      if fid == 0:
18802 
        if ftype == TType.STRUCT:
18803 
          self.success = Insurer()
18804 
          self.success.read(iprot)
18805 
        else:
18806 
          iprot.skip(ftype)
18807 
      else:
18808 
        iprot.skip(ftype)
18809 
      iprot.readFieldEnd()
18810 
    iprot.readStructEnd()
18811 
 
18812 
  def write(self, oprot):
18813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18815 
      return
18816 
    oprot.writeStructBegin('getInsurer_result')
18817 
    if self.success is not None:
18818 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18819 
      self.success.write(oprot)
18820 
      oprot.writeFieldEnd()
18821 
    oprot.writeFieldStop()
18822 
    oprot.writeStructEnd()
18823 
 
18824 
  def validate(self):
18825 
    return
18826 
 
18827 
 
18828 
  def __repr__(self):
18829 
    L = ['%s=%r' % (key, value)
18830 
      for key, value in self.__dict__.iteritems()]
18831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18832 
 
18833 
  def __eq__(self, other):
18834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18835 
 
18836 
  def __ne__(self, other):
18837 
    return not (self == other)
6838 vikram.rag 18838 
 
18839 
class getAllInsurers_args:
18840 
 
18841 
  thrift_spec = (
18842 
  )
18843 
 
18844 
  def read(self, iprot):
18845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18847 
      return
18848 
    iprot.readStructBegin()
18849 
    while True:
18850 
      (fname, ftype, fid) = iprot.readFieldBegin()
18851 
      if ftype == TType.STOP:
18852 
        break
18853 
      else:
18854 
        iprot.skip(ftype)
18855 
      iprot.readFieldEnd()
18856 
    iprot.readStructEnd()
18857 
 
18858 
  def write(self, oprot):
18859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18861 
      return
18862 
    oprot.writeStructBegin('getAllInsurers_args')
18863 
    oprot.writeFieldStop()
18864 
    oprot.writeStructEnd()
18865 
 
18866 
  def validate(self):
18867 
    return
18868 
 
18869 
 
18870 
  def __repr__(self):
18871 
    L = ['%s=%r' % (key, value)
18872 
      for key, value in self.__dict__.iteritems()]
18873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18874 
 
18875 
  def __eq__(self, other):
18876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18877 
 
18878 
  def __ne__(self, other):
18879 
    return not (self == other)
18880 
 
18881 
class getAllInsurers_result:
18882 
  """
18883 
  Attributes:
18884 
   - success
18885 
  """
18886 
 
18887 
  thrift_spec = (
18888 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
18889 
  )
18890 
 
18891 
  def __init__(self, success=None,):
18892 
    self.success = success
18893 
 
18894 
  def read(self, iprot):
18895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18897 
      return
18898 
    iprot.readStructBegin()
18899 
    while True:
18900 
      (fname, ftype, fid) = iprot.readFieldBegin()
18901 
      if ftype == TType.STOP:
18902 
        break
18903 
      if fid == 0:
18904 
        if ftype == TType.LIST:
18905 
          self.success = []
9155 kshitij.so 18906 
          (_etype384, _size381) = iprot.readListBegin()
18907 
          for _i385 in xrange(_size381):
18908 
            _elem386 = Insurer()
18909 
            _elem386.read(iprot)
18910 
            self.success.append(_elem386)
6838 vikram.rag 18911 
          iprot.readListEnd()
18912 
        else:
18913 
          iprot.skip(ftype)
18914 
      else:
18915 
        iprot.skip(ftype)
18916 
      iprot.readFieldEnd()
18917 
    iprot.readStructEnd()
18918 
 
18919 
  def write(self, oprot):
18920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18922 
      return
18923 
    oprot.writeStructBegin('getAllInsurers_result')
18924 
    if self.success is not None:
18925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18927 
      for iter387 in self.success:
18928 
        iter387.write(oprot)
6838 vikram.rag 18929 
      oprot.writeListEnd()
18930 
      oprot.writeFieldEnd()
18931 
    oprot.writeFieldStop()
18932 
    oprot.writeStructEnd()
18933 
 
18934 
  def validate(self):
18935 
    return
18936 
 
18937 
 
18938 
  def __repr__(self):
18939 
    L = ['%s=%r' % (key, value)
18940 
      for key, value in self.__dict__.iteritems()]
18941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18942 
 
18943 
  def __eq__(self, other):
18944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18945 
 
18946 
  def __ne__(self, other):
18947 
    return not (self == other)
6962 rajveer 18948 
 
18949 
class updateInsuranceDeclaredAmount_args:
18950 
  """
18951 
  Attributes:
18952 
   - insurerId
18953 
   - amount
18954 
  """
18955 
 
18956 
  thrift_spec = (
18957 
    None, # 0
18958 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18959 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
18960 
  )
18961 
 
18962 
  def __init__(self, insurerId=None, amount=None,):
18963 
    self.insurerId = insurerId
18964 
    self.amount = amount
18965 
 
18966 
  def read(self, iprot):
18967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18969 
      return
18970 
    iprot.readStructBegin()
18971 
    while True:
18972 
      (fname, ftype, fid) = iprot.readFieldBegin()
18973 
      if ftype == TType.STOP:
18974 
        break
18975 
      if fid == 1:
18976 
        if ftype == TType.I64:
18977 
          self.insurerId = iprot.readI64();
18978 
        else:
18979 
          iprot.skip(ftype)
18980 
      elif fid == 2:
18981 
        if ftype == TType.DOUBLE:
18982 
          self.amount = iprot.readDouble();
18983 
        else:
18984 
          iprot.skip(ftype)
18985 
      else:
18986 
        iprot.skip(ftype)
18987 
      iprot.readFieldEnd()
18988 
    iprot.readStructEnd()
18989 
 
18990 
  def write(self, oprot):
18991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18993 
      return
18994 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
18995 
    if self.insurerId is not None:
18996 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18997 
      oprot.writeI64(self.insurerId)
18998 
      oprot.writeFieldEnd()
18999 
    if self.amount is not None:
19000 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
19001 
      oprot.writeDouble(self.amount)
19002 
      oprot.writeFieldEnd()
19003 
    oprot.writeFieldStop()
19004 
    oprot.writeStructEnd()
19005 
 
19006 
  def validate(self):
19007 
    return
19008 
 
19009 
 
19010 
  def __repr__(self):
19011 
    L = ['%s=%r' % (key, value)
19012 
      for key, value in self.__dict__.iteritems()]
19013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19014 
 
19015 
  def __eq__(self, other):
19016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19017 
 
19018 
  def __ne__(self, other):
19019 
    return not (self == other)
19020 
 
19021 
class updateInsuranceDeclaredAmount_result:
19022 
 
19023 
  thrift_spec = (
19024 
  )
19025 
 
19026 
  def read(self, iprot):
19027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19029 
      return
19030 
    iprot.readStructBegin()
19031 
    while True:
19032 
      (fname, ftype, fid) = iprot.readFieldBegin()
19033 
      if ftype == TType.STOP:
19034 
        break
19035 
      else:
19036 
        iprot.skip(ftype)
19037 
      iprot.readFieldEnd()
19038 
    iprot.readStructEnd()
19039 
 
19040 
  def write(self, oprot):
19041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19043 
      return
19044 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
19045 
    oprot.writeFieldStop()
19046 
    oprot.writeStructEnd()
19047 
 
19048 
  def validate(self):
19049 
    return
19050 
 
19051 
 
19052 
  def __repr__(self):
19053 
    L = ['%s=%r' % (key, value)
19054 
      for key, value in self.__dict__.iteritems()]
19055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19056 
 
19057 
  def __eq__(self, other):
19058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19059 
 
19060 
  def __ne__(self, other):
19061 
    return not (self == other)
7190 amar.kumar 19062 
 
19063 
class getFreebieForItem_args:
19064 
  """
19065 
  Attributes:
19066 
   - itemId
19067 
  """
19068 
 
19069 
  thrift_spec = (
19070 
    None, # 0
19071 
    (1, TType.I64, 'itemId', None, None, ), # 1
19072 
  )
19073 
 
19074 
  def __init__(self, itemId=None,):
19075 
    self.itemId = itemId
19076 
 
19077 
  def read(self, iprot):
19078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19080 
      return
19081 
    iprot.readStructBegin()
19082 
    while True:
19083 
      (fname, ftype, fid) = iprot.readFieldBegin()
19084 
      if ftype == TType.STOP:
19085 
        break
19086 
      if fid == 1:
19087 
        if ftype == TType.I64:
19088 
          self.itemId = iprot.readI64();
19089 
        else:
19090 
          iprot.skip(ftype)
19091 
      else:
19092 
        iprot.skip(ftype)
19093 
      iprot.readFieldEnd()
19094 
    iprot.readStructEnd()
19095 
 
19096 
  def write(self, oprot):
19097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19099 
      return
19100 
    oprot.writeStructBegin('getFreebieForItem_args')
19101 
    if self.itemId is not None:
19102 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19103 
      oprot.writeI64(self.itemId)
19104 
      oprot.writeFieldEnd()
19105 
    oprot.writeFieldStop()
19106 
    oprot.writeStructEnd()
19107 
 
19108 
  def validate(self):
19109 
    return
19110 
 
19111 
 
19112 
  def __repr__(self):
19113 
    L = ['%s=%r' % (key, value)
19114 
      for key, value in self.__dict__.iteritems()]
19115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19116 
 
19117 
  def __eq__(self, other):
19118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19119 
 
19120 
  def __ne__(self, other):
19121 
    return not (self == other)
19122 
 
19123 
class getFreebieForItem_result:
19124 
  """
19125 
  Attributes:
19126 
   - success
19127 
  """
19128 
 
19129 
  thrift_spec = (
19130 
    (0, TType.I64, 'success', None, None, ), # 0
19131 
  )
19132 
 
19133 
  def __init__(self, success=None,):
19134 
    self.success = success
19135 
 
19136 
  def read(self, iprot):
19137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19139 
      return
19140 
    iprot.readStructBegin()
19141 
    while True:
19142 
      (fname, ftype, fid) = iprot.readFieldBegin()
19143 
      if ftype == TType.STOP:
19144 
        break
19145 
      if fid == 0:
19146 
        if ftype == TType.I64:
19147 
          self.success = iprot.readI64();
19148 
        else:
19149 
          iprot.skip(ftype)
19150 
      else:
19151 
        iprot.skip(ftype)
19152 
      iprot.readFieldEnd()
19153 
    iprot.readStructEnd()
19154 
 
19155 
  def write(self, oprot):
19156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19158 
      return
19159 
    oprot.writeStructBegin('getFreebieForItem_result')
19160 
    if self.success is not None:
19161 
      oprot.writeFieldBegin('success', TType.I64, 0)
19162 
      oprot.writeI64(self.success)
19163 
      oprot.writeFieldEnd()
19164 
    oprot.writeFieldStop()
19165 
    oprot.writeStructEnd()
19166 
 
19167 
  def validate(self):
19168 
    return
19169 
 
19170 
 
19171 
  def __repr__(self):
19172 
    L = ['%s=%r' % (key, value)
19173 
      for key, value in self.__dict__.iteritems()]
19174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19175 
 
19176 
  def __eq__(self, other):
19177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19178 
 
19179 
  def __ne__(self, other):
19180 
    return not (self == other)
19181 
 
19182 
class addOrUpdateFreebieForItem_args:
19183 
  """
19184 
  Attributes:
19185 
   - freebieItem
19186 
  """
19187 
 
19188 
  thrift_spec = (
19189 
    None, # 0
19190 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
19191 
  )
19192 
 
19193 
  def __init__(self, freebieItem=None,):
19194 
    self.freebieItem = freebieItem
19195 
 
19196 
  def read(self, iprot):
19197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19199 
      return
19200 
    iprot.readStructBegin()
19201 
    while True:
19202 
      (fname, ftype, fid) = iprot.readFieldBegin()
19203 
      if ftype == TType.STOP:
19204 
        break
19205 
      if fid == 1:
19206 
        if ftype == TType.STRUCT:
19207 
          self.freebieItem = FreebieItem()
19208 
          self.freebieItem.read(iprot)
19209 
        else:
19210 
          iprot.skip(ftype)
19211 
      else:
19212 
        iprot.skip(ftype)
19213 
      iprot.readFieldEnd()
19214 
    iprot.readStructEnd()
19215 
 
19216 
  def write(self, oprot):
19217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19219 
      return
19220 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
19221 
    if self.freebieItem is not None:
19222 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
19223 
      self.freebieItem.write(oprot)
19224 
      oprot.writeFieldEnd()
19225 
    oprot.writeFieldStop()
19226 
    oprot.writeStructEnd()
19227 
 
19228 
  def validate(self):
19229 
    return
19230 
 
19231 
 
19232 
  def __repr__(self):
19233 
    L = ['%s=%r' % (key, value)
19234 
      for key, value in self.__dict__.iteritems()]
19235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19236 
 
19237 
  def __eq__(self, other):
19238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19239 
 
19240 
  def __ne__(self, other):
19241 
    return not (self == other)
19242 
 
19243 
class addOrUpdateFreebieForItem_result:
19244 
 
19245 
  thrift_spec = (
19246 
  )
19247 
 
19248 
  def read(self, iprot):
19249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19251 
      return
19252 
    iprot.readStructBegin()
19253 
    while True:
19254 
      (fname, ftype, fid) = iprot.readFieldBegin()
19255 
      if ftype == TType.STOP:
19256 
        break
19257 
      else:
19258 
        iprot.skip(ftype)
19259 
      iprot.readFieldEnd()
19260 
    iprot.readStructEnd()
19261 
 
19262 
  def write(self, oprot):
19263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19265 
      return
19266 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
19267 
    oprot.writeFieldStop()
19268 
    oprot.writeStructEnd()
19269 
 
19270 
  def validate(self):
19271 
    return
19272 
 
19273 
 
19274 
  def __repr__(self):
19275 
    L = ['%s=%r' % (key, value)
19276 
      for key, value in self.__dict__.iteritems()]
19277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19278 
 
19279 
  def __eq__(self, other):
19280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19281 
 
19282 
  def __ne__(self, other):
19283 
    return not (self == other)
7256 rajveer 19284 
 
7272 amit.gupta 19285 
class addOrUpdateBrandInfo_args:
19286 
  """
19287 
  Attributes:
19288 
   - brandInfo
19289 
  """
19290 
 
19291 
  thrift_spec = (
19292 
    None, # 0
19293 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
19294 
  )
19295 
 
19296 
  def __init__(self, brandInfo=None,):
19297 
    self.brandInfo = brandInfo
19298 
 
19299 
  def read(self, iprot):
19300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19302 
      return
19303 
    iprot.readStructBegin()
19304 
    while True:
19305 
      (fname, ftype, fid) = iprot.readFieldBegin()
19306 
      if ftype == TType.STOP:
19307 
        break
19308 
      if fid == 1:
19309 
        if ftype == TType.STRUCT:
19310 
          self.brandInfo = BrandInfo()
19311 
          self.brandInfo.read(iprot)
19312 
        else:
19313 
          iprot.skip(ftype)
19314 
      else:
19315 
        iprot.skip(ftype)
19316 
      iprot.readFieldEnd()
19317 
    iprot.readStructEnd()
19318 
 
19319 
  def write(self, oprot):
19320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19322 
      return
19323 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
19324 
    if self.brandInfo is not None:
19325 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
19326 
      self.brandInfo.write(oprot)
19327 
      oprot.writeFieldEnd()
19328 
    oprot.writeFieldStop()
19329 
    oprot.writeStructEnd()
19330 
 
19331 
  def validate(self):
19332 
    return
19333 
 
19334 
 
19335 
  def __repr__(self):
19336 
    L = ['%s=%r' % (key, value)
19337 
      for key, value in self.__dict__.iteritems()]
19338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19339 
 
19340 
  def __eq__(self, other):
19341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19342 
 
19343 
  def __ne__(self, other):
19344 
    return not (self == other)
19345 
 
19346 
class addOrUpdateBrandInfo_result:
19347 
 
19348 
  thrift_spec = (
19349 
  )
19350 
 
19351 
  def read(self, iprot):
19352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19354 
      return
19355 
    iprot.readStructBegin()
19356 
    while True:
19357 
      (fname, ftype, fid) = iprot.readFieldBegin()
19358 
      if ftype == TType.STOP:
19359 
        break
19360 
      else:
19361 
        iprot.skip(ftype)
19362 
      iprot.readFieldEnd()
19363 
    iprot.readStructEnd()
19364 
 
19365 
  def write(self, oprot):
19366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19368 
      return
19369 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19370 
    oprot.writeFieldStop()
19371 
    oprot.writeStructEnd()
19372 
 
19373 
  def validate(self):
19374 
    return
19375 
 
19376 
 
19377 
  def __repr__(self):
19378 
    L = ['%s=%r' % (key, value)
19379 
      for key, value in self.__dict__.iteritems()]
19380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19381 
 
19382 
  def __eq__(self, other):
19383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19384 
 
19385 
  def __ne__(self, other):
19386 
    return not (self == other)
19387 
 
19388 
class getBrandInfo_args:
19389 
 
19390 
  thrift_spec = (
19391 
  )
19392 
 
19393 
  def read(self, iprot):
19394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19396 
      return
19397 
    iprot.readStructBegin()
19398 
    while True:
19399 
      (fname, ftype, fid) = iprot.readFieldBegin()
19400 
      if ftype == TType.STOP:
19401 
        break
19402 
      else:
19403 
        iprot.skip(ftype)
19404 
      iprot.readFieldEnd()
19405 
    iprot.readStructEnd()
19406 
 
19407 
  def write(self, oprot):
19408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19410 
      return
19411 
    oprot.writeStructBegin('getBrandInfo_args')
19412 
    oprot.writeFieldStop()
19413 
    oprot.writeStructEnd()
19414 
 
19415 
  def validate(self):
19416 
    return
19417 
 
19418 
 
19419 
  def __repr__(self):
19420 
    L = ['%s=%r' % (key, value)
19421 
      for key, value in self.__dict__.iteritems()]
19422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19423 
 
19424 
  def __eq__(self, other):
19425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19426 
 
19427 
  def __ne__(self, other):
19428 
    return not (self == other)
19429 
 
19430 
class getBrandInfo_result:
19431 
  """
19432 
  Attributes:
19433 
   - success
19434 
  """
19435 
 
19436 
  thrift_spec = (
19437 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19438 
  )
19439 
 
19440 
  def __init__(self, success=None,):
19441 
    self.success = success
19442 
 
19443 
  def read(self, iprot):
19444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19446 
      return
19447 
    iprot.readStructBegin()
19448 
    while True:
19449 
      (fname, ftype, fid) = iprot.readFieldBegin()
19450 
      if ftype == TType.STOP:
19451 
        break
19452 
      if fid == 0:
19453 
        if ftype == TType.MAP:
19454 
          self.success = {}
9155 kshitij.so 19455 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19456 
          for _i392 in xrange(_size388):
19457 
            _key393 = iprot.readString();
19458 
            _val394 = BrandInfo()
19459 
            _val394.read(iprot)
19460 
            self.success[_key393] = _val394
7272 amit.gupta 19461 
          iprot.readMapEnd()
19462 
        else:
19463 
          iprot.skip(ftype)
19464 
      else:
19465 
        iprot.skip(ftype)
19466 
      iprot.readFieldEnd()
19467 
    iprot.readStructEnd()
19468 
 
19469 
  def write(self, oprot):
19470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19472 
      return
19473 
    oprot.writeStructBegin('getBrandInfo_result')
19474 
    if self.success is not None:
19475 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19476 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19477 
      for kiter395,viter396 in self.success.items():
19478 
        oprot.writeString(kiter395)
19479 
        viter396.write(oprot)
7272 amit.gupta 19480 
      oprot.writeMapEnd()
19481 
      oprot.writeFieldEnd()
19482 
    oprot.writeFieldStop()
19483 
    oprot.writeStructEnd()
19484 
 
19485 
  def validate(self):
19486 
    return
19487 
 
19488 
 
19489 
  def __repr__(self):
19490 
    L = ['%s=%r' % (key, value)
19491 
      for key, value in self.__dict__.iteritems()]
19492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19493 
 
19494 
  def __eq__(self, other):
19495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19496 
 
19497 
  def __ne__(self, other):
19498 
    return not (self == other)
19499 
 
7256 rajveer 19500 
class getStorePricing_args:
19501 
  """
19502 
  Attributes:
19503 
   - itemId
19504 
  """
19505 
 
19506 
  thrift_spec = (
19507 
    None, # 0
19508 
    (1, TType.I64, 'itemId', None, None, ), # 1
19509 
  )
19510 
 
19511 
  def __init__(self, itemId=None,):
19512 
    self.itemId = itemId
19513 
 
19514 
  def read(self, iprot):
19515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19517 
      return
19518 
    iprot.readStructBegin()
19519 
    while True:
19520 
      (fname, ftype, fid) = iprot.readFieldBegin()
19521 
      if ftype == TType.STOP:
19522 
        break
19523 
      if fid == 1:
19524 
        if ftype == TType.I64:
19525 
          self.itemId = iprot.readI64();
19526 
        else:
19527 
          iprot.skip(ftype)
19528 
      else:
19529 
        iprot.skip(ftype)
19530 
      iprot.readFieldEnd()
19531 
    iprot.readStructEnd()
19532 
 
19533 
  def write(self, oprot):
19534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19536 
      return
19537 
    oprot.writeStructBegin('getStorePricing_args')
19538 
    if self.itemId is not None:
19539 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19540 
      oprot.writeI64(self.itemId)
19541 
      oprot.writeFieldEnd()
19542 
    oprot.writeFieldStop()
19543 
    oprot.writeStructEnd()
19544 
 
19545 
  def validate(self):
19546 
    return
19547 
 
19548 
 
19549 
  def __repr__(self):
19550 
    L = ['%s=%r' % (key, value)
19551 
      for key, value in self.__dict__.iteritems()]
19552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19553 
 
19554 
  def __eq__(self, other):
19555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19556 
 
19557 
  def __ne__(self, other):
19558 
    return not (self == other)
19559 
 
19560 
class getStorePricing_result:
19561 
  """
19562 
  Attributes:
19563 
   - success
19564 
  """
19565 
 
19566 
  thrift_spec = (
19567 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19568 
  )
19569 
 
19570 
  def __init__(self, success=None,):
19571 
    self.success = success
19572 
 
19573 
  def read(self, iprot):
19574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19576 
      return
19577 
    iprot.readStructBegin()
19578 
    while True:
19579 
      (fname, ftype, fid) = iprot.readFieldBegin()
19580 
      if ftype == TType.STOP:
19581 
        break
19582 
      if fid == 0:
19583 
        if ftype == TType.STRUCT:
19584 
          self.success = StorePricing()
19585 
          self.success.read(iprot)
19586 
        else:
19587 
          iprot.skip(ftype)
19588 
      else:
19589 
        iprot.skip(ftype)
19590 
      iprot.readFieldEnd()
19591 
    iprot.readStructEnd()
19592 
 
19593 
  def write(self, oprot):
19594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19596 
      return
19597 
    oprot.writeStructBegin('getStorePricing_result')
19598 
    if self.success is not None:
19599 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19600 
      self.success.write(oprot)
19601 
      oprot.writeFieldEnd()
19602 
    oprot.writeFieldStop()
19603 
    oprot.writeStructEnd()
19604 
 
19605 
  def validate(self):
19606 
    return
19607 
 
19608 
 
19609 
  def __repr__(self):
19610 
    L = ['%s=%r' % (key, value)
19611 
      for key, value in self.__dict__.iteritems()]
19612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19613 
 
19614 
  def __eq__(self, other):
19615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19616 
 
19617 
  def __ne__(self, other):
19618 
    return not (self == other)
7265 rajveer 19619 
 
7306 rajveer 19620 
class getStorePricings_args:
19621 
  """
19622 
  Attributes:
19623 
   - itemIds
19624 
  """
19625 
 
19626 
  thrift_spec = (
19627 
    None, # 0
19628 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19629 
  )
19630 
 
19631 
  def __init__(self, itemIds=None,):
19632 
    self.itemIds = itemIds
19633 
 
19634 
  def read(self, iprot):
19635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19637 
      return
19638 
    iprot.readStructBegin()
19639 
    while True:
19640 
      (fname, ftype, fid) = iprot.readFieldBegin()
19641 
      if ftype == TType.STOP:
19642 
        break
19643 
      if fid == 1:
19644 
        if ftype == TType.LIST:
19645 
          self.itemIds = []
9155 kshitij.so 19646 
          (_etype400, _size397) = iprot.readListBegin()
19647 
          for _i401 in xrange(_size397):
19648 
            _elem402 = iprot.readI64();
19649 
            self.itemIds.append(_elem402)
7306 rajveer 19650 
          iprot.readListEnd()
19651 
        else:
19652 
          iprot.skip(ftype)
19653 
      else:
19654 
        iprot.skip(ftype)
19655 
      iprot.readFieldEnd()
19656 
    iprot.readStructEnd()
19657 
 
19658 
  def write(self, oprot):
19659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19661 
      return
19662 
    oprot.writeStructBegin('getStorePricings_args')
19663 
    if self.itemIds is not None:
19664 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19665 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19666 
      for iter403 in self.itemIds:
19667 
        oprot.writeI64(iter403)
7306 rajveer 19668 
      oprot.writeListEnd()
19669 
      oprot.writeFieldEnd()
19670 
    oprot.writeFieldStop()
19671 
    oprot.writeStructEnd()
19672 
 
19673 
  def validate(self):
19674 
    return
19675 
 
19676 
 
19677 
  def __repr__(self):
19678 
    L = ['%s=%r' % (key, value)
19679 
      for key, value in self.__dict__.iteritems()]
19680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19681 
 
19682 
  def __eq__(self, other):
19683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19684 
 
19685 
  def __ne__(self, other):
19686 
    return not (self == other)
19687 
 
19688 
class getStorePricings_result:
19689 
  """
19690 
  Attributes:
19691 
   - success
19692 
  """
19693 
 
19694 
  thrift_spec = (
19695 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19696 
  )
19697 
 
19698 
  def __init__(self, success=None,):
19699 
    self.success = success
19700 
 
19701 
  def read(self, iprot):
19702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19704 
      return
19705 
    iprot.readStructBegin()
19706 
    while True:
19707 
      (fname, ftype, fid) = iprot.readFieldBegin()
19708 
      if ftype == TType.STOP:
19709 
        break
19710 
      if fid == 0:
19711 
        if ftype == TType.LIST:
19712 
          self.success = []
9155 kshitij.so 19713 
          (_etype407, _size404) = iprot.readListBegin()
19714 
          for _i408 in xrange(_size404):
19715 
            _elem409 = StorePricing()
19716 
            _elem409.read(iprot)
19717 
            self.success.append(_elem409)
7306 rajveer 19718 
          iprot.readListEnd()
19719 
        else:
19720 
          iprot.skip(ftype)
19721 
      else:
19722 
        iprot.skip(ftype)
19723 
      iprot.readFieldEnd()
19724 
    iprot.readStructEnd()
19725 
 
19726 
  def write(self, oprot):
19727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19729 
      return
19730 
    oprot.writeStructBegin('getStorePricings_result')
19731 
    if self.success is not None:
19732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19734 
      for iter410 in self.success:
19735 
        iter410.write(oprot)
7306 rajveer 19736 
      oprot.writeListEnd()
19737 
      oprot.writeFieldEnd()
19738 
    oprot.writeFieldStop()
19739 
    oprot.writeStructEnd()
19740 
 
19741 
  def validate(self):
19742 
    return
19743 
 
19744 
 
19745 
  def __repr__(self):
19746 
    L = ['%s=%r' % (key, value)
19747 
      for key, value in self.__dict__.iteritems()]
19748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19749 
 
19750 
  def __eq__(self, other):
19751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19752 
 
19753 
  def __ne__(self, other):
19754 
    return not (self == other)
19755 
 
7265 rajveer 19756 
class updateStorePricing_args:
19757 
  """
19758 
  Attributes:
19759 
   - sp
7382 rajveer 19760 
   - allColors
7265 rajveer 19761 
  """
19762 
 
19763 
  thrift_spec = (
19764 
    None, # 0
19765 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 19766 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 19767 
  )
19768 
 
7382 rajveer 19769 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 19770 
    self.sp = sp
7382 rajveer 19771 
    self.allColors = allColors
7265 rajveer 19772 
 
19773 
  def read(self, iprot):
19774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19776 
      return
19777 
    iprot.readStructBegin()
19778 
    while True:
19779 
      (fname, ftype, fid) = iprot.readFieldBegin()
19780 
      if ftype == TType.STOP:
19781 
        break
19782 
      if fid == 1:
19783 
        if ftype == TType.STRUCT:
19784 
          self.sp = StorePricing()
19785 
          self.sp.read(iprot)
19786 
        else:
19787 
          iprot.skip(ftype)
7382 rajveer 19788 
      elif fid == 2:
19789 
        if ftype == TType.BOOL:
19790 
          self.allColors = iprot.readBool();
19791 
        else:
19792 
          iprot.skip(ftype)
7265 rajveer 19793 
      else:
19794 
        iprot.skip(ftype)
19795 
      iprot.readFieldEnd()
19796 
    iprot.readStructEnd()
19797 
 
19798 
  def write(self, oprot):
19799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19801 
      return
19802 
    oprot.writeStructBegin('updateStorePricing_args')
19803 
    if self.sp is not None:
19804 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
19805 
      self.sp.write(oprot)
19806 
      oprot.writeFieldEnd()
7382 rajveer 19807 
    if self.allColors is not None:
19808 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
19809 
      oprot.writeBool(self.allColors)
19810 
      oprot.writeFieldEnd()
7265 rajveer 19811 
    oprot.writeFieldStop()
19812 
    oprot.writeStructEnd()
19813 
 
19814 
  def validate(self):
19815 
    return
19816 
 
19817 
 
19818 
  def __repr__(self):
19819 
    L = ['%s=%r' % (key, value)
19820 
      for key, value in self.__dict__.iteritems()]
19821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19822 
 
19823 
  def __eq__(self, other):
19824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19825 
 
19826 
  def __ne__(self, other):
19827 
    return not (self == other)
19828 
 
19829 
class updateStorePricing_result:
19830 
 
19831 
  thrift_spec = (
19832 
  )
19833 
 
19834 
  def read(self, iprot):
19835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19837 
      return
19838 
    iprot.readStructBegin()
19839 
    while True:
19840 
      (fname, ftype, fid) = iprot.readFieldBegin()
19841 
      if ftype == TType.STOP:
19842 
        break
19843 
      else:
19844 
        iprot.skip(ftype)
19845 
      iprot.readFieldEnd()
19846 
    iprot.readStructEnd()
19847 
 
19848 
  def write(self, oprot):
19849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19851 
      return
19852 
    oprot.writeStructBegin('updateStorePricing_result')
19853 
    oprot.writeFieldStop()
19854 
    oprot.writeStructEnd()
19855 
 
19856 
  def validate(self):
19857 
    return
19858 
 
19859 
 
19860 
  def __repr__(self):
19861 
    L = ['%s=%r' % (key, value)
19862 
      for key, value in self.__dict__.iteritems()]
19863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19864 
 
19865 
  def __eq__(self, other):
19866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19867 
 
19868 
  def __ne__(self, other):
19869 
    return not (self == other)
7281 kshitij.so 19870 
 
19871 
class getAllAmazonListedItems_args:
19872 
 
19873 
  thrift_spec = (
19874 
  )
19875 
 
19876 
  def read(self, iprot):
19877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19879 
      return
19880 
    iprot.readStructBegin()
19881 
    while True:
19882 
      (fname, ftype, fid) = iprot.readFieldBegin()
19883 
      if ftype == TType.STOP:
19884 
        break
19885 
      else:
19886 
        iprot.skip(ftype)
19887 
      iprot.readFieldEnd()
19888 
    iprot.readStructEnd()
19889 
 
19890 
  def write(self, oprot):
19891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19893 
      return
19894 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
19895 
    oprot.writeFieldStop()
19896 
    oprot.writeStructEnd()
19897 
 
19898 
  def validate(self):
19899 
    return
19900 
 
19901 
 
19902 
  def __repr__(self):
19903 
    L = ['%s=%r' % (key, value)
19904 
      for key, value in self.__dict__.iteritems()]
19905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19906 
 
19907 
  def __eq__(self, other):
19908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19909 
 
19910 
  def __ne__(self, other):
19911 
    return not (self == other)
19912 
 
19913 
class getAllAmazonListedItems_result:
19914 
  """
19915 
  Attributes:
19916 
   - success
19917 
  """
19918 
 
19919 
  thrift_spec = (
19920 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19921 
  )
19922 
 
19923 
  def __init__(self, success=None,):
19924 
    self.success = success
19925 
 
19926 
  def read(self, iprot):
19927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19929 
      return
19930 
    iprot.readStructBegin()
19931 
    while True:
19932 
      (fname, ftype, fid) = iprot.readFieldBegin()
19933 
      if ftype == TType.STOP:
19934 
        break
19935 
      if fid == 0:
19936 
        if ftype == TType.LIST:
19937 
          self.success = []
9155 kshitij.so 19938 
          (_etype414, _size411) = iprot.readListBegin()
19939 
          for _i415 in xrange(_size411):
19940 
            _elem416 = Amazonlisted()
19941 
            _elem416.read(iprot)
19942 
            self.success.append(_elem416)
7281 kshitij.so 19943 
          iprot.readListEnd()
19944 
        else:
19945 
          iprot.skip(ftype)
19946 
      else:
19947 
        iprot.skip(ftype)
19948 
      iprot.readFieldEnd()
19949 
    iprot.readStructEnd()
19950 
 
19951 
  def write(self, oprot):
19952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19954 
      return
19955 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
19956 
    if self.success is not None:
19957 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19958 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19959 
      for iter417 in self.success:
19960 
        iter417.write(oprot)
7281 kshitij.so 19961 
      oprot.writeListEnd()
19962 
      oprot.writeFieldEnd()
19963 
    oprot.writeFieldStop()
19964 
    oprot.writeStructEnd()
19965 
 
19966 
  def validate(self):
19967 
    return
19968 
 
19969 
 
19970 
  def __repr__(self):
19971 
    L = ['%s=%r' % (key, value)
19972 
      for key, value in self.__dict__.iteritems()]
19973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19974 
 
19975 
  def __eq__(self, other):
19976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19977 
 
19978 
  def __ne__(self, other):
19979 
    return not (self == other)
19980 
 
8619 kshitij.so 19981 
class searchAmazonItems_args:
19982 
  """
19983 
  Attributes:
19984 
   - searchTerm
19985 
   - offset
19986 
   - limit
19987 
  """
19988 
 
19989 
  thrift_spec = (
19990 
    None, # 0
19991 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19992 
    (2, TType.I64, 'offset', None, None, ), # 2
19993 
    (3, TType.I64, 'limit', None, None, ), # 3
19994 
  )
19995 
 
19996 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
19997 
    self.searchTerm = searchTerm
19998 
    self.offset = offset
19999 
    self.limit = limit
20000 
 
20001 
  def read(self, iprot):
20002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20004 
      return
20005 
    iprot.readStructBegin()
20006 
    while True:
20007 
      (fname, ftype, fid) = iprot.readFieldBegin()
20008 
      if ftype == TType.STOP:
20009 
        break
20010 
      if fid == 1:
20011 
        if ftype == TType.LIST:
20012 
          self.searchTerm = []
9155 kshitij.so 20013 
          (_etype421, _size418) = iprot.readListBegin()
20014 
          for _i422 in xrange(_size418):
20015 
            _elem423 = iprot.readString();
20016 
            self.searchTerm.append(_elem423)
8619 kshitij.so 20017 
          iprot.readListEnd()
20018 
        else:
20019 
          iprot.skip(ftype)
20020 
      elif fid == 2:
20021 
        if ftype == TType.I64:
20022 
          self.offset = iprot.readI64();
20023 
        else:
20024 
          iprot.skip(ftype)
20025 
      elif fid == 3:
20026 
        if ftype == TType.I64:
20027 
          self.limit = iprot.readI64();
20028 
        else:
20029 
          iprot.skip(ftype)
20030 
      else:
20031 
        iprot.skip(ftype)
20032 
      iprot.readFieldEnd()
20033 
    iprot.readStructEnd()
20034 
 
20035 
  def write(self, oprot):
20036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20038 
      return
20039 
    oprot.writeStructBegin('searchAmazonItems_args')
20040 
    if self.searchTerm is not None:
20041 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20042 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20043 
      for iter424 in self.searchTerm:
20044 
        oprot.writeString(iter424)
8619 kshitij.so 20045 
      oprot.writeListEnd()
20046 
      oprot.writeFieldEnd()
20047 
    if self.offset is not None:
20048 
      oprot.writeFieldBegin('offset', TType.I64, 2)
20049 
      oprot.writeI64(self.offset)
20050 
      oprot.writeFieldEnd()
20051 
    if self.limit is not None:
20052 
      oprot.writeFieldBegin('limit', TType.I64, 3)
20053 
      oprot.writeI64(self.limit)
20054 
      oprot.writeFieldEnd()
20055 
    oprot.writeFieldStop()
20056 
    oprot.writeStructEnd()
20057 
 
20058 
  def validate(self):
20059 
    return
20060 
 
20061 
 
20062 
  def __repr__(self):
20063 
    L = ['%s=%r' % (key, value)
20064 
      for key, value in self.__dict__.iteritems()]
20065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20066 
 
20067 
  def __eq__(self, other):
20068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20069 
 
20070 
  def __ne__(self, other):
20071 
    return not (self == other)
20072 
 
20073 
class searchAmazonItems_result:
20074 
  """
20075 
  Attributes:
20076 
   - success
20077 
  """
20078 
 
20079 
  thrift_spec = (
20080 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20081 
  )
20082 
 
20083 
  def __init__(self, success=None,):
20084 
    self.success = success
20085 
 
20086 
  def read(self, iprot):
20087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20089 
      return
20090 
    iprot.readStructBegin()
20091 
    while True:
20092 
      (fname, ftype, fid) = iprot.readFieldBegin()
20093 
      if ftype == TType.STOP:
20094 
        break
20095 
      if fid == 0:
20096 
        if ftype == TType.LIST:
20097 
          self.success = []
9155 kshitij.so 20098 
          (_etype428, _size425) = iprot.readListBegin()
20099 
          for _i429 in xrange(_size425):
20100 
            _elem430 = Amazonlisted()
20101 
            _elem430.read(iprot)
20102 
            self.success.append(_elem430)
8619 kshitij.so 20103 
          iprot.readListEnd()
20104 
        else:
20105 
          iprot.skip(ftype)
20106 
      else:
20107 
        iprot.skip(ftype)
20108 
      iprot.readFieldEnd()
20109 
    iprot.readStructEnd()
20110 
 
20111 
  def write(self, oprot):
20112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20114 
      return
20115 
    oprot.writeStructBegin('searchAmazonItems_result')
20116 
    if self.success is not None:
20117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20118 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20119 
      for iter431 in self.success:
20120 
        iter431.write(oprot)
8619 kshitij.so 20121 
      oprot.writeListEnd()
20122 
      oprot.writeFieldEnd()
20123 
    oprot.writeFieldStop()
20124 
    oprot.writeStructEnd()
20125 
 
20126 
  def validate(self):
20127 
    return
20128 
 
20129 
 
20130 
  def __repr__(self):
20131 
    L = ['%s=%r' % (key, value)
20132 
      for key, value in self.__dict__.iteritems()]
20133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20134 
 
20135 
  def __eq__(self, other):
20136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20137 
 
20138 
  def __ne__(self, other):
20139 
    return not (self == other)
20140 
 
20141 
class getAmazonSearchResultCount_args:
20142 
  """
20143 
  Attributes:
20144 
   - searchTerm
20145 
  """
20146 
 
20147 
  thrift_spec = (
20148 
    None, # 0
20149 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
20150 
  )
20151 
 
20152 
  def __init__(self, searchTerm=None,):
20153 
    self.searchTerm = searchTerm
20154 
 
20155 
  def read(self, iprot):
20156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20158 
      return
20159 
    iprot.readStructBegin()
20160 
    while True:
20161 
      (fname, ftype, fid) = iprot.readFieldBegin()
20162 
      if ftype == TType.STOP:
20163 
        break
20164 
      if fid == 1:
20165 
        if ftype == TType.LIST:
20166 
          self.searchTerm = []
9155 kshitij.so 20167 
          (_etype435, _size432) = iprot.readListBegin()
20168 
          for _i436 in xrange(_size432):
20169 
            _elem437 = iprot.readString();
20170 
            self.searchTerm.append(_elem437)
8619 kshitij.so 20171 
          iprot.readListEnd()
20172 
        else:
20173 
          iprot.skip(ftype)
20174 
      else:
20175 
        iprot.skip(ftype)
20176 
      iprot.readFieldEnd()
20177 
    iprot.readStructEnd()
20178 
 
20179 
  def write(self, oprot):
20180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20182 
      return
20183 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
20184 
    if self.searchTerm is not None:
20185 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
20186 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 20187 
      for iter438 in self.searchTerm:
20188 
        oprot.writeString(iter438)
8619 kshitij.so 20189 
      oprot.writeListEnd()
20190 
      oprot.writeFieldEnd()
20191 
    oprot.writeFieldStop()
20192 
    oprot.writeStructEnd()
20193 
 
20194 
  def validate(self):
20195 
    return
20196 
 
20197 
 
20198 
  def __repr__(self):
20199 
    L = ['%s=%r' % (key, value)
20200 
      for key, value in self.__dict__.iteritems()]
20201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20202 
 
20203 
  def __eq__(self, other):
20204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20205 
 
20206 
  def __ne__(self, other):
20207 
    return not (self == other)
20208 
 
20209 
class getAmazonSearchResultCount_result:
20210 
  """
20211 
  Attributes:
20212 
   - success
20213 
  """
20214 
 
20215 
  thrift_spec = (
20216 
    (0, TType.I64, 'success', None, None, ), # 0
20217 
  )
20218 
 
20219 
  def __init__(self, success=None,):
20220 
    self.success = success
20221 
 
20222 
  def read(self, iprot):
20223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20225 
      return
20226 
    iprot.readStructBegin()
20227 
    while True:
20228 
      (fname, ftype, fid) = iprot.readFieldBegin()
20229 
      if ftype == TType.STOP:
20230 
        break
20231 
      if fid == 0:
20232 
        if ftype == TType.I64:
20233 
          self.success = iprot.readI64();
20234 
        else:
20235 
          iprot.skip(ftype)
20236 
      else:
20237 
        iprot.skip(ftype)
20238 
      iprot.readFieldEnd()
20239 
    iprot.readStructEnd()
20240 
 
20241 
  def write(self, oprot):
20242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20244 
      return
20245 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
20246 
    if self.success is not None:
20247 
      oprot.writeFieldBegin('success', TType.I64, 0)
20248 
      oprot.writeI64(self.success)
20249 
      oprot.writeFieldEnd()
20250 
    oprot.writeFieldStop()
20251 
    oprot.writeStructEnd()
20252 
 
20253 
  def validate(self):
20254 
    return
20255 
 
20256 
 
20257 
  def __repr__(self):
20258 
    L = ['%s=%r' % (key, value)
20259 
      for key, value in self.__dict__.iteritems()]
20260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20261 
 
20262 
  def __eq__(self, other):
20263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20264 
 
20265 
  def __ne__(self, other):
20266 
    return not (self == other)
20267 
 
20268 
class getCountForAmazonlistedItems_args:
20269 
 
20270 
  thrift_spec = (
20271 
  )
20272 
 
20273 
  def read(self, iprot):
20274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20276 
      return
20277 
    iprot.readStructBegin()
20278 
    while True:
20279 
      (fname, ftype, fid) = iprot.readFieldBegin()
20280 
      if ftype == TType.STOP:
20281 
        break
20282 
      else:
20283 
        iprot.skip(ftype)
20284 
      iprot.readFieldEnd()
20285 
    iprot.readStructEnd()
20286 
 
20287 
  def write(self, oprot):
20288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20290 
      return
20291 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
20292 
    oprot.writeFieldStop()
20293 
    oprot.writeStructEnd()
20294 
 
20295 
  def validate(self):
20296 
    return
20297 
 
20298 
 
20299 
  def __repr__(self):
20300 
    L = ['%s=%r' % (key, value)
20301 
      for key, value in self.__dict__.iteritems()]
20302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20303 
 
20304 
  def __eq__(self, other):
20305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20306 
 
20307 
  def __ne__(self, other):
20308 
    return not (self == other)
20309 
 
20310 
class getCountForAmazonlistedItems_result:
20311 
  """
20312 
  Attributes:
20313 
   - success
20314 
  """
20315 
 
20316 
  thrift_spec = (
20317 
    (0, TType.I64, 'success', None, None, ), # 0
20318 
  )
20319 
 
20320 
  def __init__(self, success=None,):
20321 
    self.success = success
20322 
 
20323 
  def read(self, iprot):
20324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20326 
      return
20327 
    iprot.readStructBegin()
20328 
    while True:
20329 
      (fname, ftype, fid) = iprot.readFieldBegin()
20330 
      if ftype == TType.STOP:
20331 
        break
20332 
      if fid == 0:
20333 
        if ftype == TType.I64:
20334 
          self.success = iprot.readI64();
20335 
        else:
20336 
          iprot.skip(ftype)
20337 
      else:
20338 
        iprot.skip(ftype)
20339 
      iprot.readFieldEnd()
20340 
    iprot.readStructEnd()
20341 
 
20342 
  def write(self, oprot):
20343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20345 
      return
20346 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
20347 
    if self.success is not None:
20348 
      oprot.writeFieldBegin('success', TType.I64, 0)
20349 
      oprot.writeI64(self.success)
20350 
      oprot.writeFieldEnd()
20351 
    oprot.writeFieldStop()
20352 
    oprot.writeStructEnd()
20353 
 
20354 
  def validate(self):
20355 
    return
20356 
 
20357 
 
20358 
  def __repr__(self):
20359 
    L = ['%s=%r' % (key, value)
20360 
      for key, value in self.__dict__.iteritems()]
20361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20362 
 
20363 
  def __eq__(self, other):
20364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20365 
 
20366 
  def __ne__(self, other):
20367 
    return not (self == other)
20368 
 
7281 kshitij.so 20369 
class getAmazonItemDetails_args:
20370 
  """
20371 
  Attributes:
20372 
   - itemId
20373 
  """
20374 
 
20375 
  thrift_spec = (
20376 
    None, # 0
20377 
    (1, TType.I64, 'itemId', None, None, ), # 1
20378 
  )
20379 
 
20380 
  def __init__(self, itemId=None,):
20381 
    self.itemId = itemId
20382 
 
20383 
  def read(self, iprot):
20384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20386 
      return
20387 
    iprot.readStructBegin()
20388 
    while True:
20389 
      (fname, ftype, fid) = iprot.readFieldBegin()
20390 
      if ftype == TType.STOP:
20391 
        break
20392 
      if fid == 1:
20393 
        if ftype == TType.I64:
20394 
          self.itemId = iprot.readI64();
20395 
        else:
20396 
          iprot.skip(ftype)
20397 
      else:
20398 
        iprot.skip(ftype)
20399 
      iprot.readFieldEnd()
20400 
    iprot.readStructEnd()
20401 
 
20402 
  def write(self, oprot):
20403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20405 
      return
20406 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20407 
    if self.itemId is not None:
20408 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20409 
      oprot.writeI64(self.itemId)
20410 
      oprot.writeFieldEnd()
20411 
    oprot.writeFieldStop()
20412 
    oprot.writeStructEnd()
20413 
 
20414 
  def validate(self):
20415 
    return
20416 
 
20417 
 
20418 
  def __repr__(self):
20419 
    L = ['%s=%r' % (key, value)
20420 
      for key, value in self.__dict__.iteritems()]
20421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20422 
 
20423 
  def __eq__(self, other):
20424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20425 
 
20426 
  def __ne__(self, other):
20427 
    return not (self == other)
20428 
 
20429 
class getAmazonItemDetails_result:
20430 
  """
20431 
  Attributes:
20432 
   - success
20433 
  """
20434 
 
20435 
  thrift_spec = (
20436 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20437 
  )
20438 
 
20439 
  def __init__(self, success=None,):
20440 
    self.success = success
20441 
 
20442 
  def read(self, iprot):
20443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20445 
      return
20446 
    iprot.readStructBegin()
20447 
    while True:
20448 
      (fname, ftype, fid) = iprot.readFieldBegin()
20449 
      if ftype == TType.STOP:
20450 
        break
20451 
      if fid == 0:
20452 
        if ftype == TType.STRUCT:
20453 
          self.success = Amazonlisted()
20454 
          self.success.read(iprot)
20455 
        else:
20456 
          iprot.skip(ftype)
20457 
      else:
20458 
        iprot.skip(ftype)
20459 
      iprot.readFieldEnd()
20460 
    iprot.readStructEnd()
20461 
 
20462 
  def write(self, oprot):
20463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20465 
      return
20466 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20467 
    if self.success is not None:
20468 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20469 
      self.success.write(oprot)
20470 
      oprot.writeFieldEnd()
20471 
    oprot.writeFieldStop()
20472 
    oprot.writeStructEnd()
20473 
 
20474 
  def validate(self):
20475 
    return
20476 
 
20477 
 
20478 
  def __repr__(self):
20479 
    L = ['%s=%r' % (key, value)
20480 
      for key, value in self.__dict__.iteritems()]
20481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20482 
 
20483 
  def __eq__(self, other):
20484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20485 
 
20486 
  def __ne__(self, other):
20487 
    return not (self == other)
20488 
 
20489 
class updateAmazonItemDetails_args:
20490 
  """
20491 
  Attributes:
8168 kshitij.so 20492 
   - amazonlisted
7281 kshitij.so 20493 
  """
20494 
 
20495 
  thrift_spec = (
20496 
    None, # 0
8168 kshitij.so 20497 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20498 
  )
20499 
 
8168 kshitij.so 20500 
  def __init__(self, amazonlisted=None,):
20501 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20502 
 
20503 
  def read(self, iprot):
20504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20506 
      return
20507 
    iprot.readStructBegin()
20508 
    while True:
20509 
      (fname, ftype, fid) = iprot.readFieldBegin()
20510 
      if ftype == TType.STOP:
20511 
        break
20512 
      if fid == 1:
8168 kshitij.so 20513 
        if ftype == TType.STRUCT:
20514 
          self.amazonlisted = Amazonlisted()
20515 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20516 
        else:
20517 
          iprot.skip(ftype)
20518 
      else:
20519 
        iprot.skip(ftype)
20520 
      iprot.readFieldEnd()
20521 
    iprot.readStructEnd()
20522 
 
20523 
  def write(self, oprot):
20524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20526 
      return
20527 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20528 
    if self.amazonlisted is not None:
20529 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20530 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20531 
      oprot.writeFieldEnd()
20532 
    oprot.writeFieldStop()
20533 
    oprot.writeStructEnd()
20534 
 
20535 
  def validate(self):
20536 
    return
20537 
 
20538 
 
20539 
  def __repr__(self):
20540 
    L = ['%s=%r' % (key, value)
20541 
      for key, value in self.__dict__.iteritems()]
20542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20543 
 
20544 
  def __eq__(self, other):
20545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20546 
 
20547 
  def __ne__(self, other):
20548 
    return not (self == other)
20549 
 
20550 
class updateAmazonItemDetails_result:
20551 
 
20552 
  thrift_spec = (
20553 
  )
20554 
 
20555 
  def read(self, iprot):
20556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20558 
      return
20559 
    iprot.readStructBegin()
20560 
    while True:
20561 
      (fname, ftype, fid) = iprot.readFieldBegin()
20562 
      if ftype == TType.STOP:
20563 
        break
20564 
      else:
20565 
        iprot.skip(ftype)
20566 
      iprot.readFieldEnd()
20567 
    iprot.readStructEnd()
20568 
 
20569 
  def write(self, oprot):
20570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20572 
      return
20573 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20574 
    oprot.writeFieldStop()
20575 
    oprot.writeStructEnd()
20576 
 
20577 
  def validate(self):
20578 
    return
20579 
 
20580 
 
20581 
  def __repr__(self):
20582 
    L = ['%s=%r' % (key, value)
20583 
      for key, value in self.__dict__.iteritems()]
20584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20585 
 
20586 
  def __eq__(self, other):
20587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20588 
 
20589 
  def __ne__(self, other):
20590 
    return not (self == other)
20591 
 
20592 
class addAmazonItem_args:
20593 
  """
20594 
  Attributes:
20595 
   - amazonlisted
20596 
  """
20597 
 
20598 
  thrift_spec = (
20599 
    None, # 0
20600 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20601 
  )
20602 
 
20603 
  def __init__(self, amazonlisted=None,):
20604 
    self.amazonlisted = amazonlisted
20605 
 
20606 
  def read(self, iprot):
20607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20609 
      return
20610 
    iprot.readStructBegin()
20611 
    while True:
20612 
      (fname, ftype, fid) = iprot.readFieldBegin()
20613 
      if ftype == TType.STOP:
20614 
        break
20615 
      if fid == 1:
20616 
        if ftype == TType.STRUCT:
20617 
          self.amazonlisted = Amazonlisted()
20618 
          self.amazonlisted.read(iprot)
20619 
        else:
20620 
          iprot.skip(ftype)
20621 
      else:
20622 
        iprot.skip(ftype)
20623 
      iprot.readFieldEnd()
20624 
    iprot.readStructEnd()
20625 
 
20626 
  def write(self, oprot):
20627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20629 
      return
20630 
    oprot.writeStructBegin('addAmazonItem_args')
20631 
    if self.amazonlisted is not None:
20632 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20633 
      self.amazonlisted.write(oprot)
20634 
      oprot.writeFieldEnd()
20635 
    oprot.writeFieldStop()
20636 
    oprot.writeStructEnd()
20637 
 
20638 
  def validate(self):
20639 
    return
20640 
 
20641 
 
20642 
  def __repr__(self):
20643 
    L = ['%s=%r' % (key, value)
20644 
      for key, value in self.__dict__.iteritems()]
20645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20646 
 
20647 
  def __eq__(self, other):
20648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20649 
 
20650 
  def __ne__(self, other):
20651 
    return not (self == other)
20652 
 
20653 
class addAmazonItem_result:
20654 
 
20655 
  thrift_spec = (
20656 
  )
20657 
 
20658 
  def read(self, iprot):
20659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20661 
      return
20662 
    iprot.readStructBegin()
20663 
    while True:
20664 
      (fname, ftype, fid) = iprot.readFieldBegin()
20665 
      if ftype == TType.STOP:
20666 
        break
20667 
      else:
20668 
        iprot.skip(ftype)
20669 
      iprot.readFieldEnd()
20670 
    iprot.readStructEnd()
20671 
 
20672 
  def write(self, oprot):
20673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20675 
      return
20676 
    oprot.writeStructBegin('addAmazonItem_result')
20677 
    oprot.writeFieldStop()
20678 
    oprot.writeStructEnd()
20679 
 
20680 
  def validate(self):
20681 
    return
20682 
 
20683 
 
20684 
  def __repr__(self):
20685 
    L = ['%s=%r' % (key, value)
20686 
      for key, value in self.__dict__.iteritems()]
20687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20688 
 
20689 
  def __eq__(self, other):
20690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20691 
 
20692 
  def __ne__(self, other):
20693 
    return not (self == other)
7291 vikram.rag 20694 
 
20695 
class getAsinItems_args:
20696 
 
20697 
  thrift_spec = (
20698 
  )
20699 
 
20700 
  def read(self, iprot):
20701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20703 
      return
20704 
    iprot.readStructBegin()
20705 
    while True:
20706 
      (fname, ftype, fid) = iprot.readFieldBegin()
20707 
      if ftype == TType.STOP:
20708 
        break
20709 
      else:
20710 
        iprot.skip(ftype)
20711 
      iprot.readFieldEnd()
20712 
    iprot.readStructEnd()
20713 
 
20714 
  def write(self, oprot):
20715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20717 
      return
20718 
    oprot.writeStructBegin('getAsinItems_args')
20719 
    oprot.writeFieldStop()
20720 
    oprot.writeStructEnd()
20721 
 
20722 
  def validate(self):
20723 
    return
20724 
 
20725 
 
20726 
  def __repr__(self):
20727 
    L = ['%s=%r' % (key, value)
20728 
      for key, value in self.__dict__.iteritems()]
20729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20730 
 
20731 
  def __eq__(self, other):
20732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20733 
 
20734 
  def __ne__(self, other):
20735 
    return not (self == other)
20736 
 
20737 
class getAsinItems_result:
20738 
  """
20739 
  Attributes:
20740 
   - success
20741 
  """
20742 
 
20743 
  thrift_spec = (
20744 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
20745 
  )
20746 
 
20747 
  def __init__(self, success=None,):
20748 
    self.success = success
20749 
 
20750 
  def read(self, iprot):
20751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20753 
      return
20754 
    iprot.readStructBegin()
20755 
    while True:
20756 
      (fname, ftype, fid) = iprot.readFieldBegin()
20757 
      if ftype == TType.STOP:
20758 
        break
20759 
      if fid == 0:
20760 
        if ftype == TType.LIST:
20761 
          self.success = []
9155 kshitij.so 20762 
          (_etype442, _size439) = iprot.readListBegin()
20763 
          for _i443 in xrange(_size439):
20764 
            _elem444 = Item()
20765 
            _elem444.read(iprot)
20766 
            self.success.append(_elem444)
7291 vikram.rag 20767 
          iprot.readListEnd()
20768 
        else:
20769 
          iprot.skip(ftype)
20770 
      else:
20771 
        iprot.skip(ftype)
20772 
      iprot.readFieldEnd()
20773 
    iprot.readStructEnd()
20774 
 
20775 
  def write(self, oprot):
20776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20778 
      return
20779 
    oprot.writeStructBegin('getAsinItems_result')
20780 
    if self.success is not None:
20781 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20782 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20783 
      for iter445 in self.success:
20784 
        iter445.write(oprot)
7291 vikram.rag 20785 
      oprot.writeListEnd()
20786 
      oprot.writeFieldEnd()
20787 
    oprot.writeFieldStop()
20788 
    oprot.writeStructEnd()
20789 
 
20790 
  def validate(self):
20791 
    return
20792 
 
20793 
 
20794 
  def __repr__(self):
20795 
    L = ['%s=%r' % (key, value)
20796 
      for key, value in self.__dict__.iteritems()]
20797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20798 
 
20799 
  def __eq__(self, other):
20800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20801 
 
20802 
  def __ne__(self, other):
20803 
    return not (self == other)
20804 
 
20805 
class getAllFbaListedItems_args:
20806 
 
20807 
  thrift_spec = (
20808 
  )
20809 
 
20810 
  def read(self, iprot):
20811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20813 
      return
20814 
    iprot.readStructBegin()
20815 
    while True:
20816 
      (fname, ftype, fid) = iprot.readFieldBegin()
20817 
      if ftype == TType.STOP:
20818 
        break
20819 
      else:
20820 
        iprot.skip(ftype)
20821 
      iprot.readFieldEnd()
20822 
    iprot.readStructEnd()
20823 
 
20824 
  def write(self, oprot):
20825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20827 
      return
20828 
    oprot.writeStructBegin('getAllFbaListedItems_args')
20829 
    oprot.writeFieldStop()
20830 
    oprot.writeStructEnd()
20831 
 
20832 
  def validate(self):
20833 
    return
20834 
 
20835 
 
20836 
  def __repr__(self):
20837 
    L = ['%s=%r' % (key, value)
20838 
      for key, value in self.__dict__.iteritems()]
20839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20840 
 
20841 
  def __eq__(self, other):
20842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20843 
 
20844 
  def __ne__(self, other):
20845 
    return not (self == other)
20846 
 
20847 
class getAllFbaListedItems_result:
20848 
  """
20849 
  Attributes:
20850 
   - success
20851 
  """
20852 
 
20853 
  thrift_spec = (
20854 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20855 
  )
20856 
 
20857 
  def __init__(self, success=None,):
20858 
    self.success = success
20859 
 
20860 
  def read(self, iprot):
20861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20863 
      return
20864 
    iprot.readStructBegin()
20865 
    while True:
20866 
      (fname, ftype, fid) = iprot.readFieldBegin()
20867 
      if ftype == TType.STOP:
20868 
        break
20869 
      if fid == 0:
20870 
        if ftype == TType.LIST:
20871 
          self.success = []
9155 kshitij.so 20872 
          (_etype449, _size446) = iprot.readListBegin()
20873 
          for _i450 in xrange(_size446):
20874 
            _elem451 = Amazonlisted()
20875 
            _elem451.read(iprot)
20876 
            self.success.append(_elem451)
7291 vikram.rag 20877 
          iprot.readListEnd()
20878 
        else:
20879 
          iprot.skip(ftype)
20880 
      else:
20881 
        iprot.skip(ftype)
20882 
      iprot.readFieldEnd()
20883 
    iprot.readStructEnd()
20884 
 
20885 
  def write(self, oprot):
20886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20888 
      return
20889 
    oprot.writeStructBegin('getAllFbaListedItems_result')
20890 
    if self.success is not None:
20891 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20892 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20893 
      for iter452 in self.success:
20894 
        iter452.write(oprot)
7291 vikram.rag 20895 
      oprot.writeListEnd()
20896 
      oprot.writeFieldEnd()
20897 
    oprot.writeFieldStop()
20898 
    oprot.writeStructEnd()
20899 
 
20900 
  def validate(self):
20901 
    return
20902 
 
20903 
 
20904 
  def __repr__(self):
20905 
    L = ['%s=%r' % (key, value)
20906 
      for key, value in self.__dict__.iteritems()]
20907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20908 
 
20909 
  def __eq__(self, other):
20910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20911 
 
20912 
  def __ne__(self, other):
20913 
    return not (self == other)
20914 
 
20915 
class getAllNonFbaListedItems_args:
20916 
 
20917 
  thrift_spec = (
20918 
  )
20919 
 
20920 
  def read(self, iprot):
20921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20923 
      return
20924 
    iprot.readStructBegin()
20925 
    while True:
20926 
      (fname, ftype, fid) = iprot.readFieldBegin()
20927 
      if ftype == TType.STOP:
20928 
        break
20929 
      else:
20930 
        iprot.skip(ftype)
20931 
      iprot.readFieldEnd()
20932 
    iprot.readStructEnd()
20933 
 
20934 
  def write(self, oprot):
20935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20937 
      return
20938 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
20939 
    oprot.writeFieldStop()
20940 
    oprot.writeStructEnd()
20941 
 
20942 
  def validate(self):
20943 
    return
20944 
 
20945 
 
20946 
  def __repr__(self):
20947 
    L = ['%s=%r' % (key, value)
20948 
      for key, value in self.__dict__.iteritems()]
20949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20950 
 
20951 
  def __eq__(self, other):
20952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20953 
 
20954 
  def __ne__(self, other):
20955 
    return not (self == other)
20956 
 
20957 
class getAllNonFbaListedItems_result:
20958 
  """
20959 
  Attributes:
20960 
   - success
20961 
  """
20962 
 
20963 
  thrift_spec = (
20964 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20965 
  )
20966 
 
20967 
  def __init__(self, success=None,):
20968 
    self.success = success
20969 
 
20970 
  def read(self, iprot):
20971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20973 
      return
20974 
    iprot.readStructBegin()
20975 
    while True:
20976 
      (fname, ftype, fid) = iprot.readFieldBegin()
20977 
      if ftype == TType.STOP:
20978 
        break
20979 
      if fid == 0:
20980 
        if ftype == TType.LIST:
20981 
          self.success = []
9155 kshitij.so 20982 
          (_etype456, _size453) = iprot.readListBegin()
20983 
          for _i457 in xrange(_size453):
20984 
            _elem458 = Amazonlisted()
20985 
            _elem458.read(iprot)
20986 
            self.success.append(_elem458)
7291 vikram.rag 20987 
          iprot.readListEnd()
20988 
        else:
20989 
          iprot.skip(ftype)
20990 
      else:
20991 
        iprot.skip(ftype)
20992 
      iprot.readFieldEnd()
20993 
    iprot.readStructEnd()
20994 
 
20995 
  def write(self, oprot):
20996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20998 
      return
20999 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
21000 
    if self.success is not None:
21001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21003 
      for iter459 in self.success:
21004 
        iter459.write(oprot)
7291 vikram.rag 21005 
      oprot.writeListEnd()
21006 
      oprot.writeFieldEnd()
21007 
    oprot.writeFieldStop()
21008 
    oprot.writeStructEnd()
21009 
 
21010 
  def validate(self):
21011 
    return
21012 
 
21013 
 
21014 
  def __repr__(self):
21015 
    L = ['%s=%r' % (key, value)
21016 
      for key, value in self.__dict__.iteritems()]
21017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21018 
 
21019 
  def __eq__(self, other):
21020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21021 
 
21022 
  def __ne__(self, other):
21023 
    return not (self == other)
7460 kshitij.so 21024 
 
21025 
class updateItemInventory_args:
21026 
  """
21027 
  Attributes:
21028 
   - itemId
21029 
   - holdInventory
21030 
   - defaultInventory
21031 
  """
21032 
 
21033 
  thrift_spec = (
21034 
    None, # 0
21035 
    (1, TType.I64, 'itemId', None, None, ), # 1
21036 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
21037 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
21038 
  )
21039 
 
21040 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
21041 
    self.itemId = itemId
21042 
    self.holdInventory = holdInventory
21043 
    self.defaultInventory = defaultInventory
21044 
 
21045 
  def read(self, iprot):
21046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21048 
      return
21049 
    iprot.readStructBegin()
21050 
    while True:
21051 
      (fname, ftype, fid) = iprot.readFieldBegin()
21052 
      if ftype == TType.STOP:
21053 
        break
21054 
      if fid == 1:
21055 
        if ftype == TType.I64:
21056 
          self.itemId = iprot.readI64();
21057 
        else:
21058 
          iprot.skip(ftype)
21059 
      elif fid == 2:
21060 
        if ftype == TType.I64:
21061 
          self.holdInventory = iprot.readI64();
21062 
        else:
21063 
          iprot.skip(ftype)
21064 
      elif fid == 3:
21065 
        if ftype == TType.I64:
21066 
          self.defaultInventory = iprot.readI64();
21067 
        else:
21068 
          iprot.skip(ftype)
21069 
      else:
21070 
        iprot.skip(ftype)
21071 
      iprot.readFieldEnd()
21072 
    iprot.readStructEnd()
21073 
 
21074 
  def write(self, oprot):
21075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21077 
      return
21078 
    oprot.writeStructBegin('updateItemInventory_args')
21079 
    if self.itemId is not None:
21080 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21081 
      oprot.writeI64(self.itemId)
21082 
      oprot.writeFieldEnd()
21083 
    if self.holdInventory is not None:
21084 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
21085 
      oprot.writeI64(self.holdInventory)
21086 
      oprot.writeFieldEnd()
21087 
    if self.defaultInventory is not None:
21088 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
21089 
      oprot.writeI64(self.defaultInventory)
21090 
      oprot.writeFieldEnd()
21091 
    oprot.writeFieldStop()
21092 
    oprot.writeStructEnd()
21093 
 
21094 
  def validate(self):
21095 
    return
21096 
 
21097 
 
21098 
  def __repr__(self):
21099 
    L = ['%s=%r' % (key, value)
21100 
      for key, value in self.__dict__.iteritems()]
21101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21102 
 
21103 
  def __eq__(self, other):
21104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21105 
 
21106 
  def __ne__(self, other):
21107 
    return not (self == other)
21108 
 
21109 
class updateItemInventory_result:
21110 
  """
21111 
  Attributes:
21112 
   - success
21113 
  """
21114 
 
21115 
  thrift_spec = (
21116 
    (0, TType.BOOL, 'success', None, None, ), # 0
21117 
  )
21118 
 
21119 
  def __init__(self, success=None,):
21120 
    self.success = success
21121 
 
21122 
  def read(self, iprot):
21123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21125 
      return
21126 
    iprot.readStructBegin()
21127 
    while True:
21128 
      (fname, ftype, fid) = iprot.readFieldBegin()
21129 
      if ftype == TType.STOP:
21130 
        break
21131 
      if fid == 0:
21132 
        if ftype == TType.BOOL:
21133 
          self.success = iprot.readBool();
21134 
        else:
21135 
          iprot.skip(ftype)
21136 
      else:
21137 
        iprot.skip(ftype)
21138 
      iprot.readFieldEnd()
21139 
    iprot.readStructEnd()
21140 
 
21141 
  def write(self, oprot):
21142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21144 
      return
21145 
    oprot.writeStructBegin('updateItemInventory_result')
21146 
    if self.success is not None:
21147 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21148 
      oprot.writeBool(self.success)
21149 
      oprot.writeFieldEnd()
21150 
    oprot.writeFieldStop()
21151 
    oprot.writeStructEnd()
21152 
 
21153 
  def validate(self):
21154 
    return
21155 
 
21156 
 
21157 
  def __repr__(self):
21158 
    L = ['%s=%r' % (key, value)
21159 
      for key, value in self.__dict__.iteritems()]
21160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21161 
 
21162 
  def __eq__(self, other):
21163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21164 
 
21165 
  def __ne__(self, other):
21166 
    return not (self == other)
7770 kshitij.so 21167 
 
21168 
class updateTimestampForAmazonFeeds_args:
21169 
  """
21170 
  Attributes:
21171 
   - type
21172 
   - sku
21173 
   - timestamp
21174 
  """
21175 
 
21176 
  thrift_spec = (
21177 
    None, # 0
21178 
    (1, TType.STRING, 'type', None, None, ), # 1
21179 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
21180 
    (3, TType.I64, 'timestamp', None, None, ), # 3
21181 
  )
21182 
 
21183 
  def __init__(self, type=None, sku=None, timestamp=None,):
21184 
    self.type = type
21185 
    self.sku = sku
21186 
    self.timestamp = timestamp
21187 
 
21188 
  def read(self, iprot):
21189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21191 
      return
21192 
    iprot.readStructBegin()
21193 
    while True:
21194 
      (fname, ftype, fid) = iprot.readFieldBegin()
21195 
      if ftype == TType.STOP:
21196 
        break
21197 
      if fid == 1:
21198 
        if ftype == TType.STRING:
21199 
          self.type = iprot.readString();
21200 
        else:
21201 
          iprot.skip(ftype)
21202 
      elif fid == 2:
21203 
        if ftype == TType.LIST:
21204 
          self.sku = []
9155 kshitij.so 21205 
          (_etype463, _size460) = iprot.readListBegin()
21206 
          for _i464 in xrange(_size460):
21207 
            _elem465 = iprot.readI64();
21208 
            self.sku.append(_elem465)
7770 kshitij.so 21209 
          iprot.readListEnd()
21210 
        else:
21211 
          iprot.skip(ftype)
21212 
      elif fid == 3:
21213 
        if ftype == TType.I64:
21214 
          self.timestamp = iprot.readI64();
21215 
        else:
21216 
          iprot.skip(ftype)
21217 
      else:
21218 
        iprot.skip(ftype)
21219 
      iprot.readFieldEnd()
21220 
    iprot.readStructEnd()
21221 
 
21222 
  def write(self, oprot):
21223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21225 
      return
21226 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
21227 
    if self.type is not None:
21228 
      oprot.writeFieldBegin('type', TType.STRING, 1)
21229 
      oprot.writeString(self.type)
21230 
      oprot.writeFieldEnd()
21231 
    if self.sku is not None:
21232 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
21233 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 21234 
      for iter466 in self.sku:
21235 
        oprot.writeI64(iter466)
7770 kshitij.so 21236 
      oprot.writeListEnd()
21237 
      oprot.writeFieldEnd()
21238 
    if self.timestamp is not None:
21239 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
21240 
      oprot.writeI64(self.timestamp)
21241 
      oprot.writeFieldEnd()
21242 
    oprot.writeFieldStop()
21243 
    oprot.writeStructEnd()
21244 
 
21245 
  def validate(self):
21246 
    return
21247 
 
21248 
 
21249 
  def __repr__(self):
21250 
    L = ['%s=%r' % (key, value)
21251 
      for key, value in self.__dict__.iteritems()]
21252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21253 
 
21254 
  def __eq__(self, other):
21255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21256 
 
21257 
  def __ne__(self, other):
21258 
    return not (self == other)
21259 
 
21260 
class updateTimestampForAmazonFeeds_result:
21261 
  """
21262 
  Attributes:
21263 
   - success
21264 
  """
21265 
 
21266 
  thrift_spec = (
21267 
    (0, TType.BOOL, 'success', None, None, ), # 0
21268 
  )
21269 
 
21270 
  def __init__(self, success=None,):
21271 
    self.success = success
21272 
 
21273 
  def read(self, iprot):
21274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21276 
      return
21277 
    iprot.readStructBegin()
21278 
    while True:
21279 
      (fname, ftype, fid) = iprot.readFieldBegin()
21280 
      if ftype == TType.STOP:
21281 
        break
21282 
      if fid == 0:
21283 
        if ftype == TType.BOOL:
21284 
          self.success = iprot.readBool();
21285 
        else:
21286 
          iprot.skip(ftype)
21287 
      else:
21288 
        iprot.skip(ftype)
21289 
      iprot.readFieldEnd()
21290 
    iprot.readStructEnd()
21291 
 
21292 
  def write(self, oprot):
21293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21295 
      return
21296 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
21297 
    if self.success is not None:
21298 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21299 
      oprot.writeBool(self.success)
21300 
      oprot.writeFieldEnd()
21301 
    oprot.writeFieldStop()
21302 
    oprot.writeStructEnd()
21303 
 
21304 
  def validate(self):
21305 
    return
21306 
 
21307 
 
21308 
  def __repr__(self):
21309 
    L = ['%s=%r' % (key, value)
21310 
      for key, value in self.__dict__.iteritems()]
21311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21312 
 
21313 
  def __eq__(self, other):
21314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21315 
 
21316 
  def __ne__(self, other):
21317 
    return not (self == other)
7897 amar.kumar 21318 
 
21319 
class getAllParentCategories_args:
21320 
 
21321 
  thrift_spec = (
21322 
  )
21323 
 
21324 
  def read(self, iprot):
21325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21327 
      return
21328 
    iprot.readStructBegin()
21329 
    while True:
21330 
      (fname, ftype, fid) = iprot.readFieldBegin()
21331 
      if ftype == TType.STOP:
21332 
        break
21333 
      else:
21334 
        iprot.skip(ftype)
21335 
      iprot.readFieldEnd()
21336 
    iprot.readStructEnd()
21337 
 
21338 
  def write(self, oprot):
21339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21341 
      return
21342 
    oprot.writeStructBegin('getAllParentCategories_args')
21343 
    oprot.writeFieldStop()
21344 
    oprot.writeStructEnd()
21345 
 
21346 
  def validate(self):
21347 
    return
21348 
 
21349 
 
21350 
  def __repr__(self):
21351 
    L = ['%s=%r' % (key, value)
21352 
      for key, value in self.__dict__.iteritems()]
21353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21354 
 
21355 
  def __eq__(self, other):
21356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21357 
 
21358 
  def __ne__(self, other):
21359 
    return not (self == other)
21360 
 
21361 
class getAllParentCategories_result:
21362 
  """
21363 
  Attributes:
21364 
   - success
21365 
  """
21366 
 
21367 
  thrift_spec = (
21368 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21369 
  )
21370 
 
21371 
  def __init__(self, success=None,):
21372 
    self.success = success
21373 
 
21374 
  def read(self, iprot):
21375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21377 
      return
21378 
    iprot.readStructBegin()
21379 
    while True:
21380 
      (fname, ftype, fid) = iprot.readFieldBegin()
21381 
      if ftype == TType.STOP:
21382 
        break
21383 
      if fid == 0:
21384 
        if ftype == TType.LIST:
21385 
          self.success = []
9155 kshitij.so 21386 
          (_etype470, _size467) = iprot.readListBegin()
21387 
          for _i471 in xrange(_size467):
21388 
            _elem472 = Category()
21389 
            _elem472.read(iprot)
21390 
            self.success.append(_elem472)
7897 amar.kumar 21391 
          iprot.readListEnd()
21392 
        else:
21393 
          iprot.skip(ftype)
21394 
      else:
21395 
        iprot.skip(ftype)
21396 
      iprot.readFieldEnd()
21397 
    iprot.readStructEnd()
21398 
 
21399 
  def write(self, oprot):
21400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21402 
      return
21403 
    oprot.writeStructBegin('getAllParentCategories_result')
21404 
    if self.success is not None:
21405 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21406 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21407 
      for iter473 in self.success:
21408 
        iter473.write(oprot)
7897 amar.kumar 21409 
      oprot.writeListEnd()
21410 
      oprot.writeFieldEnd()
21411 
    oprot.writeFieldStop()
21412 
    oprot.writeStructEnd()
21413 
 
21414 
  def validate(self):
21415 
    return
21416 
 
21417 
 
21418 
  def __repr__(self):
21419 
    L = ['%s=%r' % (key, value)
21420 
      for key, value in self.__dict__.iteritems()]
21421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21422 
 
21423 
  def __eq__(self, other):
21424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21425 
 
21426 
  def __ne__(self, other):
21427 
    return not (self == other)
7977 kshitij.so 21428 
 
21429 
class addPageViewEvent_args:
21430 
  """
21431 
  Attributes:
21432 
   - pageViewEvents
21433 
  """
21434 
 
21435 
  thrift_spec = (
21436 
    None, # 0
21437 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21438 
  )
21439 
 
21440 
  def __init__(self, pageViewEvents=None,):
21441 
    self.pageViewEvents = pageViewEvents
21442 
 
21443 
  def read(self, iprot):
21444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21446 
      return
21447 
    iprot.readStructBegin()
21448 
    while True:
21449 
      (fname, ftype, fid) = iprot.readFieldBegin()
21450 
      if ftype == TType.STOP:
21451 
        break
21452 
      if fid == 1:
21453 
        if ftype == TType.STRUCT:
21454 
          self.pageViewEvents = PageViewEvents()
21455 
          self.pageViewEvents.read(iprot)
21456 
        else:
21457 
          iprot.skip(ftype)
21458 
      else:
21459 
        iprot.skip(ftype)
21460 
      iprot.readFieldEnd()
21461 
    iprot.readStructEnd()
21462 
 
21463 
  def write(self, oprot):
21464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21466 
      return
21467 
    oprot.writeStructBegin('addPageViewEvent_args')
21468 
    if self.pageViewEvents is not None:
21469 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21470 
      self.pageViewEvents.write(oprot)
21471 
      oprot.writeFieldEnd()
21472 
    oprot.writeFieldStop()
21473 
    oprot.writeStructEnd()
21474 
 
21475 
  def validate(self):
21476 
    return
21477 
 
21478 
 
21479 
  def __repr__(self):
21480 
    L = ['%s=%r' % (key, value)
21481 
      for key, value in self.__dict__.iteritems()]
21482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21483 
 
21484 
  def __eq__(self, other):
21485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21486 
 
21487 
  def __ne__(self, other):
21488 
    return not (self == other)
21489 
 
21490 
class addPageViewEvent_result:
21491 
 
21492 
  thrift_spec = (
21493 
  )
21494 
 
21495 
  def read(self, iprot):
21496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21498 
      return
21499 
    iprot.readStructBegin()
21500 
    while True:
21501 
      (fname, ftype, fid) = iprot.readFieldBegin()
21502 
      if ftype == TType.STOP:
21503 
        break
21504 
      else:
21505 
        iprot.skip(ftype)
21506 
      iprot.readFieldEnd()
21507 
    iprot.readStructEnd()
21508 
 
21509 
  def write(self, oprot):
21510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21512 
      return
21513 
    oprot.writeStructBegin('addPageViewEvent_result')
21514 
    oprot.writeFieldStop()
21515 
    oprot.writeStructEnd()
21516 
 
21517 
  def validate(self):
21518 
    return
21519 
 
21520 
 
21521 
  def __repr__(self):
21522 
    L = ['%s=%r' % (key, value)
21523 
      for key, value in self.__dict__.iteritems()]
21524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21525 
 
21526 
  def __eq__(self, other):
21527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21528 
 
21529 
  def __ne__(self, other):
21530 
    return not (self == other)
21531 
 
21532 
class addCartEvent_args:
21533 
  """
21534 
  Attributes:
21535 
   - cartEvents
21536 
  """
21537 
 
21538 
  thrift_spec = (
21539 
    None, # 0
21540 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21541 
  )
21542 
 
21543 
  def __init__(self, cartEvents=None,):
21544 
    self.cartEvents = cartEvents
21545 
 
21546 
  def read(self, iprot):
21547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21549 
      return
21550 
    iprot.readStructBegin()
21551 
    while True:
21552 
      (fname, ftype, fid) = iprot.readFieldBegin()
21553 
      if ftype == TType.STOP:
21554 
        break
21555 
      if fid == 1:
21556 
        if ftype == TType.STRUCT:
21557 
          self.cartEvents = CartEvents()
21558 
          self.cartEvents.read(iprot)
21559 
        else:
21560 
          iprot.skip(ftype)
21561 
      else:
21562 
        iprot.skip(ftype)
21563 
      iprot.readFieldEnd()
21564 
    iprot.readStructEnd()
21565 
 
21566 
  def write(self, oprot):
21567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21569 
      return
21570 
    oprot.writeStructBegin('addCartEvent_args')
21571 
    if self.cartEvents is not None:
21572 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21573 
      self.cartEvents.write(oprot)
21574 
      oprot.writeFieldEnd()
21575 
    oprot.writeFieldStop()
21576 
    oprot.writeStructEnd()
21577 
 
21578 
  def validate(self):
21579 
    return
21580 
 
21581 
 
21582 
  def __repr__(self):
21583 
    L = ['%s=%r' % (key, value)
21584 
      for key, value in self.__dict__.iteritems()]
21585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21586 
 
21587 
  def __eq__(self, other):
21588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21589 
 
21590 
  def __ne__(self, other):
21591 
    return not (self == other)
21592 
 
21593 
class addCartEvent_result:
21594 
 
21595 
  thrift_spec = (
21596 
  )
21597 
 
21598 
  def read(self, iprot):
21599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21601 
      return
21602 
    iprot.readStructBegin()
21603 
    while True:
21604 
      (fname, ftype, fid) = iprot.readFieldBegin()
21605 
      if ftype == TType.STOP:
21606 
        break
21607 
      else:
21608 
        iprot.skip(ftype)
21609 
      iprot.readFieldEnd()
21610 
    iprot.readStructEnd()
21611 
 
21612 
  def write(self, oprot):
21613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21615 
      return
21616 
    oprot.writeStructBegin('addCartEvent_result')
21617 
    oprot.writeFieldStop()
21618 
    oprot.writeStructEnd()
21619 
 
21620 
  def validate(self):
21621 
    return
21622 
 
21623 
 
21624 
  def __repr__(self):
21625 
    L = ['%s=%r' % (key, value)
21626 
      for key, value in self.__dict__.iteritems()]
21627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21628 
 
21629 
  def __eq__(self, other):
21630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21631 
 
21632 
  def __ne__(self, other):
21633 
    return not (self == other)
8139 kshitij.so 21634 
 
8182 amar.kumar 21635 
class addEbayItem_args:
21636 
  """
21637 
  Attributes:
21638 
   - ebayItem
21639 
  """
21640 
 
21641 
  thrift_spec = (
21642 
    None, # 0
21643 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21644 
  )
21645 
 
21646 
  def __init__(self, ebayItem=None,):
21647 
    self.ebayItem = ebayItem
21648 
 
21649 
  def read(self, iprot):
21650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21652 
      return
21653 
    iprot.readStructBegin()
21654 
    while True:
21655 
      (fname, ftype, fid) = iprot.readFieldBegin()
21656 
      if ftype == TType.STOP:
21657 
        break
21658 
      if fid == 1:
21659 
        if ftype == TType.STRUCT:
21660 
          self.ebayItem = EbayItem()
21661 
          self.ebayItem.read(iprot)
21662 
        else:
21663 
          iprot.skip(ftype)
21664 
      else:
21665 
        iprot.skip(ftype)
21666 
      iprot.readFieldEnd()
21667 
    iprot.readStructEnd()
21668 
 
21669 
  def write(self, oprot):
21670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21672 
      return
21673 
    oprot.writeStructBegin('addEbayItem_args')
21674 
    if self.ebayItem is not None:
21675 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21676 
      self.ebayItem.write(oprot)
21677 
      oprot.writeFieldEnd()
21678 
    oprot.writeFieldStop()
21679 
    oprot.writeStructEnd()
21680 
 
21681 
  def validate(self):
21682 
    return
21683 
 
21684 
 
21685 
  def __repr__(self):
21686 
    L = ['%s=%r' % (key, value)
21687 
      for key, value in self.__dict__.iteritems()]
21688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21689 
 
21690 
  def __eq__(self, other):
21691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21692 
 
21693 
  def __ne__(self, other):
21694 
    return not (self == other)
21695 
 
21696 
class addEbayItem_result:
21697 
 
21698 
  thrift_spec = (
21699 
  )
21700 
 
21701 
  def read(self, iprot):
21702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21704 
      return
21705 
    iprot.readStructBegin()
21706 
    while True:
21707 
      (fname, ftype, fid) = iprot.readFieldBegin()
21708 
      if ftype == TType.STOP:
21709 
        break
21710 
      else:
21711 
        iprot.skip(ftype)
21712 
      iprot.readFieldEnd()
21713 
    iprot.readStructEnd()
21714 
 
21715 
  def write(self, oprot):
21716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21718 
      return
21719 
    oprot.writeStructBegin('addEbayItem_result')
21720 
    oprot.writeFieldStop()
21721 
    oprot.writeStructEnd()
21722 
 
21723 
  def validate(self):
21724 
    return
21725 
 
21726 
 
21727 
  def __repr__(self):
21728 
    L = ['%s=%r' % (key, value)
21729 
      for key, value in self.__dict__.iteritems()]
21730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21731 
 
21732 
  def __eq__(self, other):
21733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21734 
 
21735 
  def __ne__(self, other):
21736 
    return not (self == other)
21737 
 
21738 
class getEbayItem_args:
21739 
  """
21740 
  Attributes:
21741 
   - listingId
21742 
  """
21743 
 
21744 
  thrift_spec = (
21745 
    None, # 0
21746 
    (1, TType.STRING, 'listingId', None, None, ), # 1
21747 
  )
21748 
 
21749 
  def __init__(self, listingId=None,):
21750 
    self.listingId = listingId
21751 
 
21752 
  def read(self, iprot):
21753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21755 
      return
21756 
    iprot.readStructBegin()
21757 
    while True:
21758 
      (fname, ftype, fid) = iprot.readFieldBegin()
21759 
      if ftype == TType.STOP:
21760 
        break
21761 
      if fid == 1:
21762 
        if ftype == TType.STRING:
21763 
          self.listingId = iprot.readString();
21764 
        else:
21765 
          iprot.skip(ftype)
21766 
      else:
21767 
        iprot.skip(ftype)
21768 
      iprot.readFieldEnd()
21769 
    iprot.readStructEnd()
21770 
 
21771 
  def write(self, oprot):
21772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21774 
      return
21775 
    oprot.writeStructBegin('getEbayItem_args')
21776 
    if self.listingId is not None:
21777 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
21778 
      oprot.writeString(self.listingId)
21779 
      oprot.writeFieldEnd()
21780 
    oprot.writeFieldStop()
21781 
    oprot.writeStructEnd()
21782 
 
21783 
  def validate(self):
21784 
    return
21785 
 
21786 
 
21787 
  def __repr__(self):
21788 
    L = ['%s=%r' % (key, value)
21789 
      for key, value in self.__dict__.iteritems()]
21790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21791 
 
21792 
  def __eq__(self, other):
21793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21794 
 
21795 
  def __ne__(self, other):
21796 
    return not (self == other)
21797 
 
21798 
class getEbayItem_result:
21799 
  """
21800 
  Attributes:
21801 
   - success
21802 
  """
21803 
 
21804 
  thrift_spec = (
21805 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
21806 
  )
21807 
 
21808 
  def __init__(self, success=None,):
21809 
    self.success = success
21810 
 
21811 
  def read(self, iprot):
21812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21814 
      return
21815 
    iprot.readStructBegin()
21816 
    while True:
21817 
      (fname, ftype, fid) = iprot.readFieldBegin()
21818 
      if ftype == TType.STOP:
21819 
        break
21820 
      if fid == 0:
21821 
        if ftype == TType.STRUCT:
21822 
          self.success = EbayItem()
21823 
          self.success.read(iprot)
21824 
        else:
21825 
          iprot.skip(ftype)
21826 
      else:
21827 
        iprot.skip(ftype)
21828 
      iprot.readFieldEnd()
21829 
    iprot.readStructEnd()
21830 
 
21831 
  def write(self, oprot):
21832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21834 
      return
21835 
    oprot.writeStructBegin('getEbayItem_result')
21836 
    if self.success is not None:
21837 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21838 
      self.success.write(oprot)
21839 
      oprot.writeFieldEnd()
21840 
    oprot.writeFieldStop()
21841 
    oprot.writeStructEnd()
21842 
 
21843 
  def validate(self):
21844 
    return
21845 
 
21846 
 
21847 
  def __repr__(self):
21848 
    L = ['%s=%r' % (key, value)
21849 
      for key, value in self.__dict__.iteritems()]
21850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21851 
 
21852 
  def __eq__(self, other):
21853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21854 
 
21855 
  def __ne__(self, other):
21856 
    return not (self == other)
21857 
 
21858 
class updateEbayItem_args:
21859 
  """
21860 
  Attributes:
21861 
   - ebayItem
21862 
  """
21863 
 
21864 
  thrift_spec = (
21865 
    None, # 0
21866 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21867 
  )
21868 
 
21869 
  def __init__(self, ebayItem=None,):
21870 
    self.ebayItem = ebayItem
21871 
 
21872 
  def read(self, iprot):
21873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21875 
      return
21876 
    iprot.readStructBegin()
21877 
    while True:
21878 
      (fname, ftype, fid) = iprot.readFieldBegin()
21879 
      if ftype == TType.STOP:
21880 
        break
21881 
      if fid == 1:
21882 
        if ftype == TType.STRUCT:
21883 
          self.ebayItem = EbayItem()
21884 
          self.ebayItem.read(iprot)
21885 
        else:
21886 
          iprot.skip(ftype)
21887 
      else:
21888 
        iprot.skip(ftype)
21889 
      iprot.readFieldEnd()
21890 
    iprot.readStructEnd()
21891 
 
21892 
  def write(self, oprot):
21893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21895 
      return
21896 
    oprot.writeStructBegin('updateEbayItem_args')
21897 
    if self.ebayItem is not None:
21898 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21899 
      self.ebayItem.write(oprot)
21900 
      oprot.writeFieldEnd()
21901 
    oprot.writeFieldStop()
21902 
    oprot.writeStructEnd()
21903 
 
21904 
  def validate(self):
21905 
    return
21906 
 
21907 
 
21908 
  def __repr__(self):
21909 
    L = ['%s=%r' % (key, value)
21910 
      for key, value in self.__dict__.iteritems()]
21911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21912 
 
21913 
  def __eq__(self, other):
21914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21915 
 
21916 
  def __ne__(self, other):
21917 
    return not (self == other)
21918 
 
21919 
class updateEbayItem_result:
21920 
 
21921 
  thrift_spec = (
21922 
  )
21923 
 
21924 
  def read(self, iprot):
21925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21927 
      return
21928 
    iprot.readStructBegin()
21929 
    while True:
21930 
      (fname, ftype, fid) = iprot.readFieldBegin()
21931 
      if ftype == TType.STOP:
21932 
        break
21933 
      else:
21934 
        iprot.skip(ftype)
21935 
      iprot.readFieldEnd()
21936 
    iprot.readStructEnd()
21937 
 
21938 
  def write(self, oprot):
21939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21941 
      return
21942 
    oprot.writeStructBegin('updateEbayItem_result')
21943 
    oprot.writeFieldStop()
21944 
    oprot.writeStructEnd()
21945 
 
21946 
  def validate(self):
21947 
    return
21948 
 
21949 
 
21950 
  def __repr__(self):
21951 
    L = ['%s=%r' % (key, value)
21952 
      for key, value in self.__dict__.iteritems()]
21953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21954 
 
21955 
  def __eq__(self, other):
21956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21957 
 
21958 
  def __ne__(self, other):
21959 
    return not (self == other)
21960 
 
8139 kshitij.so 21961 
class getAmazonListedItems_args:
21962 
  """
21963 
  Attributes:
21964 
   - offset
21965 
   - limit
21966 
  """
21967 
 
21968 
  thrift_spec = (
21969 
    None, # 0
21970 
    (1, TType.I64, 'offset', None, None, ), # 1
21971 
    (2, TType.I64, 'limit', None, None, ), # 2
21972 
  )
21973 
 
21974 
  def __init__(self, offset=None, limit=None,):
21975 
    self.offset = offset
21976 
    self.limit = limit
21977 
 
21978 
  def read(self, iprot):
21979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21981 
      return
21982 
    iprot.readStructBegin()
21983 
    while True:
21984 
      (fname, ftype, fid) = iprot.readFieldBegin()
21985 
      if ftype == TType.STOP:
21986 
        break
21987 
      if fid == 1:
21988 
        if ftype == TType.I64:
21989 
          self.offset = iprot.readI64();
21990 
        else:
21991 
          iprot.skip(ftype)
21992 
      elif fid == 2:
21993 
        if ftype == TType.I64:
21994 
          self.limit = iprot.readI64();
21995 
        else:
21996 
          iprot.skip(ftype)
21997 
      else:
21998 
        iprot.skip(ftype)
21999 
      iprot.readFieldEnd()
22000 
    iprot.readStructEnd()
22001 
 
22002 
  def write(self, oprot):
22003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22005 
      return
22006 
    oprot.writeStructBegin('getAmazonListedItems_args')
22007 
    if self.offset is not None:
22008 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22009 
      oprot.writeI64(self.offset)
22010 
      oprot.writeFieldEnd()
22011 
    if self.limit is not None:
22012 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22013 
      oprot.writeI64(self.limit)
22014 
      oprot.writeFieldEnd()
22015 
    oprot.writeFieldStop()
22016 
    oprot.writeStructEnd()
22017 
 
22018 
  def validate(self):
22019 
    return
22020 
 
22021 
 
22022 
  def __repr__(self):
22023 
    L = ['%s=%r' % (key, value)
22024 
      for key, value in self.__dict__.iteritems()]
22025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22026 
 
22027 
  def __eq__(self, other):
22028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22029 
 
22030 
  def __ne__(self, other):
22031 
    return not (self == other)
22032 
 
22033 
class getAmazonListedItems_result:
22034 
  """
22035 
  Attributes:
22036 
   - success
22037 
  """
22038 
 
22039 
  thrift_spec = (
22040 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22041 
  )
22042 
 
22043 
  def __init__(self, success=None,):
22044 
    self.success = success
22045 
 
22046 
  def read(self, iprot):
22047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22049 
      return
22050 
    iprot.readStructBegin()
22051 
    while True:
22052 
      (fname, ftype, fid) = iprot.readFieldBegin()
22053 
      if ftype == TType.STOP:
22054 
        break
22055 
      if fid == 0:
22056 
        if ftype == TType.LIST:
22057 
          self.success = []
9155 kshitij.so 22058 
          (_etype477, _size474) = iprot.readListBegin()
22059 
          for _i478 in xrange(_size474):
22060 
            _elem479 = Amazonlisted()
22061 
            _elem479.read(iprot)
22062 
            self.success.append(_elem479)
8139 kshitij.so 22063 
          iprot.readListEnd()
22064 
        else:
22065 
          iprot.skip(ftype)
22066 
      else:
22067 
        iprot.skip(ftype)
22068 
      iprot.readFieldEnd()
22069 
    iprot.readStructEnd()
22070 
 
22071 
  def write(self, oprot):
22072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22074 
      return
22075 
    oprot.writeStructBegin('getAmazonListedItems_result')
22076 
    if self.success is not None:
22077 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22078 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22079 
      for iter480 in self.success:
22080 
        iter480.write(oprot)
8139 kshitij.so 22081 
      oprot.writeListEnd()
22082 
      oprot.writeFieldEnd()
22083 
    oprot.writeFieldStop()
22084 
    oprot.writeStructEnd()
22085 
 
22086 
  def validate(self):
22087 
    return
22088 
 
22089 
 
22090 
  def __repr__(self):
22091 
    L = ['%s=%r' % (key, value)
22092 
      for key, value in self.__dict__.iteritems()]
22093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22094 
 
22095 
  def __eq__(self, other):
22096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22097 
 
22098 
  def __ne__(self, other):
22099 
    return not (self == other)
8168 kshitij.so 22100 
 
22101 
class updateAmazonAttributesInBulk_args:
22102 
  """
22103 
  Attributes:
22104 
   - amazonlisted
22105 
  """
22106 
 
22107 
  thrift_spec = (
22108 
    None, # 0
22109 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
22110 
  )
22111 
 
22112 
  def __init__(self, amazonlisted=None,):
22113 
    self.amazonlisted = amazonlisted
22114 
 
22115 
  def read(self, iprot):
22116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22118 
      return
22119 
    iprot.readStructBegin()
22120 
    while True:
22121 
      (fname, ftype, fid) = iprot.readFieldBegin()
22122 
      if ftype == TType.STOP:
22123 
        break
22124 
      if fid == 1:
22125 
        if ftype == TType.MAP:
22126 
          self.amazonlisted = {}
9155 kshitij.so 22127 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
22128 
          for _i485 in xrange(_size481):
22129 
            _key486 = iprot.readI64();
22130 
            _val487 = Amazonlisted()
22131 
            _val487.read(iprot)
22132 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 22133 
          iprot.readMapEnd()
22134 
        else:
22135 
          iprot.skip(ftype)
22136 
      else:
22137 
        iprot.skip(ftype)
22138 
      iprot.readFieldEnd()
22139 
    iprot.readStructEnd()
22140 
 
22141 
  def write(self, oprot):
22142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22144 
      return
22145 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
22146 
    if self.amazonlisted is not None:
22147 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
22148 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 22149 
      for kiter488,viter489 in self.amazonlisted.items():
22150 
        oprot.writeI64(kiter488)
22151 
        viter489.write(oprot)
8168 kshitij.so 22152 
      oprot.writeMapEnd()
22153 
      oprot.writeFieldEnd()
22154 
    oprot.writeFieldStop()
22155 
    oprot.writeStructEnd()
22156 
 
22157 
  def validate(self):
22158 
    return
22159 
 
22160 
 
22161 
  def __repr__(self):
22162 
    L = ['%s=%r' % (key, value)
22163 
      for key, value in self.__dict__.iteritems()]
22164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22165 
 
22166 
  def __eq__(self, other):
22167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22168 
 
22169 
  def __ne__(self, other):
22170 
    return not (self == other)
22171 
 
22172 
class updateAmazonAttributesInBulk_result:
22173 
  """
22174 
  Attributes:
22175 
   - success
22176 
  """
22177 
 
22178 
  thrift_spec = (
22179 
    (0, TType.BOOL, 'success', None, None, ), # 0
22180 
  )
22181 
 
22182 
  def __init__(self, success=None,):
22183 
    self.success = success
22184 
 
22185 
  def read(self, iprot):
22186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22188 
      return
22189 
    iprot.readStructBegin()
22190 
    while True:
22191 
      (fname, ftype, fid) = iprot.readFieldBegin()
22192 
      if ftype == TType.STOP:
22193 
        break
22194 
      if fid == 0:
22195 
        if ftype == TType.BOOL:
22196 
          self.success = iprot.readBool();
22197 
        else:
22198 
          iprot.skip(ftype)
22199 
      else:
22200 
        iprot.skip(ftype)
22201 
      iprot.readFieldEnd()
22202 
    iprot.readStructEnd()
22203 
 
22204 
  def write(self, oprot):
22205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22207 
      return
22208 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
22209 
    if self.success is not None:
22210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22211 
      oprot.writeBool(self.success)
22212 
      oprot.writeFieldEnd()
22213 
    oprot.writeFieldStop()
22214 
    oprot.writeStructEnd()
22215 
 
22216 
  def validate(self):
22217 
    return
22218 
 
22219 
 
22220 
  def __repr__(self):
22221 
    L = ['%s=%r' % (key, value)
22222 
      for key, value in self.__dict__.iteritems()]
22223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22224 
 
22225 
  def __eq__(self, other):
22226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22227 
 
22228 
  def __ne__(self, other):
22229 
    return not (self == other)
8379 vikram.rag 22230 
 
22231 
class getAllItemstoListOnFba_args:
22232 
 
22233 
  thrift_spec = (
22234 
  )
22235 
 
22236 
  def read(self, iprot):
22237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22239 
      return
22240 
    iprot.readStructBegin()
22241 
    while True:
22242 
      (fname, ftype, fid) = iprot.readFieldBegin()
22243 
      if ftype == TType.STOP:
22244 
        break
22245 
      else:
22246 
        iprot.skip(ftype)
22247 
      iprot.readFieldEnd()
22248 
    iprot.readStructEnd()
22249 
 
22250 
  def write(self, oprot):
22251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22253 
      return
22254 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
22255 
    oprot.writeFieldStop()
22256 
    oprot.writeStructEnd()
22257 
 
22258 
  def validate(self):
22259 
    return
22260 
 
22261 
 
22262 
  def __repr__(self):
22263 
    L = ['%s=%r' % (key, value)
22264 
      for key, value in self.__dict__.iteritems()]
22265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22266 
 
22267 
  def __eq__(self, other):
22268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22269 
 
22270 
  def __ne__(self, other):
22271 
    return not (self == other)
22272 
 
22273 
class getAllItemstoListOnFba_result:
22274 
  """
22275 
  Attributes:
22276 
   - success
22277 
  """
22278 
 
22279 
  thrift_spec = (
22280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22281 
  )
22282 
 
22283 
  def __init__(self, success=None,):
22284 
    self.success = success
22285 
 
22286 
  def read(self, iprot):
22287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22289 
      return
22290 
    iprot.readStructBegin()
22291 
    while True:
22292 
      (fname, ftype, fid) = iprot.readFieldBegin()
22293 
      if ftype == TType.STOP:
22294 
        break
22295 
      if fid == 0:
22296 
        if ftype == TType.LIST:
22297 
          self.success = []
9155 kshitij.so 22298 
          (_etype493, _size490) = iprot.readListBegin()
22299 
          for _i494 in xrange(_size490):
22300 
            _elem495 = Amazonlisted()
22301 
            _elem495.read(iprot)
22302 
            self.success.append(_elem495)
8379 vikram.rag 22303 
          iprot.readListEnd()
22304 
        else:
22305 
          iprot.skip(ftype)
22306 
      else:
22307 
        iprot.skip(ftype)
22308 
      iprot.readFieldEnd()
22309 
    iprot.readStructEnd()
22310 
 
22311 
  def write(self, oprot):
22312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22314 
      return
22315 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
22316 
    if self.success is not None:
22317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22318 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22319 
      for iter496 in self.success:
22320 
        iter496.write(oprot)
8379 vikram.rag 22321 
      oprot.writeListEnd()
22322 
      oprot.writeFieldEnd()
22323 
    oprot.writeFieldStop()
22324 
    oprot.writeStructEnd()
22325 
 
22326 
  def validate(self):
22327 
    return
22328 
 
22329 
 
22330 
  def __repr__(self):
22331 
    L = ['%s=%r' % (key, value)
22332 
      for key, value in self.__dict__.iteritems()]
22333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22334 
 
22335 
  def __eq__(self, other):
22336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22337 
 
22338 
  def __ne__(self, other):
22339 
    return not (self == other)
22340 
 
22341 
class getAllItemstoListOnNonFba_args:
22342 
 
22343 
  thrift_spec = (
22344 
  )
22345 
 
22346 
  def read(self, iprot):
22347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22349 
      return
22350 
    iprot.readStructBegin()
22351 
    while True:
22352 
      (fname, ftype, fid) = iprot.readFieldBegin()
22353 
      if ftype == TType.STOP:
22354 
        break
22355 
      else:
22356 
        iprot.skip(ftype)
22357 
      iprot.readFieldEnd()
22358 
    iprot.readStructEnd()
22359 
 
22360 
  def write(self, oprot):
22361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22363 
      return
22364 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22365 
    oprot.writeFieldStop()
22366 
    oprot.writeStructEnd()
22367 
 
22368 
  def validate(self):
22369 
    return
22370 
 
22371 
 
22372 
  def __repr__(self):
22373 
    L = ['%s=%r' % (key, value)
22374 
      for key, value in self.__dict__.iteritems()]
22375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22376 
 
22377 
  def __eq__(self, other):
22378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22379 
 
22380 
  def __ne__(self, other):
22381 
    return not (self == other)
22382 
 
22383 
class getAllItemstoListOnNonFba_result:
22384 
  """
22385 
  Attributes:
22386 
   - success
22387 
  """
22388 
 
22389 
  thrift_spec = (
22390 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22391 
  )
22392 
 
22393 
  def __init__(self, success=None,):
22394 
    self.success = success
22395 
 
22396 
  def read(self, iprot):
22397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22399 
      return
22400 
    iprot.readStructBegin()
22401 
    while True:
22402 
      (fname, ftype, fid) = iprot.readFieldBegin()
22403 
      if ftype == TType.STOP:
22404 
        break
22405 
      if fid == 0:
22406 
        if ftype == TType.LIST:
22407 
          self.success = []
9155 kshitij.so 22408 
          (_etype500, _size497) = iprot.readListBegin()
22409 
          for _i501 in xrange(_size497):
22410 
            _elem502 = Amazonlisted()
22411 
            _elem502.read(iprot)
22412 
            self.success.append(_elem502)
8379 vikram.rag 22413 
          iprot.readListEnd()
22414 
        else:
22415 
          iprot.skip(ftype)
22416 
      else:
22417 
        iprot.skip(ftype)
22418 
      iprot.readFieldEnd()
22419 
    iprot.readStructEnd()
22420 
 
22421 
  def write(self, oprot):
22422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22424 
      return
22425 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22426 
    if self.success is not None:
22427 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22428 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22429 
      for iter503 in self.success:
22430 
        iter503.write(oprot)
8379 vikram.rag 22431 
      oprot.writeListEnd()
22432 
      oprot.writeFieldEnd()
22433 
    oprot.writeFieldStop()
22434 
    oprot.writeStructEnd()
22435 
 
22436 
  def validate(self):
22437 
    return
22438 
 
22439 
 
22440 
  def __repr__(self):
22441 
    L = ['%s=%r' % (key, value)
22442 
      for key, value in self.__dict__.iteritems()]
22443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22444 
 
22445 
  def __eq__(self, other):
22446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22447 
 
22448 
  def __ne__(self, other):
22449 
    return not (self == other)
8616 vikram.rag 22450 
 
9242 kshitij.so 22451 
class updateAsin_args:
22452 
  """
22453 
  Attributes:
22454 
   - item
22455 
  """
8616 vikram.rag 22456 
 
22457 
  thrift_spec = (
9242 kshitij.so 22458 
    None, # 0
22459 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22460 
  )
22461 
 
9242 kshitij.so 22462 
  def __init__(self, item=None,):
22463 
    self.item = item
22464 
 
8616 vikram.rag 22465 
  def read(self, iprot):
22466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22468 
      return
22469 
    iprot.readStructBegin()
22470 
    while True:
22471 
      (fname, ftype, fid) = iprot.readFieldBegin()
22472 
      if ftype == TType.STOP:
22473 
        break
9242 kshitij.so 22474 
      if fid == 1:
22475 
        if ftype == TType.MAP:
22476 
          self.item = {}
22477 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22478 
          for _i508 in xrange(_size504):
22479 
            _key509 = iprot.readI64();
22480 
            _val510 = Item()
22481 
            _val510.read(iprot)
22482 
            self.item[_key509] = _val510
22483 
          iprot.readMapEnd()
22484 
        else:
22485 
          iprot.skip(ftype)
8616 vikram.rag 22486 
      else:
22487 
        iprot.skip(ftype)
22488 
      iprot.readFieldEnd()
22489 
    iprot.readStructEnd()
22490 
 
22491 
  def write(self, oprot):
22492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22494 
      return
9242 kshitij.so 22495 
    oprot.writeStructBegin('updateAsin_args')
22496 
    if self.item is not None:
22497 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22498 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22499 
      for kiter511,viter512 in self.item.items():
22500 
        oprot.writeI64(kiter511)
22501 
        viter512.write(oprot)
22502 
      oprot.writeMapEnd()
22503 
      oprot.writeFieldEnd()
8616 vikram.rag 22504 
    oprot.writeFieldStop()
22505 
    oprot.writeStructEnd()
22506 
 
22507 
  def validate(self):
22508 
    return
22509 
 
22510 
 
22511 
  def __repr__(self):
22512 
    L = ['%s=%r' % (key, value)
22513 
      for key, value in self.__dict__.iteritems()]
22514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22515 
 
22516 
  def __eq__(self, other):
22517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22518 
 
22519 
  def __ne__(self, other):
22520 
    return not (self == other)
22521 
 
9242 kshitij.so 22522 
class updateAsin_result:
8616 vikram.rag 22523 
 
22524 
  thrift_spec = (
22525 
  )
22526 
 
22527 
  def read(self, iprot):
22528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22530 
      return
22531 
    iprot.readStructBegin()
22532 
    while True:
22533 
      (fname, ftype, fid) = iprot.readFieldBegin()
22534 
      if ftype == TType.STOP:
22535 
        break
22536 
      else:
22537 
        iprot.skip(ftype)
22538 
      iprot.readFieldEnd()
22539 
    iprot.readStructEnd()
22540 
 
22541 
  def write(self, oprot):
22542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22544 
      return
9242 kshitij.so 22545 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22546 
    oprot.writeFieldStop()
22547 
    oprot.writeStructEnd()
22548 
 
22549 
  def validate(self):
22550 
    return
22551 
 
22552 
 
22553 
  def __repr__(self):
22554 
    L = ['%s=%r' % (key, value)
22555 
      for key, value in self.__dict__.iteritems()]
22556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22557 
 
22558 
  def __eq__(self, other):
22559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22560 
 
22561 
  def __ne__(self, other):
22562 
    return not (self == other)
8619 kshitij.so 22563 
 
9242 kshitij.so 22564 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22565 
  """
22566 
  Attributes:
9242 kshitij.so 22567 
   - snapdealitem
8619 kshitij.so 22568 
  """
22569 
 
9242 kshitij.so 22570 
  thrift_spec = None
22571 
  def __init__(self, snapdealitem=None,):
22572 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22573 
 
22574 
  def read(self, iprot):
22575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22577 
      return
22578 
    iprot.readStructBegin()
22579 
    while True:
22580 
      (fname, ftype, fid) = iprot.readFieldBegin()
22581 
      if ftype == TType.STOP:
22582 
        break
9242 kshitij.so 22583 
      if fid == -1:
22584 
        if ftype == TType.STRUCT:
22585 
          self.snapdealitem = SnapdealItem()
22586 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22587 
        else:
22588 
          iprot.skip(ftype)
22589 
      else:
22590 
        iprot.skip(ftype)
22591 
      iprot.readFieldEnd()
22592 
    iprot.readStructEnd()
22593 
 
22594 
  def write(self, oprot):
22595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22597 
      return
9242 kshitij.so 22598 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22599 
    if self.snapdealitem is not None:
22600 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22601 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22602 
      oprot.writeFieldEnd()
22603 
    oprot.writeFieldStop()
22604 
    oprot.writeStructEnd()
22605 
 
22606 
  def validate(self):
22607 
    return
22608 
 
22609 
 
22610 
  def __repr__(self):
22611 
    L = ['%s=%r' % (key, value)
22612 
      for key, value in self.__dict__.iteritems()]
22613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22614 
 
22615 
  def __eq__(self, other):
22616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22617 
 
22618 
  def __ne__(self, other):
22619 
    return not (self == other)
22620 
 
9242 kshitij.so 22621 
class addOrUpdateSnapdealItem_result:
22622 
  """
22623 
  Attributes:
22624 
   - success
22625 
  """
8619 kshitij.so 22626 
 
22627 
  thrift_spec = (
9242 kshitij.so 22628 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22629 
  )
22630 
 
9242 kshitij.so 22631 
  def __init__(self, success=None,):
22632 
    self.success = success
22633 
 
8619 kshitij.so 22634 
  def read(self, iprot):
22635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22637 
      return
22638 
    iprot.readStructBegin()
22639 
    while True:
22640 
      (fname, ftype, fid) = iprot.readFieldBegin()
22641 
      if ftype == TType.STOP:
22642 
        break
9242 kshitij.so 22643 
      if fid == 0:
22644 
        if ftype == TType.BOOL:
22645 
          self.success = iprot.readBool();
22646 
        else:
22647 
          iprot.skip(ftype)
8619 kshitij.so 22648 
      else:
22649 
        iprot.skip(ftype)
22650 
      iprot.readFieldEnd()
22651 
    iprot.readStructEnd()
22652 
 
22653 
  def write(self, oprot):
22654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22656 
      return
9242 kshitij.so 22657 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22658 
    if self.success is not None:
22659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22660 
      oprot.writeBool(self.success)
22661 
      oprot.writeFieldEnd()
8619 kshitij.so 22662 
    oprot.writeFieldStop()
22663 
    oprot.writeStructEnd()
22664 
 
22665 
  def validate(self):
22666 
    return
22667 
 
22668 
 
22669 
  def __repr__(self):
22670 
    L = ['%s=%r' % (key, value)
22671 
      for key, value in self.__dict__.iteritems()]
22672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22673 
 
22674 
  def __eq__(self, other):
22675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22676 
 
22677 
  def __ne__(self, other):
22678 
    return not (self == other)
8739 vikram.rag 22679 
 
9242 kshitij.so 22680 
class getSnapdealItem_args:
8739 vikram.rag 22681 
  """
22682 
  Attributes:
9242 kshitij.so 22683 
   - item_id
8739 vikram.rag 22684 
  """
22685 
 
9242 kshitij.so 22686 
  thrift_spec = (
22687 
    None, # 0
22688 
    (1, TType.I64, 'item_id', None, None, ), # 1
22689 
  )
8739 vikram.rag 22690 
 
9242 kshitij.so 22691 
  def __init__(self, item_id=None,):
22692 
    self.item_id = item_id
22693 
 
8739 vikram.rag 22694 
  def read(self, iprot):
22695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22697 
      return
22698 
    iprot.readStructBegin()
22699 
    while True:
22700 
      (fname, ftype, fid) = iprot.readFieldBegin()
22701 
      if ftype == TType.STOP:
22702 
        break
9242 kshitij.so 22703 
      if fid == 1:
22704 
        if ftype == TType.I64:
22705 
          self.item_id = iprot.readI64();
8739 vikram.rag 22706 
        else:
22707 
          iprot.skip(ftype)
22708 
      else:
22709 
        iprot.skip(ftype)
22710 
      iprot.readFieldEnd()
22711 
    iprot.readStructEnd()
22712 
 
22713 
  def write(self, oprot):
22714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22716 
      return
9242 kshitij.so 22717 
    oprot.writeStructBegin('getSnapdealItem_args')
22718 
    if self.item_id is not None:
22719 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22720 
      oprot.writeI64(self.item_id)
8739 vikram.rag 22721 
      oprot.writeFieldEnd()
22722 
    oprot.writeFieldStop()
22723 
    oprot.writeStructEnd()
22724 
 
22725 
  def validate(self):
22726 
    return
22727 
 
22728 
 
22729 
  def __repr__(self):
22730 
    L = ['%s=%r' % (key, value)
22731 
      for key, value in self.__dict__.iteritems()]
22732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22733 
 
22734 
  def __eq__(self, other):
22735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22736 
 
22737 
  def __ne__(self, other):
22738 
    return not (self == other)
22739 
 
9242 kshitij.so 22740 
class getSnapdealItem_result:
8739 vikram.rag 22741 
  """
22742 
  Attributes:
22743 
   - success
22744 
  """
22745 
 
22746 
  thrift_spec = (
9242 kshitij.so 22747 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 22748 
  )
22749 
 
22750 
  def __init__(self, success=None,):
22751 
    self.success = success
22752 
 
22753 
  def read(self, iprot):
22754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22756 
      return
22757 
    iprot.readStructBegin()
22758 
    while True:
22759 
      (fname, ftype, fid) = iprot.readFieldBegin()
22760 
      if ftype == TType.STOP:
22761 
        break
22762 
      if fid == 0:
9242 kshitij.so 22763 
        if ftype == TType.STRUCT:
22764 
          self.success = SnapdealItem()
22765 
          self.success.read(iprot)
8739 vikram.rag 22766 
        else:
22767 
          iprot.skip(ftype)
22768 
      else:
22769 
        iprot.skip(ftype)
22770 
      iprot.readFieldEnd()
22771 
    iprot.readStructEnd()
22772 
 
22773 
  def write(self, oprot):
22774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22776 
      return
9242 kshitij.so 22777 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 22778 
    if self.success is not None:
9242 kshitij.so 22779 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22780 
      self.success.write(oprot)
8739 vikram.rag 22781 
      oprot.writeFieldEnd()
22782 
    oprot.writeFieldStop()
22783 
    oprot.writeStructEnd()
22784 
 
22785 
  def validate(self):
22786 
    return
22787 
 
22788 
 
22789 
  def __repr__(self):
22790 
    L = ['%s=%r' % (key, value)
22791 
      for key, value in self.__dict__.iteritems()]
22792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22793 
 
22794 
  def __eq__(self, other):
22795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22796 
 
22797 
  def __ne__(self, other):
22798 
    return not (self == other)
22799 
 
9242 kshitij.so 22800 
class getSnapdealItemDetails_args:
8739 vikram.rag 22801 
  """
22802 
  Attributes:
22803 
   - item_id
22804 
  """
22805 
 
22806 
  thrift_spec = (
22807 
    None, # 0
22808 
    (1, TType.I64, 'item_id', None, None, ), # 1
22809 
  )
22810 
 
22811 
  def __init__(self, item_id=None,):
22812 
    self.item_id = item_id
22813 
 
22814 
  def read(self, iprot):
22815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22817 
      return
22818 
    iprot.readStructBegin()
22819 
    while True:
22820 
      (fname, ftype, fid) = iprot.readFieldBegin()
22821 
      if ftype == TType.STOP:
22822 
        break
22823 
      if fid == 1:
22824 
        if ftype == TType.I64:
22825 
          self.item_id = iprot.readI64();
22826 
        else:
22827 
          iprot.skip(ftype)
22828 
      else:
22829 
        iprot.skip(ftype)
22830 
      iprot.readFieldEnd()
22831 
    iprot.readStructEnd()
22832 
 
22833 
  def write(self, oprot):
22834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22836 
      return
9242 kshitij.so 22837 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 22838 
    if self.item_id is not None:
22839 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22840 
      oprot.writeI64(self.item_id)
22841 
      oprot.writeFieldEnd()
22842 
    oprot.writeFieldStop()
22843 
    oprot.writeStructEnd()
22844 
 
22845 
  def validate(self):
22846 
    return
22847 
 
22848 
 
22849 
  def __repr__(self):
22850 
    L = ['%s=%r' % (key, value)
22851 
      for key, value in self.__dict__.iteritems()]
22852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22853 
 
22854 
  def __eq__(self, other):
22855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22856 
 
22857 
  def __ne__(self, other):
22858 
    return not (self == other)
22859 
 
9242 kshitij.so 22860 
class getSnapdealItemDetails_result:
8739 vikram.rag 22861 
  """
22862 
  Attributes:
22863 
   - success
22864 
  """
22865 
 
22866 
  thrift_spec = (
9242 kshitij.so 22867 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 22868 
  )
22869 
 
22870 
  def __init__(self, success=None,):
22871 
    self.success = success
22872 
 
22873 
  def read(self, iprot):
22874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22876 
      return
22877 
    iprot.readStructBegin()
22878 
    while True:
22879 
      (fname, ftype, fid) = iprot.readFieldBegin()
22880 
      if ftype == TType.STOP:
22881 
        break
22882 
      if fid == 0:
22883 
        if ftype == TType.STRUCT:
9242 kshitij.so 22884 
          self.success = SnapdealItemDetails()
8739 vikram.rag 22885 
          self.success.read(iprot)
22886 
        else:
22887 
          iprot.skip(ftype)
22888 
      else:
22889 
        iprot.skip(ftype)
22890 
      iprot.readFieldEnd()
22891 
    iprot.readStructEnd()
22892 
 
22893 
  def write(self, oprot):
22894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22896 
      return
9242 kshitij.so 22897 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 22898 
    if self.success is not None:
22899 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22900 
      self.success.write(oprot)
22901 
      oprot.writeFieldEnd()
22902 
    oprot.writeFieldStop()
22903 
    oprot.writeStructEnd()
22904 
 
22905 
  def validate(self):
22906 
    return
22907 
 
22908 
 
22909 
  def __repr__(self):
22910 
    L = ['%s=%r' % (key, value)
22911 
      for key, value in self.__dict__.iteritems()]
22912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22913 
 
22914 
  def __eq__(self, other):
22915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22916 
 
22917 
  def __ne__(self, other):
22918 
    return not (self == other)
22919 
 
22920 
class getAllSnapdealItems_args:
22921 
 
22922 
  thrift_spec = (
22923 
  )
22924 
 
22925 
  def read(self, iprot):
22926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22928 
      return
22929 
    iprot.readStructBegin()
22930 
    while True:
22931 
      (fname, ftype, fid) = iprot.readFieldBegin()
22932 
      if ftype == TType.STOP:
22933 
        break
22934 
      else:
22935 
        iprot.skip(ftype)
22936 
      iprot.readFieldEnd()
22937 
    iprot.readStructEnd()
22938 
 
22939 
  def write(self, oprot):
22940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22942 
      return
22943 
    oprot.writeStructBegin('getAllSnapdealItems_args')
22944 
    oprot.writeFieldStop()
22945 
    oprot.writeStructEnd()
22946 
 
22947 
  def validate(self):
22948 
    return
22949 
 
22950 
 
22951 
  def __repr__(self):
22952 
    L = ['%s=%r' % (key, value)
22953 
      for key, value in self.__dict__.iteritems()]
22954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22955 
 
22956 
  def __eq__(self, other):
22957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22958 
 
22959 
  def __ne__(self, other):
22960 
    return not (self == other)
22961 
 
22962 
class getAllSnapdealItems_result:
22963 
  """
22964 
  Attributes:
22965 
   - success
22966 
  """
22967 
 
22968 
  thrift_spec = (
9242 kshitij.so 22969 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 22970 
  )
22971 
 
22972 
  def __init__(self, success=None,):
22973 
    self.success = success
22974 
 
22975 
  def read(self, iprot):
22976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22978 
      return
22979 
    iprot.readStructBegin()
22980 
    while True:
22981 
      (fname, ftype, fid) = iprot.readFieldBegin()
22982 
      if ftype == TType.STOP:
22983 
        break
22984 
      if fid == 0:
22985 
        if ftype == TType.LIST:
22986 
          self.success = []
9242 kshitij.so 22987 
          (_etype516, _size513) = iprot.readListBegin()
22988 
          for _i517 in xrange(_size513):
22989 
            _elem518 = SnapdealItemDetails()
22990 
            _elem518.read(iprot)
22991 
            self.success.append(_elem518)
22992 
          iprot.readListEnd()
22993 
        else:
22994 
          iprot.skip(ftype)
22995 
      else:
22996 
        iprot.skip(ftype)
22997 
      iprot.readFieldEnd()
22998 
    iprot.readStructEnd()
22999 
 
23000 
  def write(self, oprot):
23001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23003 
      return
23004 
    oprot.writeStructBegin('getAllSnapdealItems_result')
23005 
    if self.success is not None:
23006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23008 
      for iter519 in self.success:
23009 
        iter519.write(oprot)
23010 
      oprot.writeListEnd()
23011 
      oprot.writeFieldEnd()
23012 
    oprot.writeFieldStop()
23013 
    oprot.writeStructEnd()
23014 
 
23015 
  def validate(self):
23016 
    return
23017 
 
23018 
 
23019 
  def __repr__(self):
23020 
    L = ['%s=%r' % (key, value)
23021 
      for key, value in self.__dict__.iteritems()]
23022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23023 
 
23024 
  def __eq__(self, other):
23025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23026 
 
23027 
  def __ne__(self, other):
23028 
    return not (self == other)
23029 
 
23030 
class getSnapdealItems_args:
23031 
  """
23032 
  Attributes:
23033 
   - offset
23034 
   - limit
23035 
  """
23036 
 
23037 
  thrift_spec = (
23038 
    None, # 0
23039 
    (1, TType.I64, 'offset', None, None, ), # 1
23040 
    (2, TType.I64, 'limit', None, None, ), # 2
23041 
  )
23042 
 
23043 
  def __init__(self, offset=None, limit=None,):
23044 
    self.offset = offset
23045 
    self.limit = limit
23046 
 
23047 
  def read(self, iprot):
23048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23050 
      return
23051 
    iprot.readStructBegin()
23052 
    while True:
23053 
      (fname, ftype, fid) = iprot.readFieldBegin()
23054 
      if ftype == TType.STOP:
23055 
        break
23056 
      if fid == 1:
23057 
        if ftype == TType.I64:
23058 
          self.offset = iprot.readI64();
23059 
        else:
23060 
          iprot.skip(ftype)
23061 
      elif fid == 2:
23062 
        if ftype == TType.I64:
23063 
          self.limit = iprot.readI64();
23064 
        else:
23065 
          iprot.skip(ftype)
23066 
      else:
23067 
        iprot.skip(ftype)
23068 
      iprot.readFieldEnd()
23069 
    iprot.readStructEnd()
23070 
 
23071 
  def write(self, oprot):
23072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23074 
      return
23075 
    oprot.writeStructBegin('getSnapdealItems_args')
23076 
    if self.offset is not None:
23077 
      oprot.writeFieldBegin('offset', TType.I64, 1)
23078 
      oprot.writeI64(self.offset)
23079 
      oprot.writeFieldEnd()
23080 
    if self.limit is not None:
23081 
      oprot.writeFieldBegin('limit', TType.I64, 2)
23082 
      oprot.writeI64(self.limit)
23083 
      oprot.writeFieldEnd()
23084 
    oprot.writeFieldStop()
23085 
    oprot.writeStructEnd()
23086 
 
23087 
  def validate(self):
23088 
    return
23089 
 
23090 
 
23091 
  def __repr__(self):
23092 
    L = ['%s=%r' % (key, value)
23093 
      for key, value in self.__dict__.iteritems()]
23094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23095 
 
23096 
  def __eq__(self, other):
23097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23098 
 
23099 
  def __ne__(self, other):
23100 
    return not (self == other)
23101 
 
23102 
class getSnapdealItems_result:
23103 
  """
23104 
  Attributes:
23105 
   - success
23106 
  """
23107 
 
23108 
  thrift_spec = (
23109 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23110 
  )
23111 
 
23112 
  def __init__(self, success=None,):
23113 
    self.success = success
23114 
 
23115 
  def read(self, iprot):
23116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23118 
      return
23119 
    iprot.readStructBegin()
23120 
    while True:
23121 
      (fname, ftype, fid) = iprot.readFieldBegin()
23122 
      if ftype == TType.STOP:
23123 
        break
23124 
      if fid == 0:
23125 
        if ftype == TType.LIST:
23126 
          self.success = []
9155 kshitij.so 23127 
          (_etype523, _size520) = iprot.readListBegin()
23128 
          for _i524 in xrange(_size520):
9242 kshitij.so 23129 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 23130 
            _elem525.read(iprot)
23131 
            self.success.append(_elem525)
8739 vikram.rag 23132 
          iprot.readListEnd()
23133 
        else:
23134 
          iprot.skip(ftype)
23135 
      else:
23136 
        iprot.skip(ftype)
23137 
      iprot.readFieldEnd()
23138 
    iprot.readStructEnd()
23139 
 
23140 
  def write(self, oprot):
23141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23143 
      return
9242 kshitij.so 23144 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 23145 
    if self.success is not None:
23146 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23147 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 23148 
      for iter526 in self.success:
23149 
        iter526.write(oprot)
8739 vikram.rag 23150 
      oprot.writeListEnd()
23151 
      oprot.writeFieldEnd()
23152 
    oprot.writeFieldStop()
23153 
    oprot.writeStructEnd()
23154 
 
23155 
  def validate(self):
23156 
    return
23157 
 
23158 
 
23159 
  def __repr__(self):
23160 
    L = ['%s=%r' % (key, value)
23161 
      for key, value in self.__dict__.iteritems()]
23162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23163 
 
23164 
  def __eq__(self, other):
23165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23166 
 
23167 
  def __ne__(self, other):
23168 
    return not (self == other)
9242 kshitij.so 23169 
 
23170 
class searchSnapdealItems_args:
23171 
  """
23172 
  Attributes:
23173 
   - searchTerm
23174 
   - offset
23175 
   - limit
23176 
  """
23177 
 
23178 
  thrift_spec = (
23179 
    None, # 0
23180 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23181 
    (2, TType.I64, 'offset', None, None, ), # 2
23182 
    (3, TType.I64, 'limit', None, None, ), # 3
23183 
  )
23184 
 
23185 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
23186 
    self.searchTerm = searchTerm
23187 
    self.offset = offset
23188 
    self.limit = limit
23189 
 
23190 
  def read(self, iprot):
23191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23193 
      return
23194 
    iprot.readStructBegin()
23195 
    while True:
23196 
      (fname, ftype, fid) = iprot.readFieldBegin()
23197 
      if ftype == TType.STOP:
23198 
        break
23199 
      if fid == 1:
23200 
        if ftype == TType.LIST:
23201 
          self.searchTerm = []
23202 
          (_etype530, _size527) = iprot.readListBegin()
23203 
          for _i531 in xrange(_size527):
23204 
            _elem532 = iprot.readString();
23205 
            self.searchTerm.append(_elem532)
23206 
          iprot.readListEnd()
23207 
        else:
23208 
          iprot.skip(ftype)
23209 
      elif fid == 2:
23210 
        if ftype == TType.I64:
23211 
          self.offset = iprot.readI64();
23212 
        else:
23213 
          iprot.skip(ftype)
23214 
      elif fid == 3:
23215 
        if ftype == TType.I64:
23216 
          self.limit = iprot.readI64();
23217 
        else:
23218 
          iprot.skip(ftype)
23219 
      else:
23220 
        iprot.skip(ftype)
23221 
      iprot.readFieldEnd()
23222 
    iprot.readStructEnd()
23223 
 
23224 
  def write(self, oprot):
23225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23227 
      return
23228 
    oprot.writeStructBegin('searchSnapdealItems_args')
23229 
    if self.searchTerm is not None:
23230 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23231 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23232 
      for iter533 in self.searchTerm:
23233 
        oprot.writeString(iter533)
23234 
      oprot.writeListEnd()
23235 
      oprot.writeFieldEnd()
23236 
    if self.offset is not None:
23237 
      oprot.writeFieldBegin('offset', TType.I64, 2)
23238 
      oprot.writeI64(self.offset)
23239 
      oprot.writeFieldEnd()
23240 
    if self.limit is not None:
23241 
      oprot.writeFieldBegin('limit', TType.I64, 3)
23242 
      oprot.writeI64(self.limit)
23243 
      oprot.writeFieldEnd()
23244 
    oprot.writeFieldStop()
23245 
    oprot.writeStructEnd()
23246 
 
23247 
  def validate(self):
23248 
    return
23249 
 
23250 
 
23251 
  def __repr__(self):
23252 
    L = ['%s=%r' % (key, value)
23253 
      for key, value in self.__dict__.iteritems()]
23254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23255 
 
23256 
  def __eq__(self, other):
23257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23258 
 
23259 
  def __ne__(self, other):
23260 
    return not (self == other)
23261 
 
23262 
class searchSnapdealItems_result:
23263 
  """
23264 
  Attributes:
23265 
   - success
23266 
  """
23267 
 
23268 
  thrift_spec = (
23269 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
23270 
  )
23271 
 
23272 
  def __init__(self, success=None,):
23273 
    self.success = success
23274 
 
23275 
  def read(self, iprot):
23276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23278 
      return
23279 
    iprot.readStructBegin()
23280 
    while True:
23281 
      (fname, ftype, fid) = iprot.readFieldBegin()
23282 
      if ftype == TType.STOP:
23283 
        break
23284 
      if fid == 0:
23285 
        if ftype == TType.LIST:
23286 
          self.success = []
23287 
          (_etype537, _size534) = iprot.readListBegin()
23288 
          for _i538 in xrange(_size534):
23289 
            _elem539 = SnapdealItemDetails()
23290 
            _elem539.read(iprot)
23291 
            self.success.append(_elem539)
23292 
          iprot.readListEnd()
23293 
        else:
23294 
          iprot.skip(ftype)
23295 
      else:
23296 
        iprot.skip(ftype)
23297 
      iprot.readFieldEnd()
23298 
    iprot.readStructEnd()
23299 
 
23300 
  def write(self, oprot):
23301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23303 
      return
23304 
    oprot.writeStructBegin('searchSnapdealItems_result')
23305 
    if self.success is not None:
23306 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23307 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
23308 
      for iter540 in self.success:
23309 
        iter540.write(oprot)
23310 
      oprot.writeListEnd()
23311 
      oprot.writeFieldEnd()
23312 
    oprot.writeFieldStop()
23313 
    oprot.writeStructEnd()
23314 
 
23315 
  def validate(self):
23316 
    return
23317 
 
23318 
 
23319 
  def __repr__(self):
23320 
    L = ['%s=%r' % (key, value)
23321 
      for key, value in self.__dict__.iteritems()]
23322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23323 
 
23324 
  def __eq__(self, other):
23325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23326 
 
23327 
  def __ne__(self, other):
23328 
    return not (self == other)
23329 
 
23330 
class getCountForSnapdealItems_args:
23331 
 
23332 
  thrift_spec = (
23333 
  )
23334 
 
23335 
  def read(self, iprot):
23336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23338 
      return
23339 
    iprot.readStructBegin()
23340 
    while True:
23341 
      (fname, ftype, fid) = iprot.readFieldBegin()
23342 
      if ftype == TType.STOP:
23343 
        break
23344 
      else:
23345 
        iprot.skip(ftype)
23346 
      iprot.readFieldEnd()
23347 
    iprot.readStructEnd()
23348 
 
23349 
  def write(self, oprot):
23350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23352 
      return
23353 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
23354 
    oprot.writeFieldStop()
23355 
    oprot.writeStructEnd()
23356 
 
23357 
  def validate(self):
23358 
    return
23359 
 
23360 
 
23361 
  def __repr__(self):
23362 
    L = ['%s=%r' % (key, value)
23363 
      for key, value in self.__dict__.iteritems()]
23364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23365 
 
23366 
  def __eq__(self, other):
23367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23368 
 
23369 
  def __ne__(self, other):
23370 
    return not (self == other)
23371 
 
23372 
class getCountForSnapdealItems_result:
23373 
  """
23374 
  Attributes:
23375 
   - success
23376 
  """
23377 
 
23378 
  thrift_spec = (
23379 
    (0, TType.I64, 'success', None, None, ), # 0
23380 
  )
23381 
 
23382 
  def __init__(self, success=None,):
23383 
    self.success = success
23384 
 
23385 
  def read(self, iprot):
23386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23388 
      return
23389 
    iprot.readStructBegin()
23390 
    while True:
23391 
      (fname, ftype, fid) = iprot.readFieldBegin()
23392 
      if ftype == TType.STOP:
23393 
        break
23394 
      if fid == 0:
23395 
        if ftype == TType.I64:
23396 
          self.success = iprot.readI64();
23397 
        else:
23398 
          iprot.skip(ftype)
23399 
      else:
23400 
        iprot.skip(ftype)
23401 
      iprot.readFieldEnd()
23402 
    iprot.readStructEnd()
23403 
 
23404 
  def write(self, oprot):
23405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23407 
      return
23408 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23409 
    if self.success is not None:
23410 
      oprot.writeFieldBegin('success', TType.I64, 0)
23411 
      oprot.writeI64(self.success)
23412 
      oprot.writeFieldEnd()
23413 
    oprot.writeFieldStop()
23414 
    oprot.writeStructEnd()
23415 
 
23416 
  def validate(self):
23417 
    return
23418 
 
23419 
 
23420 
  def __repr__(self):
23421 
    L = ['%s=%r' % (key, value)
23422 
      for key, value in self.__dict__.iteritems()]
23423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23424 
 
23425 
  def __eq__(self, other):
23426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23427 
 
23428 
  def __ne__(self, other):
23429 
    return not (self == other)
23430 
 
23431 
class getSnapdealSearchResultCount_args:
23432 
  """
23433 
  Attributes:
23434 
   - searchTerm
23435 
  """
23436 
 
23437 
  thrift_spec = (
23438 
    None, # 0
23439 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23440 
  )
23441 
 
23442 
  def __init__(self, searchTerm=None,):
23443 
    self.searchTerm = searchTerm
23444 
 
23445 
  def read(self, iprot):
23446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23448 
      return
23449 
    iprot.readStructBegin()
23450 
    while True:
23451 
      (fname, ftype, fid) = iprot.readFieldBegin()
23452 
      if ftype == TType.STOP:
23453 
        break
23454 
      if fid == 1:
23455 
        if ftype == TType.LIST:
23456 
          self.searchTerm = []
23457 
          (_etype544, _size541) = iprot.readListBegin()
23458 
          for _i545 in xrange(_size541):
23459 
            _elem546 = iprot.readString();
23460 
            self.searchTerm.append(_elem546)
23461 
          iprot.readListEnd()
23462 
        else:
23463 
          iprot.skip(ftype)
23464 
      else:
23465 
        iprot.skip(ftype)
23466 
      iprot.readFieldEnd()
23467 
    iprot.readStructEnd()
23468 
 
23469 
  def write(self, oprot):
23470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23472 
      return
23473 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23474 
    if self.searchTerm is not None:
23475 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23476 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23477 
      for iter547 in self.searchTerm:
23478 
        oprot.writeString(iter547)
23479 
      oprot.writeListEnd()
23480 
      oprot.writeFieldEnd()
23481 
    oprot.writeFieldStop()
23482 
    oprot.writeStructEnd()
23483 
 
23484 
  def validate(self):
23485 
    return
23486 
 
23487 
 
23488 
  def __repr__(self):
23489 
    L = ['%s=%r' % (key, value)
23490 
      for key, value in self.__dict__.iteritems()]
23491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23492 
 
23493 
  def __eq__(self, other):
23494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23495 
 
23496 
  def __ne__(self, other):
23497 
    return not (self == other)
23498 
 
23499 
class getSnapdealSearchResultCount_result:
23500 
  """
23501 
  Attributes:
23502 
   - success
23503 
  """
23504 
 
23505 
  thrift_spec = (
23506 
    (0, TType.I64, 'success', None, None, ), # 0
23507 
  )
23508 
 
23509 
  def __init__(self, success=None,):
23510 
    self.success = success
23511 
 
23512 
  def read(self, iprot):
23513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23515 
      return
23516 
    iprot.readStructBegin()
23517 
    while True:
23518 
      (fname, ftype, fid) = iprot.readFieldBegin()
23519 
      if ftype == TType.STOP:
23520 
        break
23521 
      if fid == 0:
23522 
        if ftype == TType.I64:
23523 
          self.success = iprot.readI64();
23524 
        else:
23525 
          iprot.skip(ftype)
23526 
      else:
23527 
        iprot.skip(ftype)
23528 
      iprot.readFieldEnd()
23529 
    iprot.readStructEnd()
23530 
 
23531 
  def write(self, oprot):
23532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23534 
      return
23535 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23536 
    if self.success is not None:
23537 
      oprot.writeFieldBegin('success', TType.I64, 0)
23538 
      oprot.writeI64(self.success)
23539 
      oprot.writeFieldEnd()
23540 
    oprot.writeFieldStop()
23541 
    oprot.writeStructEnd()
23542 
 
23543 
  def validate(self):
23544 
    return
23545 
 
23546 
 
23547 
  def __repr__(self):
23548 
    L = ['%s=%r' % (key, value)
23549 
      for key, value in self.__dict__.iteritems()]
23550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23551 
 
23552 
  def __eq__(self, other):
23553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23554 
 
23555 
  def __ne__(self, other):
23556 
    return not (self == other)
9299 kshitij.so 23557 
 
23558 
class getPrefferedInsurerForItem_args:
23559 
  """
23560 
  Attributes:
23561 
   - itemId
23562 
   - insurerType
23563 
  """
23564 
 
23565 
  thrift_spec = (
23566 
    None, # 0
23567 
    (1, TType.I64, 'itemId', None, None, ), # 1
23568 
    (2, TType.I32, 'insurerType', None, None, ), # 2
23569 
  )
23570 
 
23571 
  def __init__(self, itemId=None, insurerType=None,):
23572 
    self.itemId = itemId
23573 
    self.insurerType = insurerType
23574 
 
23575 
  def read(self, iprot):
23576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23578 
      return
23579 
    iprot.readStructBegin()
23580 
    while True:
23581 
      (fname, ftype, fid) = iprot.readFieldBegin()
23582 
      if ftype == TType.STOP:
23583 
        break
23584 
      if fid == 1:
23585 
        if ftype == TType.I64:
23586 
          self.itemId = iprot.readI64();
23587 
        else:
23588 
          iprot.skip(ftype)
23589 
      elif fid == 2:
23590 
        if ftype == TType.I32:
23591 
          self.insurerType = iprot.readI32();
23592 
        else:
23593 
          iprot.skip(ftype)
23594 
      else:
23595 
        iprot.skip(ftype)
23596 
      iprot.readFieldEnd()
23597 
    iprot.readStructEnd()
23598 
 
23599 
  def write(self, oprot):
23600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23602 
      return
23603 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
23604 
    if self.itemId is not None:
23605 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23606 
      oprot.writeI64(self.itemId)
23607 
      oprot.writeFieldEnd()
23608 
    if self.insurerType is not None:
23609 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
23610 
      oprot.writeI32(self.insurerType)
23611 
      oprot.writeFieldEnd()
23612 
    oprot.writeFieldStop()
23613 
    oprot.writeStructEnd()
23614 
 
23615 
  def validate(self):
23616 
    return
23617 
 
23618 
 
23619 
  def __repr__(self):
23620 
    L = ['%s=%r' % (key, value)
23621 
      for key, value in self.__dict__.iteritems()]
23622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23623 
 
23624 
  def __eq__(self, other):
23625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23626 
 
23627 
  def __ne__(self, other):
23628 
    return not (self == other)
23629 
 
23630 
class getPrefferedInsurerForItem_result:
23631 
  """
23632 
  Attributes:
23633 
   - success
23634 
  """
23635 
 
23636 
  thrift_spec = (
23637 
    (0, TType.I64, 'success', None, None, ), # 0
23638 
  )
23639 
 
23640 
  def __init__(self, success=None,):
23641 
    self.success = success
23642 
 
23643 
  def read(self, iprot):
23644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23646 
      return
23647 
    iprot.readStructBegin()
23648 
    while True:
23649 
      (fname, ftype, fid) = iprot.readFieldBegin()
23650 
      if ftype == TType.STOP:
23651 
        break
23652 
      if fid == 0:
23653 
        if ftype == TType.I64:
23654 
          self.success = iprot.readI64();
23655 
        else:
23656 
          iprot.skip(ftype)
23657 
      else:
23658 
        iprot.skip(ftype)
23659 
      iprot.readFieldEnd()
23660 
    iprot.readStructEnd()
23661 
 
23662 
  def write(self, oprot):
23663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23665 
      return
23666 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
23667 
    if self.success is not None:
23668 
      oprot.writeFieldBegin('success', TType.I64, 0)
23669 
      oprot.writeI64(self.success)
23670 
      oprot.writeFieldEnd()
23671 
    oprot.writeFieldStop()
23672 
    oprot.writeStructEnd()
23673 
 
23674 
  def validate(self):
23675 
    return
23676 
 
23677 
 
23678 
  def __repr__(self):
23679 
    L = ['%s=%r' % (key, value)
23680 
      for key, value in self.__dict__.iteritems()]
23681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23682 
 
23683 
  def __eq__(self, other):
23684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23685 
 
23686 
  def __ne__(self, other):
23687 
    return not (self == other)
9456 vikram.rag 23688 
 
23689 
class getSnapdealItembySkuAtSnapdeal_args:
23690 
  """
23691 
  Attributes:
23692 
   - skuAtSnapdeal
23693 
  """
23694 
 
23695 
  thrift_spec = None
23696 
  def __init__(self, skuAtSnapdeal=None,):
23697 
    self.skuAtSnapdeal = skuAtSnapdeal
23698 
 
23699 
  def read(self, iprot):
23700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23702 
      return
23703 
    iprot.readStructBegin()
23704 
    while True:
23705 
      (fname, ftype, fid) = iprot.readFieldBegin()
23706 
      if ftype == TType.STOP:
23707 
        break
23708 
      if fid == -1:
23709 
        if ftype == TType.STRING:
23710 
          self.skuAtSnapdeal = iprot.readString();
23711 
        else:
23712 
          iprot.skip(ftype)
23713 
      else:
23714 
        iprot.skip(ftype)
23715 
      iprot.readFieldEnd()
23716 
    iprot.readStructEnd()
23717 
 
23718 
  def write(self, oprot):
23719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23721 
      return
23722 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_args')
23723 
    if self.skuAtSnapdeal is not None:
23724 
      oprot.writeFieldBegin('skuAtSnapdeal', TType.STRING, -1)
23725 
      oprot.writeString(self.skuAtSnapdeal)
23726 
      oprot.writeFieldEnd()
23727 
    oprot.writeFieldStop()
23728 
    oprot.writeStructEnd()
23729 
 
23730 
  def validate(self):
23731 
    return
23732 
 
23733 
 
23734 
  def __repr__(self):
23735 
    L = ['%s=%r' % (key, value)
23736 
      for key, value in self.__dict__.iteritems()]
23737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23738 
 
23739 
  def __eq__(self, other):
23740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23741 
 
23742 
  def __ne__(self, other):
23743 
    return not (self == other)
23744 
 
23745 
class getSnapdealItembySkuAtSnapdeal_result:
23746 
  """
23747 
  Attributes:
23748 
   - success
23749 
  """
23750 
 
23751 
  thrift_spec = (
23752 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
23753 
  )
23754 
 
23755 
  def __init__(self, success=None,):
23756 
    self.success = success
23757 
 
23758 
  def read(self, iprot):
23759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23761 
      return
23762 
    iprot.readStructBegin()
23763 
    while True:
23764 
      (fname, ftype, fid) = iprot.readFieldBegin()
23765 
      if ftype == TType.STOP:
23766 
        break
23767 
      if fid == 0:
23768 
        if ftype == TType.STRUCT:
23769 
          self.success = SnapdealItem()
23770 
          self.success.read(iprot)
23771 
        else:
23772 
          iprot.skip(ftype)
23773 
      else:
23774 
        iprot.skip(ftype)
23775 
      iprot.readFieldEnd()
23776 
    iprot.readStructEnd()
23777 
 
23778 
  def write(self, oprot):
23779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23781 
      return
23782 
    oprot.writeStructBegin('getSnapdealItembySkuAtSnapdeal_result')
23783 
    if self.success is not None:
23784 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23785 
      self.success.write(oprot)
23786 
      oprot.writeFieldEnd()
23787 
    oprot.writeFieldStop()
23788 
    oprot.writeStructEnd()
23789 
 
23790 
  def validate(self):
23791 
    return
23792 
 
23793 
 
23794 
  def __repr__(self):
23795 
    L = ['%s=%r' % (key, value)
23796 
      for key, value in self.__dict__.iteritems()]
23797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23798 
 
23799 
  def __eq__(self, other):
23800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23801 
 
23802 
  def __ne__(self, other):
23803 
    return not (self == other)
9621 manish.sha 23804 
 
23805 
class getProductFeedSubmit_args:
23806 
  """
23807 
  Attributes:
23808 
   - catalogItemId
23809 
  """
23810 
 
23811 
  thrift_spec = (
23812 
    None, # 0
23813 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
23814 
  )
23815 
 
23816 
  def __init__(self, catalogItemId=None,):
23817 
    self.catalogItemId = catalogItemId
23818 
 
23819 
  def read(self, iprot):
23820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23822 
      return
23823 
    iprot.readStructBegin()
23824 
    while True:
23825 
      (fname, ftype, fid) = iprot.readFieldBegin()
23826 
      if ftype == TType.STOP:
23827 
        break
23828 
      if fid == 1:
23829 
        if ftype == TType.I64:
23830 
          self.catalogItemId = iprot.readI64();
23831 
        else:
23832 
          iprot.skip(ftype)
23833 
      else:
23834 
        iprot.skip(ftype)
23835 
      iprot.readFieldEnd()
23836 
    iprot.readStructEnd()
23837 
 
23838 
  def write(self, oprot):
23839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23841 
      return
23842 
    oprot.writeStructBegin('getProductFeedSubmit_args')
23843 
    if self.catalogItemId is not None:
23844 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
23845 
      oprot.writeI64(self.catalogItemId)
23846 
      oprot.writeFieldEnd()
23847 
    oprot.writeFieldStop()
23848 
    oprot.writeStructEnd()
23849 
 
23850 
  def validate(self):
23851 
    return
23852 
 
23853 
 
23854 
  def __repr__(self):
23855 
    L = ['%s=%r' % (key, value)
23856 
      for key, value in self.__dict__.iteritems()]
23857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23858 
 
23859 
  def __eq__(self, other):
23860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23861 
 
23862 
  def __ne__(self, other):
23863 
    return not (self == other)
23864 
 
23865 
class getProductFeedSubmit_result:
23866 
  """
23867 
  Attributes:
23868 
   - success
23869 
   - cex
23870 
  """
23871 
 
23872 
  thrift_spec = (
23873 
    (0, TType.STRUCT, 'success', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 0
23874 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
23875 
  )
23876 
 
23877 
  def __init__(self, success=None, cex=None,):
23878 
    self.success = success
23879 
    self.cex = cex
23880 
 
23881 
  def read(self, iprot):
23882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23884 
      return
23885 
    iprot.readStructBegin()
23886 
    while True:
23887 
      (fname, ftype, fid) = iprot.readFieldBegin()
23888 
      if ftype == TType.STOP:
23889 
        break
23890 
      if fid == 0:
23891 
        if ftype == TType.STRUCT:
23892 
          self.success = ProductFeedSubmit()
23893 
          self.success.read(iprot)
23894 
        else:
23895 
          iprot.skip(ftype)
23896 
      elif fid == 1:
23897 
        if ftype == TType.STRUCT:
23898 
          self.cex = CatalogServiceException()
23899 
          self.cex.read(iprot)
23900 
        else:
23901 
          iprot.skip(ftype)
23902 
      else:
23903 
        iprot.skip(ftype)
23904 
      iprot.readFieldEnd()
23905 
    iprot.readStructEnd()
23906 
 
23907 
  def write(self, oprot):
23908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23910 
      return
23911 
    oprot.writeStructBegin('getProductFeedSubmit_result')
23912 
    if self.success is not None:
23913 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23914 
      self.success.write(oprot)
23915 
      oprot.writeFieldEnd()
23916 
    if self.cex is not None:
23917 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
23918 
      self.cex.write(oprot)
23919 
      oprot.writeFieldEnd()
23920 
    oprot.writeFieldStop()
23921 
    oprot.writeStructEnd()
23922 
 
23923 
  def validate(self):
23924 
    return
23925 
 
23926 
 
23927 
  def __repr__(self):
23928 
    L = ['%s=%r' % (key, value)
23929 
      for key, value in self.__dict__.iteritems()]
23930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23931 
 
23932 
  def __eq__(self, other):
23933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23934 
 
23935 
  def __ne__(self, other):
23936 
    return not (self == other)
23937 
 
23938 
class addProductFeedSubmit_args:
23939 
  """
23940 
  Attributes:
23941 
   - productFeedSubmit
23942 
  """
23943 
 
23944 
  thrift_spec = (
23945 
    None, # 0
23946 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
23947 
  )
23948 
 
23949 
  def __init__(self, productFeedSubmit=None,):
23950 
    self.productFeedSubmit = productFeedSubmit
23951 
 
23952 
  def read(self, iprot):
23953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23955 
      return
23956 
    iprot.readStructBegin()
23957 
    while True:
23958 
      (fname, ftype, fid) = iprot.readFieldBegin()
23959 
      if ftype == TType.STOP:
23960 
        break
23961 
      if fid == 1:
23962 
        if ftype == TType.STRUCT:
23963 
          self.productFeedSubmit = ProductFeedSubmit()
23964 
          self.productFeedSubmit.read(iprot)
23965 
        else:
23966 
          iprot.skip(ftype)
23967 
      else:
23968 
        iprot.skip(ftype)
23969 
      iprot.readFieldEnd()
23970 
    iprot.readStructEnd()
23971 
 
23972 
  def write(self, oprot):
23973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23975 
      return
23976 
    oprot.writeStructBegin('addProductFeedSubmit_args')
23977 
    if self.productFeedSubmit is not None:
23978 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
23979 
      self.productFeedSubmit.write(oprot)
23980 
      oprot.writeFieldEnd()
23981 
    oprot.writeFieldStop()
23982 
    oprot.writeStructEnd()
23983 
 
23984 
  def validate(self):
23985 
    return
23986 
 
23987 
 
23988 
  def __repr__(self):
23989 
    L = ['%s=%r' % (key, value)
23990 
      for key, value in self.__dict__.iteritems()]
23991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23992 
 
23993 
  def __eq__(self, other):
23994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23995 
 
23996 
  def __ne__(self, other):
23997 
    return not (self == other)
23998 
 
23999 
class addProductFeedSubmit_result:
24000 
  """
24001 
  Attributes:
24002 
   - success
24003 
   - cex
24004 
  """
24005 
 
24006 
  thrift_spec = (
24007 
    (0, TType.BOOL, 'success', None, None, ), # 0
24008 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24009 
  )
24010 
 
24011 
  def __init__(self, success=None, cex=None,):
24012 
    self.success = success
24013 
    self.cex = cex
24014 
 
24015 
  def read(self, iprot):
24016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24018 
      return
24019 
    iprot.readStructBegin()
24020 
    while True:
24021 
      (fname, ftype, fid) = iprot.readFieldBegin()
24022 
      if ftype == TType.STOP:
24023 
        break
24024 
      if fid == 0:
24025 
        if ftype == TType.BOOL:
24026 
          self.success = iprot.readBool();
24027 
        else:
24028 
          iprot.skip(ftype)
24029 
      elif fid == 1:
24030 
        if ftype == TType.STRUCT:
24031 
          self.cex = CatalogServiceException()
24032 
          self.cex.read(iprot)
24033 
        else:
24034 
          iprot.skip(ftype)
24035 
      else:
24036 
        iprot.skip(ftype)
24037 
      iprot.readFieldEnd()
24038 
    iprot.readStructEnd()
24039 
 
24040 
  def write(self, oprot):
24041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24043 
      return
24044 
    oprot.writeStructBegin('addProductFeedSubmit_result')
24045 
    if self.success is not None:
24046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24047 
      oprot.writeBool(self.success)
24048 
      oprot.writeFieldEnd()
24049 
    if self.cex is not None:
24050 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24051 
      self.cex.write(oprot)
24052 
      oprot.writeFieldEnd()
24053 
    oprot.writeFieldStop()
24054 
    oprot.writeStructEnd()
24055 
 
24056 
  def validate(self):
24057 
    return
24058 
 
24059 
 
24060 
  def __repr__(self):
24061 
    L = ['%s=%r' % (key, value)
24062 
      for key, value in self.__dict__.iteritems()]
24063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24064 
 
24065 
  def __eq__(self, other):
24066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24067 
 
24068 
  def __ne__(self, other):
24069 
    return not (self == other)
24070 
 
24071 
class updateProductFeedSubmit_args:
24072 
  """
24073 
  Attributes:
24074 
   - productFeedSubmit
24075 
  """
24076 
 
24077 
  thrift_spec = (
24078 
    None, # 0
24079 
    (1, TType.STRUCT, 'productFeedSubmit', (ProductFeedSubmit, ProductFeedSubmit.thrift_spec), None, ), # 1
24080 
  )
24081 
 
24082 
  def __init__(self, productFeedSubmit=None,):
24083 
    self.productFeedSubmit = productFeedSubmit
24084 
 
24085 
  def read(self, iprot):
24086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24088 
      return
24089 
    iprot.readStructBegin()
24090 
    while True:
24091 
      (fname, ftype, fid) = iprot.readFieldBegin()
24092 
      if ftype == TType.STOP:
24093 
        break
24094 
      if fid == 1:
24095 
        if ftype == TType.STRUCT:
24096 
          self.productFeedSubmit = ProductFeedSubmit()
24097 
          self.productFeedSubmit.read(iprot)
24098 
        else:
24099 
          iprot.skip(ftype)
24100 
      else:
24101 
        iprot.skip(ftype)
24102 
      iprot.readFieldEnd()
24103 
    iprot.readStructEnd()
24104 
 
24105 
  def write(self, oprot):
24106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24108 
      return
24109 
    oprot.writeStructBegin('updateProductFeedSubmit_args')
24110 
    if self.productFeedSubmit is not None:
24111 
      oprot.writeFieldBegin('productFeedSubmit', TType.STRUCT, 1)
24112 
      self.productFeedSubmit.write(oprot)
24113 
      oprot.writeFieldEnd()
24114 
    oprot.writeFieldStop()
24115 
    oprot.writeStructEnd()
24116 
 
24117 
  def validate(self):
24118 
    return
24119 
 
24120 
 
24121 
  def __repr__(self):
24122 
    L = ['%s=%r' % (key, value)
24123 
      for key, value in self.__dict__.iteritems()]
24124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24125 
 
24126 
  def __eq__(self, other):
24127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24128 
 
24129 
  def __ne__(self, other):
24130 
    return not (self == other)
24131 
 
24132 
class updateProductFeedSubmit_result:
24133 
  """
24134 
  Attributes:
24135 
   - success
24136 
   - cex
24137 
  """
24138 
 
24139 
  thrift_spec = (
24140 
    (0, TType.BOOL, 'success', None, None, ), # 0
24141 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24142 
  )
24143 
 
24144 
  def __init__(self, success=None, cex=None,):
24145 
    self.success = success
24146 
    self.cex = cex
24147 
 
24148 
  def read(self, iprot):
24149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24151 
      return
24152 
    iprot.readStructBegin()
24153 
    while True:
24154 
      (fname, ftype, fid) = iprot.readFieldBegin()
24155 
      if ftype == TType.STOP:
24156 
        break
24157 
      if fid == 0:
24158 
        if ftype == TType.BOOL:
24159 
          self.success = iprot.readBool();
24160 
        else:
24161 
          iprot.skip(ftype)
24162 
      elif fid == 1:
24163 
        if ftype == TType.STRUCT:
24164 
          self.cex = CatalogServiceException()
24165 
          self.cex.read(iprot)
24166 
        else:
24167 
          iprot.skip(ftype)
24168 
      else:
24169 
        iprot.skip(ftype)
24170 
      iprot.readFieldEnd()
24171 
    iprot.readStructEnd()
24172 
 
24173 
  def write(self, oprot):
24174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24176 
      return
24177 
    oprot.writeStructBegin('updateProductFeedSubmit_result')
24178 
    if self.success is not None:
24179 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24180 
      oprot.writeBool(self.success)
24181 
      oprot.writeFieldEnd()
24182 
    if self.cex is not None:
24183 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24184 
      self.cex.write(oprot)
24185 
      oprot.writeFieldEnd()
24186 
    oprot.writeFieldStop()
24187 
    oprot.writeStructEnd()
24188 
 
24189 
  def validate(self):
24190 
    return
24191 
 
24192 
 
24193 
  def __repr__(self):
24194 
    L = ['%s=%r' % (key, value)
24195 
      for key, value in self.__dict__.iteritems()]
24196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24197 
 
24198 
  def __eq__(self, other):
24199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24200 
 
24201 
  def __ne__(self, other):
24202 
    return not (self == other)
24203 
 
24204 
class deleteProductFeedSubmit_args:
24205 
  """
24206 
  Attributes:
24207 
   - catalogItemId
24208 
  """
24209 
 
24210 
  thrift_spec = (
24211 
    None, # 0
24212 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
24213 
  )
24214 
 
24215 
  def __init__(self, catalogItemId=None,):
24216 
    self.catalogItemId = catalogItemId
24217 
 
24218 
  def read(self, iprot):
24219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24221 
      return
24222 
    iprot.readStructBegin()
24223 
    while True:
24224 
      (fname, ftype, fid) = iprot.readFieldBegin()
24225 
      if ftype == TType.STOP:
24226 
        break
24227 
      if fid == 1:
24228 
        if ftype == TType.I64:
24229 
          self.catalogItemId = iprot.readI64();
24230 
        else:
24231 
          iprot.skip(ftype)
24232 
      else:
24233 
        iprot.skip(ftype)
24234 
      iprot.readFieldEnd()
24235 
    iprot.readStructEnd()
24236 
 
24237 
  def write(self, oprot):
24238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24240 
      return
24241 
    oprot.writeStructBegin('deleteProductFeedSubmit_args')
24242 
    if self.catalogItemId is not None:
24243 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
24244 
      oprot.writeI64(self.catalogItemId)
24245 
      oprot.writeFieldEnd()
24246 
    oprot.writeFieldStop()
24247 
    oprot.writeStructEnd()
24248 
 
24249 
  def validate(self):
24250 
    return
24251 
 
24252 
 
24253 
  def __repr__(self):
24254 
    L = ['%s=%r' % (key, value)
24255 
      for key, value in self.__dict__.iteritems()]
24256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24257 
 
24258 
  def __eq__(self, other):
24259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24260 
 
24261 
  def __ne__(self, other):
24262 
    return not (self == other)
24263 
 
24264 
class deleteProductFeedSubmit_result:
24265 
  """
24266 
  Attributes:
24267 
   - success
24268 
   - cex
24269 
  """
24270 
 
24271 
  thrift_spec = (
24272 
    (0, TType.BOOL, 'success', None, None, ), # 0
24273 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24274 
  )
24275 
 
24276 
  def __init__(self, success=None, cex=None,):
24277 
    self.success = success
24278 
    self.cex = cex
24279 
 
24280 
  def read(self, iprot):
24281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24283 
      return
24284 
    iprot.readStructBegin()
24285 
    while True:
24286 
      (fname, ftype, fid) = iprot.readFieldBegin()
24287 
      if ftype == TType.STOP:
24288 
        break
24289 
      if fid == 0:
24290 
        if ftype == TType.BOOL:
24291 
          self.success = iprot.readBool();
24292 
        else:
24293 
          iprot.skip(ftype)
24294 
      elif fid == 1:
24295 
        if ftype == TType.STRUCT:
24296 
          self.cex = CatalogServiceException()
24297 
          self.cex.read(iprot)
24298 
        else:
24299 
          iprot.skip(ftype)
24300 
      else:
24301 
        iprot.skip(ftype)
24302 
      iprot.readFieldEnd()
24303 
    iprot.readStructEnd()
24304 
 
24305 
  def write(self, oprot):
24306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24308 
      return
24309 
    oprot.writeStructBegin('deleteProductFeedSubmit_result')
24310 
    if self.success is not None:
24311 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
24312 
      oprot.writeBool(self.success)
24313 
      oprot.writeFieldEnd()
24314 
    if self.cex is not None:
24315 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24316 
      self.cex.write(oprot)
24317 
      oprot.writeFieldEnd()
24318 
    oprot.writeFieldStop()
24319 
    oprot.writeStructEnd()
24320 
 
24321 
  def validate(self):
24322 
    return
24323 
 
24324 
 
24325 
  def __repr__(self):
24326 
    L = ['%s=%r' % (key, value)
24327 
      for key, value in self.__dict__.iteritems()]
24328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24329 
 
24330 
  def __eq__(self, other):
24331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24332 
 
24333 
  def __ne__(self, other):
24334 
    return not (self == other)
24335 
 
24336 
class getAllProductFeedSubmit_args:
24337 
 
24338 
  thrift_spec = (
24339 
  )
24340 
 
24341 
  def read(self, iprot):
24342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24344 
      return
24345 
    iprot.readStructBegin()
24346 
    while True:
24347 
      (fname, ftype, fid) = iprot.readFieldBegin()
24348 
      if ftype == TType.STOP:
24349 
        break
24350 
      else:
24351 
        iprot.skip(ftype)
24352 
      iprot.readFieldEnd()
24353 
    iprot.readStructEnd()
24354 
 
24355 
  def write(self, oprot):
24356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24358 
      return
24359 
    oprot.writeStructBegin('getAllProductFeedSubmit_args')
24360 
    oprot.writeFieldStop()
24361 
    oprot.writeStructEnd()
24362 
 
24363 
  def validate(self):
24364 
    return
24365 
 
24366 
 
24367 
  def __repr__(self):
24368 
    L = ['%s=%r' % (key, value)
24369 
      for key, value in self.__dict__.iteritems()]
24370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24371 
 
24372 
  def __eq__(self, other):
24373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24374 
 
24375 
  def __ne__(self, other):
24376 
    return not (self == other)
24377 
 
24378 
class getAllProductFeedSubmit_result:
24379 
  """
24380 
  Attributes:
24381 
   - success
24382 
   - cex
24383 
  """
24384 
 
24385 
  thrift_spec = (
24386 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductFeedSubmit, ProductFeedSubmit.thrift_spec)), None, ), # 0
24387 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
24388 
  )
24389 
 
24390 
  def __init__(self, success=None, cex=None,):
24391 
    self.success = success
24392 
    self.cex = cex
24393 
 
24394 
  def read(self, iprot):
24395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24397 
      return
24398 
    iprot.readStructBegin()
24399 
    while True:
24400 
      (fname, ftype, fid) = iprot.readFieldBegin()
24401 
      if ftype == TType.STOP:
24402 
        break
24403 
      if fid == 0:
24404 
        if ftype == TType.LIST:
24405 
          self.success = []
24406 
          (_etype551, _size548) = iprot.readListBegin()
24407 
          for _i552 in xrange(_size548):
24408 
            _elem553 = ProductFeedSubmit()
24409 
            _elem553.read(iprot)
24410 
            self.success.append(_elem553)
24411 
          iprot.readListEnd()
24412 
        else:
24413 
          iprot.skip(ftype)
24414 
      elif fid == 1:
24415 
        if ftype == TType.STRUCT:
24416 
          self.cex = CatalogServiceException()
24417 
          self.cex.read(iprot)
24418 
        else:
24419 
          iprot.skip(ftype)
24420 
      else:
24421 
        iprot.skip(ftype)
24422 
      iprot.readFieldEnd()
24423 
    iprot.readStructEnd()
24424 
 
24425 
  def write(self, oprot):
24426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24428 
      return
24429 
    oprot.writeStructBegin('getAllProductFeedSubmit_result')
24430 
    if self.success is not None:
24431 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24432 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24433 
      for iter554 in self.success:
24434 
        iter554.write(oprot)
24435 
      oprot.writeListEnd()
24436 
      oprot.writeFieldEnd()
24437 
    if self.cex is not None:
24438 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
24439 
      self.cex.write(oprot)
24440 
      oprot.writeFieldEnd()
24441 
    oprot.writeFieldStop()
24442 
    oprot.writeStructEnd()
24443 
 
24444 
  def validate(self):
24445 
    return
24446 
 
24447 
 
24448 
  def __repr__(self):
24449 
    L = ['%s=%r' % (key, value)
24450 
      for key, value in self.__dict__.iteritems()]
24451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24452 
 
24453 
  def __eq__(self, other):
24454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24455 
 
24456 
  def __ne__(self, other):
24457 
    return not (self == other)