Subversion Repositories SmartDukaan

Rev

Rev 9253 | Rev 9456 | 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 
 
9299 kshitij.so 960 
 
5944 mandeep.dh 961 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
962 
  def __init__(self, iprot, oprot=None):
963 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
964 
 
965 
  def addItem(self, item):
966 
    """
967 
    Availability and inventory attributes
968 
 
969 
    Parameters:
970 
     - item
971 
    """
972 
    self.send_addItem(item)
973 
    return self.recv_addItem()
974 
 
975 
  def send_addItem(self, item):
976 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
977 
    args = addItem_args()
978 
    args.item = item
979 
    args.write(self._oprot)
980 
    self._oprot.writeMessageEnd()
981 
    self._oprot.trans.flush()
982 
 
983 
  def recv_addItem(self, ):
984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
985 
    if mtype == TMessageType.EXCEPTION:
986 
      x = TApplicationException()
987 
      x.read(self._iprot)
988 
      self._iprot.readMessageEnd()
989 
      raise x
990 
    result = addItem_result()
991 
    result.read(self._iprot)
992 
    self._iprot.readMessageEnd()
993 
    if result.success is not None:
994 
      return result.success
995 
    if result.cex is not None:
996 
      raise result.cex
997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
998 
 
999 
  def updateItem(self, item):
1000 
    """
1001 
    Parameters:
1002 
     - item
1003 
    """
1004 
    self.send_updateItem(item)
1005 
    return self.recv_updateItem()
1006 
 
1007 
  def send_updateItem(self, item):
1008 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
1009 
    args = updateItem_args()
1010 
    args.item = item
1011 
    args.write(self._oprot)
1012 
    self._oprot.writeMessageEnd()
1013 
    self._oprot.trans.flush()
1014 
 
1015 
  def recv_updateItem(self, ):
1016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1017 
    if mtype == TMessageType.EXCEPTION:
1018 
      x = TApplicationException()
1019 
      x.read(self._iprot)
1020 
      self._iprot.readMessageEnd()
1021 
      raise x
1022 
    result = updateItem_result()
1023 
    result.read(self._iprot)
1024 
    self._iprot.readMessageEnd()
1025 
    if result.success is not None:
1026 
      return result.success
1027 
    if result.cex is not None:
1028 
      raise result.cex
1029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
1030 
 
1031 
  def isActive(self, itemId):
1032 
    """
1033 
    Checks if the item given to the corresponding itemId is active. If it's active,
1034 
    whether it's risky and if it's risky, its inventory position.
1035 
 
1036 
    Parameters:
1037 
     - itemId
1038 
    """
1039 
    self.send_isActive(itemId)
1040 
    return self.recv_isActive()
1041 
 
1042 
  def send_isActive(self, itemId):
1043 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
1044 
    args = isActive_args()
1045 
    args.itemId = itemId
1046 
    args.write(self._oprot)
1047 
    self._oprot.writeMessageEnd()
1048 
    self._oprot.trans.flush()
1049 
 
1050 
  def recv_isActive(self, ):
1051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1052 
    if mtype == TMessageType.EXCEPTION:
1053 
      x = TApplicationException()
1054 
      x.read(self._iprot)
1055 
      self._iprot.readMessageEnd()
1056 
      raise x
1057 
    result = isActive_result()
1058 
    result.read(self._iprot)
1059 
    self._iprot.readMessageEnd()
1060 
    if result.success is not None:
1061 
      return result.success
1062 
    if result.isex is not None:
1063 
      raise result.isex
1064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1065 
 
7438 amit.gupta 1066 
  def getItemsStatus(self, itemIds):
1067 
    """
1068 
    Parameters:
1069 
     - itemIds
1070 
    """
1071 
    self.send_getItemsStatus(itemIds)
1072 
    return self.recv_getItemsStatus()
1073 
 
1074 
  def send_getItemsStatus(self, itemIds):
1075 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1076 
    args = getItemsStatus_args()
1077 
    args.itemIds = itemIds
1078 
    args.write(self._oprot)
1079 
    self._oprot.writeMessageEnd()
1080 
    self._oprot.trans.flush()
1081 
 
1082 
  def recv_getItemsStatus(self, ):
1083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1084 
    if mtype == TMessageType.EXCEPTION:
1085 
      x = TApplicationException()
1086 
      x.read(self._iprot)
1087 
      self._iprot.readMessageEnd()
1088 
      raise x
1089 
    result = getItemsStatus_result()
1090 
    result.read(self._iprot)
1091 
    self._iprot.readMessageEnd()
1092 
    if result.success is not None:
1093 
      return result.success
1094 
    if result.isex is not None:
1095 
      raise result.isex
1096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1097 
 
5944 mandeep.dh 1098 
  def getItemStatusDescription(self, itemId):
1099 
    """
1100 
    Parameters:
1101 
     - itemId
1102 
    """
1103 
    self.send_getItemStatusDescription(itemId)
1104 
    return self.recv_getItemStatusDescription()
1105 
 
1106 
  def send_getItemStatusDescription(self, itemId):
1107 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1108 
    args = getItemStatusDescription_args()
1109 
    args.itemId = itemId
1110 
    args.write(self._oprot)
1111 
    self._oprot.writeMessageEnd()
1112 
    self._oprot.trans.flush()
1113 
 
1114 
  def recv_getItemStatusDescription(self, ):
1115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1116 
    if mtype == TMessageType.EXCEPTION:
1117 
      x = TApplicationException()
1118 
      x.read(self._iprot)
1119 
      self._iprot.readMessageEnd()
1120 
      raise x
1121 
    result = getItemStatusDescription_result()
1122 
    result.read(self._iprot)
1123 
    self._iprot.readMessageEnd()
1124 
    if result.success is not None:
1125 
      return result.success
1126 
    if result.isex is not None:
1127 
      raise result.isex
1128 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1129 
 
1130 
  def startItemOn(self, item_id, timestamp):
1131 
    """
1132 
    Parameters:
1133 
     - item_id
1134 
     - timestamp
1135 
    """
1136 
    self.send_startItemOn(item_id, timestamp)
1137 
    self.recv_startItemOn()
1138 
 
1139 
  def send_startItemOn(self, item_id, timestamp):
1140 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1141 
    args = startItemOn_args()
1142 
    args.item_id = item_id
1143 
    args.timestamp = timestamp
1144 
    args.write(self._oprot)
1145 
    self._oprot.writeMessageEnd()
1146 
    self._oprot.trans.flush()
1147 
 
1148 
  def recv_startItemOn(self, ):
1149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1150 
    if mtype == TMessageType.EXCEPTION:
1151 
      x = TApplicationException()
1152 
      x.read(self._iprot)
1153 
      self._iprot.readMessageEnd()
1154 
      raise x
1155 
    result = startItemOn_result()
1156 
    result.read(self._iprot)
1157 
    self._iprot.readMessageEnd()
1158 
    if result.cex is not None:
1159 
      raise result.cex
1160 
    return
1161 
 
1162 
  def retireItemOn(self, item_id, timestamp):
1163 
    """
1164 
    Parameters:
1165 
     - item_id
1166 
     - timestamp
1167 
    """
1168 
    self.send_retireItemOn(item_id, timestamp)
1169 
    self.recv_retireItemOn()
1170 
 
1171 
  def send_retireItemOn(self, item_id, timestamp):
1172 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1173 
    args = retireItemOn_args()
1174 
    args.item_id = item_id
1175 
    args.timestamp = timestamp
1176 
    args.write(self._oprot)
1177 
    self._oprot.writeMessageEnd()
1178 
    self._oprot.trans.flush()
1179 
 
1180 
  def recv_retireItemOn(self, ):
1181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1182 
    if mtype == TMessageType.EXCEPTION:
1183 
      x = TApplicationException()
1184 
      x.read(self._iprot)
1185 
      self._iprot.readMessageEnd()
1186 
      raise x
1187 
    result = retireItemOn_result()
1188 
    result.read(self._iprot)
1189 
    self._iprot.readMessageEnd()
1190 
    if result.cex is not None:
1191 
      raise result.cex
1192 
    return
1193 
 
1194 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1195 
    """
1196 
    Parameters:
1197 
     - item_id
1198 
     - timestamp
1199 
     - newstatus
1200 
    """
1201 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1202 
    self.recv_changeItemStatus()
1203 
 
1204 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1205 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1206 
    args = changeItemStatus_args()
1207 
    args.item_id = item_id
1208 
    args.timestamp = timestamp
1209 
    args.newstatus = newstatus
1210 
    args.write(self._oprot)
1211 
    self._oprot.writeMessageEnd()
1212 
    self._oprot.trans.flush()
1213 
 
1214 
  def recv_changeItemStatus(self, ):
1215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1216 
    if mtype == TMessageType.EXCEPTION:
1217 
      x = TApplicationException()
1218 
      x.read(self._iprot)
1219 
      self._iprot.readMessageEnd()
1220 
      raise x
1221 
    result = changeItemStatus_result()
1222 
    result.read(self._iprot)
1223 
    self._iprot.readMessageEnd()
1224 
    if result.cex is not None:
1225 
      raise result.cex
1226 
    return
1227 
 
1228 
  def getItem(self, item_id):
1229 
    """
1230 
    Parameters:
1231 
     - item_id
1232 
    """
1233 
    self.send_getItem(item_id)
1234 
    return self.recv_getItem()
1235 
 
1236 
  def send_getItem(self, item_id):
1237 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1238 
    args = getItem_args()
1239 
    args.item_id = item_id
1240 
    args.write(self._oprot)
1241 
    self._oprot.writeMessageEnd()
1242 
    self._oprot.trans.flush()
1243 
 
1244 
  def recv_getItem(self, ):
1245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1246 
    if mtype == TMessageType.EXCEPTION:
1247 
      x = TApplicationException()
1248 
      x.read(self._iprot)
1249 
      self._iprot.readMessageEnd()
1250 
      raise x
1251 
    result = getItem_result()
1252 
    result.read(self._iprot)
1253 
    self._iprot.readMessageEnd()
1254 
    if result.success is not None:
1255 
      return result.success
1256 
    if result.cex is not None:
1257 
      raise result.cex
1258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1259 
 
1260 
  def getItemsByCatalogId(self, catalog_item_id):
1261 
    """
1262 
    Parameters:
1263 
     - catalog_item_id
1264 
    """
1265 
    self.send_getItemsByCatalogId(catalog_item_id)
1266 
    return self.recv_getItemsByCatalogId()
1267 
 
1268 
  def send_getItemsByCatalogId(self, catalog_item_id):
1269 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1270 
    args = getItemsByCatalogId_args()
1271 
    args.catalog_item_id = catalog_item_id
1272 
    args.write(self._oprot)
1273 
    self._oprot.writeMessageEnd()
1274 
    self._oprot.trans.flush()
1275 
 
1276 
  def recv_getItemsByCatalogId(self, ):
1277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1278 
    if mtype == TMessageType.EXCEPTION:
1279 
      x = TApplicationException()
1280 
      x.read(self._iprot)
1281 
      self._iprot.readMessageEnd()
1282 
      raise x
1283 
    result = getItemsByCatalogId_result()
1284 
    result.read(self._iprot)
1285 
    self._iprot.readMessageEnd()
1286 
    if result.success is not None:
1287 
      return result.success
1288 
    if result.cex is not None:
1289 
      raise result.cex
1290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1291 
 
1292 
  def getValidItemsByCatalogId(self, catalog_item_id):
1293 
    """
1294 
    Parameters:
1295 
     - catalog_item_id
1296 
    """
1297 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1298 
    return self.recv_getValidItemsByCatalogId()
1299 
 
1300 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1301 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1302 
    args = getValidItemsByCatalogId_args()
1303 
    args.catalog_item_id = catalog_item_id
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_getValidItemsByCatalogId(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = getValidItemsByCatalogId_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
1318 
    if result.success is not None:
1319 
      return result.success
1320 
    if result.cex is not None:
1321 
      raise result.cex
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1323 
 
1324 
  def getAllItems(self, isActive):
1325 
    """
1326 
    Parameters:
1327 
     - isActive
1328 
    """
1329 
    self.send_getAllItems(isActive)
1330 
    return self.recv_getAllItems()
1331 
 
1332 
  def send_getAllItems(self, isActive):
1333 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1334 
    args = getAllItems_args()
1335 
    args.isActive = isActive
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_getAllItems(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = getAllItems_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
1350 
    if result.success is not None:
1351 
      return result.success
1352 
    if result.cex is not None:
1353 
      raise result.cex
1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1355 
 
1356 
  def getAllItemsByStatus(self, itemStatus):
1357 
    """
1358 
    Parameters:
1359 
     - itemStatus
1360 
    """
1361 
    self.send_getAllItemsByStatus(itemStatus)
1362 
    return self.recv_getAllItemsByStatus()
1363 
 
1364 
  def send_getAllItemsByStatus(self, itemStatus):
1365 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1366 
    args = getAllItemsByStatus_args()
1367 
    args.itemStatus = itemStatus
1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
1372 
  def recv_getAllItemsByStatus(self, ):
1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
1379 
    result = getAllItemsByStatus_result()
1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
1382 
    if result.success is not None:
1383 
      return result.success
1384 
    if result.cex is not None:
1385 
      raise result.cex
1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1387 
 
9253 rajveer 1388 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1389 
    """
1390 
    Parameters:
1391 
     - entityId
1392 
     - category
1393 
     - brand
1394 
     - modelName
1395 
     - modelNumber
9253 rajveer 1396 
     - isAndroid
5944 mandeep.dh 1397 
    """
9253 rajveer 1398 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber, isAndroid)
5944 mandeep.dh 1399 
    return self.recv_markItemAsContentComplete()
1400 
 
9253 rajveer 1401 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber, isAndroid):
5944 mandeep.dh 1402 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1403 
    args = markItemAsContentComplete_args()
1404 
    args.entityId = entityId
1405 
    args.category = category
1406 
    args.brand = brand
1407 
    args.modelName = modelName
1408 
    args.modelNumber = modelNumber
9253 rajveer 1409 
    args.isAndroid = isAndroid
5944 mandeep.dh 1410 
    args.write(self._oprot)
1411 
    self._oprot.writeMessageEnd()
1412 
    self._oprot.trans.flush()
1413 
 
1414 
  def recv_markItemAsContentComplete(self, ):
1415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1416 
    if mtype == TMessageType.EXCEPTION:
1417 
      x = TApplicationException()
1418 
      x.read(self._iprot)
1419 
      self._iprot.readMessageEnd()
1420 
      raise x
1421 
    result = markItemAsContentComplete_result()
1422 
    result.read(self._iprot)
1423 
    self._iprot.readMessageEnd()
1424 
    if result.success is not None:
1425 
      return result.success
1426 
    if result.cex is not None:
1427 
      raise result.cex
1428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1429 
 
1430 
  def getAllItemsInRange(self, offset, limit):
1431 
    """
1432 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1433 
 
1434 
    Parameters:
1435 
     - offset
1436 
     - limit
1437 
    """
1438 
    self.send_getAllItemsInRange(offset, limit)
1439 
    return self.recv_getAllItemsInRange()
1440 
 
1441 
  def send_getAllItemsInRange(self, offset, limit):
1442 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1443 
    args = getAllItemsInRange_args()
1444 
    args.offset = offset
1445 
    args.limit = limit
1446 
    args.write(self._oprot)
1447 
    self._oprot.writeMessageEnd()
1448 
    self._oprot.trans.flush()
1449 
 
1450 
  def recv_getAllItemsInRange(self, ):
1451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1452 
    if mtype == TMessageType.EXCEPTION:
1453 
      x = TApplicationException()
1454 
      x.read(self._iprot)
1455 
      self._iprot.readMessageEnd()
1456 
      raise x
1457 
    result = getAllItemsInRange_result()
1458 
    result.read(self._iprot)
1459 
    self._iprot.readMessageEnd()
1460 
    if result.success is not None:
1461 
      return result.success
1462 
    if result.cex is not None:
1463 
      raise result.cex
1464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1465 
 
1466 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1467 
    """
1468 
    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.
1469 
 
1470 
    Parameters:
1471 
     - itemStatus
1472 
     - offset
1473 
     - limit
1474 
    """
1475 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1476 
    return self.recv_getAllItemsByStatusInRange()
1477 
 
1478 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1479 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1480 
    args = getAllItemsByStatusInRange_args()
1481 
    args.itemStatus = itemStatus
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_getAllItemsByStatusInRange(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 = getAllItemsByStatusInRange_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, "getAllItemsByStatusInRange failed: unknown result");
1503 
 
1504 
  def getItemCountByStatus(self, useStatus, itemStatus):
1505 
    """
1506 
    Gets a count of all items by status
1507 
 
1508 
    Parameters:
1509 
     - useStatus
1510 
     - itemStatus
1511 
    """
1512 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1513 
    return self.recv_getItemCountByStatus()
1514 
 
1515 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1516 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1517 
    args = getItemCountByStatus_args()
1518 
    args.useStatus = useStatus
1519 
    args.itemStatus = itemStatus
1520 
    args.write(self._oprot)
1521 
    self._oprot.writeMessageEnd()
1522 
    self._oprot.trans.flush()
1523 
 
1524 
  def recv_getItemCountByStatus(self, ):
1525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1526 
    if mtype == TMessageType.EXCEPTION:
1527 
      x = TApplicationException()
1528 
      x.read(self._iprot)
1529 
      self._iprot.readMessageEnd()
1530 
      raise x
1531 
    result = getItemCountByStatus_result()
1532 
    result.read(self._iprot)
1533 
    self._iprot.readMessageEnd()
1534 
    if result.success is not None:
1535 
      return result.success
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1537 
 
1538 
  def getBestSellers(self, ):
1539 
    self.send_getBestSellers()
1540 
    return self.recv_getBestSellers()
1541 
 
1542 
  def send_getBestSellers(self, ):
1543 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1544 
    args = getBestSellers_args()
1545 
    args.write(self._oprot)
1546 
    self._oprot.writeMessageEnd()
1547 
    self._oprot.trans.flush()
1548 
 
1549 
  def recv_getBestSellers(self, ):
1550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1551 
    if mtype == TMessageType.EXCEPTION:
1552 
      x = TApplicationException()
1553 
      x.read(self._iprot)
1554 
      self._iprot.readMessageEnd()
1555 
      raise x
1556 
    result = getBestSellers_result()
1557 
    result.read(self._iprot)
1558 
    self._iprot.readMessageEnd()
1559 
    if result.success is not None:
1560 
      return result.success
1561 
    if result.isex is not None:
1562 
      raise result.isex
1563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1564 
 
1565 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1566 
    """
1567 
    Parameters:
1568 
     - beginIndex
1569 
     - totalItems
1570 
     - brand
1571 
     - category
1572 
    """
1573 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1574 
    return self.recv_getBestSellersCatalogIds()
1575 
 
1576 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1577 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1578 
    args = getBestSellersCatalogIds_args()
1579 
    args.beginIndex = beginIndex
1580 
    args.totalItems = totalItems
1581 
    args.brand = brand
1582 
    args.category = category
1583 
    args.write(self._oprot)
1584 
    self._oprot.writeMessageEnd()
1585 
    self._oprot.trans.flush()
1586 
 
1587 
  def recv_getBestSellersCatalogIds(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 = getBestSellersCatalogIds_result()
1595 
    result.read(self._iprot)
1596 
    self._iprot.readMessageEnd()
1597 
    if result.success is not None:
1598 
      return result.success
1599 
    if result.cex is not None:
1600 
      raise result.cex
1601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1602 
 
1603 
  def getBestSellersCount(self, ):
1604 
    self.send_getBestSellersCount()
1605 
    return self.recv_getBestSellersCount()
1606 
 
1607 
  def send_getBestSellersCount(self, ):
1608 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1609 
    args = getBestSellersCount_args()
1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1614 
  def recv_getBestSellersCount(self, ):
1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1621 
    result = getBestSellersCount_result()
1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
1624 
    if result.success is not None:
1625 
      return result.success
1626 
    if result.cex is not None:
1627 
      raise result.cex
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1629 
 
1630 
  def getBestDeals(self, ):
1631 
    self.send_getBestDeals()
1632 
    return self.recv_getBestDeals()
1633 
 
1634 
  def send_getBestDeals(self, ):
1635 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1636 
    args = getBestDeals_args()
1637 
    args.write(self._oprot)
1638 
    self._oprot.writeMessageEnd()
1639 
    self._oprot.trans.flush()
1640 
 
1641 
  def recv_getBestDeals(self, ):
1642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1643 
    if mtype == TMessageType.EXCEPTION:
1644 
      x = TApplicationException()
1645 
      x.read(self._iprot)
1646 
      self._iprot.readMessageEnd()
1647 
      raise x
1648 
    result = getBestDeals_result()
1649 
    result.read(self._iprot)
1650 
    self._iprot.readMessageEnd()
1651 
    if result.success is not None:
1652 
      return result.success
1653 
    if result.isex is not None:
1654 
      raise result.isex
1655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1656 
 
1657 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1658 
    """
1659 
    Parameters:
1660 
     - beginIndex
1661 
     - totalItems
1662 
     - brand
1663 
     - category
1664 
    """
1665 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1666 
    return self.recv_getBestDealsCatalogIds()
1667 
 
1668 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1669 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1670 
    args = getBestDealsCatalogIds_args()
1671 
    args.beginIndex = beginIndex
1672 
    args.totalItems = totalItems
1673 
    args.brand = brand
1674 
    args.category = category
1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_getBestDealsCatalogIds(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 = getBestDealsCatalogIds_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
1689 
    if result.success is not None:
1690 
      return result.success
1691 
    if result.cex is not None:
1692 
      raise result.cex
1693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1694 
 
1695 
  def getBestDealsCount(self, ):
1696 
    self.send_getBestDealsCount()
1697 
    return self.recv_getBestDealsCount()
1698 
 
1699 
  def send_getBestDealsCount(self, ):
1700 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1701 
    args = getBestDealsCount_args()
1702 
    args.write(self._oprot)
1703 
    self._oprot.writeMessageEnd()
1704 
    self._oprot.trans.flush()
1705 
 
1706 
  def recv_getBestDealsCount(self, ):
1707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1708 
    if mtype == TMessageType.EXCEPTION:
1709 
      x = TApplicationException()
1710 
      x.read(self._iprot)
1711 
      self._iprot.readMessageEnd()
1712 
      raise x
1713 
    result = getBestDealsCount_result()
1714 
    result.read(self._iprot)
1715 
    self._iprot.readMessageEnd()
1716 
    if result.success is not None:
1717 
      return result.success
1718 
    if result.cex is not None:
1719 
      raise result.cex
1720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1721 
 
1722 
  def getComingSoon(self, ):
1723 
    self.send_getComingSoon()
1724 
    return self.recv_getComingSoon()
1725 
 
1726 
  def send_getComingSoon(self, ):
1727 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1728 
    args = getComingSoon_args()
1729 
    args.write(self._oprot)
1730 
    self._oprot.writeMessageEnd()
1731 
    self._oprot.trans.flush()
1732 
 
1733 
  def recv_getComingSoon(self, ):
1734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1735 
    if mtype == TMessageType.EXCEPTION:
1736 
      x = TApplicationException()
1737 
      x.read(self._iprot)
1738 
      self._iprot.readMessageEnd()
1739 
      raise x
1740 
    result = getComingSoon_result()
1741 
    result.read(self._iprot)
1742 
    self._iprot.readMessageEnd()
1743 
    if result.success is not None:
1744 
      return result.success
1745 
    if result.isex is not None:
1746 
      raise result.isex
1747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1748 
 
1749 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1750 
    """
1751 
    Parameters:
1752 
     - beginIndex
1753 
     - totalItems
1754 
     - brand
1755 
     - category
1756 
    """
1757 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1758 
    return self.recv_getComingSoonCatalogIds()
1759 
 
1760 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1761 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1762 
    args = getComingSoonCatalogIds_args()
1763 
    args.beginIndex = beginIndex
1764 
    args.totalItems = totalItems
1765 
    args.brand = brand
1766 
    args.category = category
1767 
    args.write(self._oprot)
1768 
    self._oprot.writeMessageEnd()
1769 
    self._oprot.trans.flush()
1770 
 
1771 
  def recv_getComingSoonCatalogIds(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 = getComingSoonCatalogIds_result()
1779 
    result.read(self._iprot)
1780 
    self._iprot.readMessageEnd()
1781 
    if result.success is not None:
1782 
      return result.success
1783 
    if result.cex is not None:
1784 
      raise result.cex
1785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1786 
 
1787 
  def getComingSoonCount(self, ):
1788 
    self.send_getComingSoonCount()
1789 
    return self.recv_getComingSoonCount()
1790 
 
1791 
  def send_getComingSoonCount(self, ):
1792 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1793 
    args = getComingSoonCount_args()
1794 
    args.write(self._oprot)
1795 
    self._oprot.writeMessageEnd()
1796 
    self._oprot.trans.flush()
1797 
 
1798 
  def recv_getComingSoonCount(self, ):
1799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1800 
    if mtype == TMessageType.EXCEPTION:
1801 
      x = TApplicationException()
1802 
      x.read(self._iprot)
1803 
      self._iprot.readMessageEnd()
1804 
      raise x
1805 
    result = getComingSoonCount_result()
1806 
    result.read(self._iprot)
1807 
    self._iprot.readMessageEnd()
1808 
    if result.success is not None:
1809 
      return result.success
1810 
    if result.cex is not None:
1811 
      raise result.cex
1812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1813 
 
1814 
  def getLatestArrivals(self, ):
1815 
    """
1816 
    Returns a list of items sorted in the descending order by start date.
1817 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1818 
    """
1819 
    self.send_getLatestArrivals()
1820 
    return self.recv_getLatestArrivals()
1821 
 
1822 
  def send_getLatestArrivals(self, ):
1823 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1824 
    args = getLatestArrivals_args()
1825 
    args.write(self._oprot)
1826 
    self._oprot.writeMessageEnd()
1827 
    self._oprot.trans.flush()
1828 
 
1829 
  def recv_getLatestArrivals(self, ):
1830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1831 
    if mtype == TMessageType.EXCEPTION:
1832 
      x = TApplicationException()
1833 
      x.read(self._iprot)
1834 
      self._iprot.readMessageEnd()
1835 
      raise x
1836 
    result = getLatestArrivals_result()
1837 
    result.read(self._iprot)
1838 
    self._iprot.readMessageEnd()
1839 
    if result.success is not None:
1840 
      return result.success
1841 
    if result.isex is not None:
1842 
      raise result.isex
1843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1844 
 
1845 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1846 
    """
1847 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1848 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1849 
 
1850 
    Parameters:
1851 
     - beginIndex
1852 
     - totalItems
1853 
     - brand
1854 
     - categories
1855 
    """
1856 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1857 
    return self.recv_getLatestArrivalsCatalogIds()
1858 
 
1859 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1860 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1861 
    args = getLatestArrivalsCatalogIds_args()
1862 
    args.beginIndex = beginIndex
1863 
    args.totalItems = totalItems
1864 
    args.brand = brand
1865 
    args.categories = categories
1866 
    args.write(self._oprot)
1867 
    self._oprot.writeMessageEnd()
1868 
    self._oprot.trans.flush()
1869 
 
1870 
  def recv_getLatestArrivalsCatalogIds(self, ):
1871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1872 
    if mtype == TMessageType.EXCEPTION:
1873 
      x = TApplicationException()
1874 
      x.read(self._iprot)
1875 
      self._iprot.readMessageEnd()
1876 
      raise x
1877 
    result = getLatestArrivalsCatalogIds_result()
1878 
    result.read(self._iprot)
1879 
    self._iprot.readMessageEnd()
1880 
    if result.success is not None:
1881 
      return result.success
1882 
    if result.cex is not None:
1883 
      raise result.cex
1884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1885 
 
1886 
  def getLatestArrivalsCount(self, ):
1887 
    """
1888 
    Get the total number of latest arrivals we are willing to show.
1889 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1890 
    """
1891 
    self.send_getLatestArrivalsCount()
1892 
    return self.recv_getLatestArrivalsCount()
1893 
 
1894 
  def send_getLatestArrivalsCount(self, ):
1895 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1896 
    args = getLatestArrivalsCount_args()
1897 
    args.write(self._oprot)
1898 
    self._oprot.writeMessageEnd()
1899 
    self._oprot.trans.flush()
1900 
 
1901 
  def recv_getLatestArrivalsCount(self, ):
1902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1903 
    if mtype == TMessageType.EXCEPTION:
1904 
      x = TApplicationException()
1905 
      x.read(self._iprot)
1906 
      self._iprot.readMessageEnd()
1907 
      raise x
1908 
    result = getLatestArrivalsCount_result()
1909 
    result.read(self._iprot)
1910 
    self._iprot.readMessageEnd()
1911 
    if result.success is not None:
1912 
      return result.success
1913 
    if result.cex is not None:
1914 
      raise result.cex
1915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1916 
 
1917 
  def generateNewEntityID(self, ):
1918 
    self.send_generateNewEntityID()
1919 
    return self.recv_generateNewEntityID()
1920 
 
1921 
  def send_generateNewEntityID(self, ):
1922 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1923 
    args = generateNewEntityID_args()
1924 
    args.write(self._oprot)
1925 
    self._oprot.writeMessageEnd()
1926 
    self._oprot.trans.flush()
1927 
 
1928 
  def recv_generateNewEntityID(self, ):
1929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1930 
    if mtype == TMessageType.EXCEPTION:
1931 
      x = TApplicationException()
1932 
      x.read(self._iprot)
1933 
      self._iprot.readMessageEnd()
1934 
      raise x
1935 
    result = generateNewEntityID_result()
1936 
    result.read(self._iprot)
1937 
    self._iprot.readMessageEnd()
1938 
    if result.success is not None:
1939 
      return result.success
1940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1941 
 
1942 
  def addCategory(self, category):
1943 
    """
1944 
    All category related functions
1945 
 
1946 
    Parameters:
1947 
     - category
1948 
    """
1949 
    self.send_addCategory(category)
1950 
    return self.recv_addCategory()
1951 
 
1952 
  def send_addCategory(self, category):
1953 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1954 
    args = addCategory_args()
1955 
    args.category = category
1956 
    args.write(self._oprot)
1957 
    self._oprot.writeMessageEnd()
1958 
    self._oprot.trans.flush()
1959 
 
1960 
  def recv_addCategory(self, ):
1961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1962 
    if mtype == TMessageType.EXCEPTION:
1963 
      x = TApplicationException()
1964 
      x.read(self._iprot)
1965 
      self._iprot.readMessageEnd()
1966 
      raise x
1967 
    result = addCategory_result()
1968 
    result.read(self._iprot)
1969 
    self._iprot.readMessageEnd()
1970 
    if result.success is not None:
1971 
      return result.success
1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1973 
 
1974 
  def getCategory(self, id):
1975 
    """
1976 
    Parameters:
1977 
     - id
1978 
    """
1979 
    self.send_getCategory(id)
1980 
    return self.recv_getCategory()
1981 
 
1982 
  def send_getCategory(self, id):
1983 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1984 
    args = getCategory_args()
1985 
    args.id = id
1986 
    args.write(self._oprot)
1987 
    self._oprot.writeMessageEnd()
1988 
    self._oprot.trans.flush()
1989 
 
1990 
  def recv_getCategory(self, ):
1991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1992 
    if mtype == TMessageType.EXCEPTION:
1993 
      x = TApplicationException()
1994 
      x.read(self._iprot)
1995 
      self._iprot.readMessageEnd()
1996 
      raise x
1997 
    result = getCategory_result()
1998 
    result.read(self._iprot)
1999 
    self._iprot.readMessageEnd()
2000 
    if result.success is not None:
2001 
      return result.success
2002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
2003 
 
2004 
  def getAllCategories(self, ):
2005 
    self.send_getAllCategories()
2006 
    return self.recv_getAllCategories()
2007 
 
2008 
  def send_getAllCategories(self, ):
2009 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
2010 
    args = getAllCategories_args()
2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
2015 
  def recv_getAllCategories(self, ):
2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
2022 
    result = getAllCategories_result()
2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
2025 
    if result.success is not None:
2026 
      return result.success
2027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
2028 
 
2029 
  def getAllSimilarItems(self, itemId):
2030 
    """
2031 
    Returns the list of similar items.
2032 
 
2033 
    Parameters:
2034 
     - itemId
2035 
    """
2036 
    self.send_getAllSimilarItems(itemId)
2037 
    return self.recv_getAllSimilarItems()
2038 
 
2039 
  def send_getAllSimilarItems(self, itemId):
2040 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
2041 
    args = getAllSimilarItems_args()
2042 
    args.itemId = itemId
2043 
    args.write(self._oprot)
2044 
    self._oprot.writeMessageEnd()
2045 
    self._oprot.trans.flush()
2046 
 
2047 
  def recv_getAllSimilarItems(self, ):
2048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2049 
    if mtype == TMessageType.EXCEPTION:
2050 
      x = TApplicationException()
2051 
      x.read(self._iprot)
2052 
      self._iprot.readMessageEnd()
2053 
      raise x
2054 
    result = getAllSimilarItems_result()
2055 
    result.read(self._iprot)
2056 
    self._iprot.readMessageEnd()
2057 
    if result.success is not None:
2058 
      return result.success
2059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2060 
 
2061 
  def addSimilarItem(self, itemId, catalogItemId):
2062 
    """
2063 
    Adds similar item.
2064 
 
2065 
    Parameters:
2066 
     - itemId
2067 
     - catalogItemId
2068 
    """
2069 
    self.send_addSimilarItem(itemId, catalogItemId)
2070 
    return self.recv_addSimilarItem()
2071 
 
2072 
  def send_addSimilarItem(self, itemId, catalogItemId):
2073 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2074 
    args = addSimilarItem_args()
2075 
    args.itemId = itemId
2076 
    args.catalogItemId = catalogItemId
2077 
    args.write(self._oprot)
2078 
    self._oprot.writeMessageEnd()
2079 
    self._oprot.trans.flush()
2080 
 
2081 
  def recv_addSimilarItem(self, ):
2082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2083 
    if mtype == TMessageType.EXCEPTION:
2084 
      x = TApplicationException()
2085 
      x.read(self._iprot)
2086 
      self._iprot.readMessageEnd()
2087 
      raise x
2088 
    result = addSimilarItem_result()
2089 
    result.read(self._iprot)
2090 
    self._iprot.readMessageEnd()
2091 
    if result.success is not None:
2092 
      return result.success
2093 
    if result.cex is not None:
2094 
      raise result.cex
2095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2096 
 
6512 kshitij.so 2097 
  def addTag(self, displayName, itemId):
2098 
    """
2099 
    Tag Related
2100 
 
2101 
    Parameters:
2102 
     - displayName
2103 
     - itemId
2104 
    """
2105 
    self.send_addTag(displayName, itemId)
2106 
    return self.recv_addTag()
2107 
 
2108 
  def send_addTag(self, displayName, itemId):
2109 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2110 
    args = addTag_args()
2111 
    args.displayName = displayName
2112 
    args.itemId = itemId
2113 
    args.write(self._oprot)
2114 
    self._oprot.writeMessageEnd()
2115 
    self._oprot.trans.flush()
2116 
 
2117 
  def recv_addTag(self, ):
2118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2119 
    if mtype == TMessageType.EXCEPTION:
2120 
      x = TApplicationException()
2121 
      x.read(self._iprot)
2122 
      self._iprot.readMessageEnd()
2123 
      raise x
2124 
    result = addTag_result()
2125 
    result.read(self._iprot)
2126 
    self._iprot.readMessageEnd()
2127 
    if result.success is not None:
2128 
      return result.success
2129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2130 
 
2131 
  def deleteEntityTag(self, displayName, itemId):
2132 
    """
2133 
    Parameters:
2134 
     - displayName
2135 
     - itemId
2136 
    """
2137 
    self.send_deleteEntityTag(displayName, itemId)
2138 
    return self.recv_deleteEntityTag()
2139 
 
2140 
  def send_deleteEntityTag(self, displayName, itemId):
2141 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2142 
    args = deleteEntityTag_args()
2143 
    args.displayName = displayName
2144 
    args.itemId = itemId
2145 
    args.write(self._oprot)
2146 
    self._oprot.writeMessageEnd()
2147 
    self._oprot.trans.flush()
2148 
 
2149 
  def recv_deleteEntityTag(self, ):
2150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2151 
    if mtype == TMessageType.EXCEPTION:
2152 
      x = TApplicationException()
2153 
      x.read(self._iprot)
2154 
      self._iprot.readMessageEnd()
2155 
      raise x
2156 
    result = deleteEntityTag_result()
2157 
    result.read(self._iprot)
2158 
    self._iprot.readMessageEnd()
2159 
    if result.success is not None:
2160 
      return result.success
2161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2162 
 
2163 
  def deleteTag(self, displayName):
2164 
    """
2165 
    Parameters:
2166 
     - displayName
2167 
    """
2168 
    self.send_deleteTag(displayName)
2169 
    return self.recv_deleteTag()
2170 
 
2171 
  def send_deleteTag(self, displayName):
2172 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2173 
    args = deleteTag_args()
2174 
    args.displayName = displayName
2175 
    args.write(self._oprot)
2176 
    self._oprot.writeMessageEnd()
2177 
    self._oprot.trans.flush()
2178 
 
2179 
  def recv_deleteTag(self, ):
2180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2181 
    if mtype == TMessageType.EXCEPTION:
2182 
      x = TApplicationException()
2183 
      x.read(self._iprot)
2184 
      self._iprot.readMessageEnd()
2185 
      raise x
2186 
    result = deleteTag_result()
2187 
    result.read(self._iprot)
2188 
    self._iprot.readMessageEnd()
2189 
    if result.success is not None:
2190 
      return result.success
2191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2192 
 
2193 
  def getAllTags(self, ):
2194 
    self.send_getAllTags()
2195 
    return self.recv_getAllTags()
2196 
 
2197 
  def send_getAllTags(self, ):
2198 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2199 
    args = getAllTags_args()
2200 
    args.write(self._oprot)
2201 
    self._oprot.writeMessageEnd()
2202 
    self._oprot.trans.flush()
2203 
 
2204 
  def recv_getAllTags(self, ):
2205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2206 
    if mtype == TMessageType.EXCEPTION:
2207 
      x = TApplicationException()
2208 
      x.read(self._iprot)
2209 
      self._iprot.readMessageEnd()
2210 
      raise x
2211 
    result = getAllTags_result()
2212 
    result.read(self._iprot)
2213 
    self._iprot.readMessageEnd()
2214 
    if result.success is not None:
2215 
      return result.success
2216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2217 
 
2218 
  def getAllEntitiesByTagName(self, displayName):
2219 
    """
2220 
    Parameters:
2221 
     - displayName
2222 
    """
2223 
    self.send_getAllEntitiesByTagName(displayName)
2224 
    return self.recv_getAllEntitiesByTagName()
2225 
 
2226 
  def send_getAllEntitiesByTagName(self, displayName):
2227 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2228 
    args = getAllEntitiesByTagName_args()
2229 
    args.displayName = displayName
2230 
    args.write(self._oprot)
2231 
    self._oprot.writeMessageEnd()
2232 
    self._oprot.trans.flush()
2233 
 
2234 
  def recv_getAllEntitiesByTagName(self, ):
2235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2236 
    if mtype == TMessageType.EXCEPTION:
2237 
      x = TApplicationException()
2238 
      x.read(self._iprot)
2239 
      self._iprot.readMessageEnd()
2240 
      raise x
2241 
    result = getAllEntitiesByTagName_result()
2242 
    result.read(self._iprot)
2243 
    self._iprot.readMessageEnd()
2244 
    if result.success is not None:
2245 
      return result.success
2246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2247 
 
6845 amit.gupta 2248 
  def getAllEntityTags(self, ):
2249 
    self.send_getAllEntityTags()
2250 
    return self.recv_getAllEntityTags()
2251 
 
2252 
  def send_getAllEntityTags(self, ):
2253 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2254 
    args = getAllEntityTags_args()
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_getAllEntityTags(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = getAllEntityTags_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
2269 
    if result.success is not None:
2270 
      return result.success
2271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2272 
 
8590 kshitij.so 2273 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2274 
    """
8579 kshitij.so 2275 
    Banner Related
2276 
 
6850 kshitij.so 2277 
    Parameters:
8590 kshitij.so 2278 
     - bannerCongregate
6850 kshitij.so 2279 
    """
8590 kshitij.so 2280 
    self.send_addBanner(bannerCongregate)
2281 
    self.recv_addBanner()
6850 kshitij.so 2282 
 
8590 kshitij.so 2283 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2284 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2285 
    args = addBanner_args()
8590 kshitij.so 2286 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
2291 
  def recv_addBanner(self, ):
2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
2298 
    result = addBanner_result()
2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
8590 kshitij.so 2301 
    return
6850 kshitij.so 2302 
 
8579 kshitij.so 2303 
  def updateBanner(self, banner):
2304 
    """
2305 
    Parameters:
2306 
     - banner
2307 
    """
2308 
    self.send_updateBanner(banner)
2309 
    return self.recv_updateBanner()
2310 
 
2311 
  def send_updateBanner(self, banner):
2312 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2313 
    args = updateBanner_args()
2314 
    args.banner = banner
2315 
    args.write(self._oprot)
2316 
    self._oprot.writeMessageEnd()
2317 
    self._oprot.trans.flush()
2318 
 
2319 
  def recv_updateBanner(self, ):
2320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2321 
    if mtype == TMessageType.EXCEPTION:
2322 
      x = TApplicationException()
2323 
      x.read(self._iprot)
2324 
      self._iprot.readMessageEnd()
2325 
      raise x
2326 
    result = updateBanner_result()
2327 
    result.read(self._iprot)
2328 
    self._iprot.readMessageEnd()
2329 
    if result.success is not None:
2330 
      return result.success
2331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2332 
 
6850 kshitij.so 2333 
  def getAllBanners(self, ):
2334 
    self.send_getAllBanners()
2335 
    return self.recv_getAllBanners()
2336 
 
2337 
  def send_getAllBanners(self, ):
2338 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2339 
    args = getAllBanners_args()
2340 
    args.write(self._oprot)
2341 
    self._oprot.writeMessageEnd()
2342 
    self._oprot.trans.flush()
2343 
 
2344 
  def recv_getAllBanners(self, ):
2345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2346 
    if mtype == TMessageType.EXCEPTION:
2347 
      x = TApplicationException()
2348 
      x.read(self._iprot)
2349 
      self._iprot.readMessageEnd()
2350 
      raise x
2351 
    result = getAllBanners_result()
2352 
    result.read(self._iprot)
2353 
    self._iprot.readMessageEnd()
2354 
    if result.success is not None:
2355 
      return result.success
2356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2357 
 
9155 kshitij.so 2358 
  def deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2359 
    """
2360 
    Parameters:
2361 
     - bannerName
9155 kshitij.so 2362 
     - bannerType
6850 kshitij.so 2363 
    """
9155 kshitij.so 2364 
    self.send_deleteBanner(bannerName, bannerType)
6850 kshitij.so 2365 
    return self.recv_deleteBanner()
2366 
 
9155 kshitij.so 2367 
  def send_deleteBanner(self, bannerName, bannerType):
6850 kshitij.so 2368 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2369 
    args = deleteBanner_args()
2370 
    args.bannerName = bannerName
9155 kshitij.so 2371 
    args.bannerType = bannerType
6850 kshitij.so 2372 
    args.write(self._oprot)
2373 
    self._oprot.writeMessageEnd()
2374 
    self._oprot.trans.flush()
2375 
 
2376 
  def recv_deleteBanner(self, ):
2377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2378 
    if mtype == TMessageType.EXCEPTION:
2379 
      x = TApplicationException()
2380 
      x.read(self._iprot)
2381 
      self._iprot.readMessageEnd()
2382 
      raise x
2383 
    result = deleteBanner_result()
2384 
    result.read(self._iprot)
2385 
    self._iprot.readMessageEnd()
2386 
    if result.success is not None:
2387 
      return result.success
2388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2389 
 
9155 kshitij.so 2390 
  def getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2391 
    """
2392 
    Parameters:
2393 
     - bannerName
9155 kshitij.so 2394 
     - bannerType
6850 kshitij.so 2395 
    """
9155 kshitij.so 2396 
    self.send_getBannerDetails(bannerName, bannerType)
6850 kshitij.so 2397 
    return self.recv_getBannerDetails()
2398 
 
9155 kshitij.so 2399 
  def send_getBannerDetails(self, bannerName, bannerType):
6850 kshitij.so 2400 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2401 
    args = getBannerDetails_args()
2402 
    args.bannerName = bannerName
9155 kshitij.so 2403 
    args.bannerType = bannerType
6850 kshitij.so 2404 
    args.write(self._oprot)
2405 
    self._oprot.writeMessageEnd()
2406 
    self._oprot.trans.flush()
2407 
 
2408 
  def recv_getBannerDetails(self, ):
2409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2410 
    if mtype == TMessageType.EXCEPTION:
2411 
      x = TApplicationException()
2412 
      x.read(self._iprot)
2413 
      self._iprot.readMessageEnd()
2414 
      raise x
2415 
    result = getBannerDetails_result()
2416 
    result.read(self._iprot)
2417 
    self._iprot.readMessageEnd()
2418 
    if result.success is not None:
2419 
      return result.success
2420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2421 
 
2422 
  def getActiveBanners(self, ):
2423 
    self.send_getActiveBanners()
2424 
    return self.recv_getActiveBanners()
2425 
 
2426 
  def send_getActiveBanners(self, ):
2427 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2428 
    args = getActiveBanners_args()
2429 
    args.write(self._oprot)
2430 
    self._oprot.writeMessageEnd()
2431 
    self._oprot.trans.flush()
2432 
 
2433 
  def recv_getActiveBanners(self, ):
2434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2435 
    if mtype == TMessageType.EXCEPTION:
2436 
      x = TApplicationException()
2437 
      x.read(self._iprot)
2438 
      self._iprot.readMessageEnd()
2439 
      raise x
2440 
    result = getActiveBanners_result()
2441 
    result.read(self._iprot)
2442 
    self._iprot.readMessageEnd()
2443 
    if result.success is not None:
2444 
      return result.success
2445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2446 
 
8579 kshitij.so 2447 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2448 
    """
2449 
    Parameters:
8579 kshitij.so 2450 
     - bannerMaps
6849 kshitij.so 2451 
    """
8579 kshitij.so 2452 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2453 
    return self.recv_addBannerMap()
2454 
 
8579 kshitij.so 2455 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2456 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2457 
    args = addBannerMap_args()
8579 kshitij.so 2458 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2459 
    args.write(self._oprot)
2460 
    self._oprot.writeMessageEnd()
2461 
    self._oprot.trans.flush()
2462 
 
2463 
  def recv_addBannerMap(self, ):
2464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2465 
    if mtype == TMessageType.EXCEPTION:
2466 
      x = TApplicationException()
2467 
      x.read(self._iprot)
2468 
      self._iprot.readMessageEnd()
2469 
      raise x
2470 
    result = addBannerMap_result()
2471 
    result.read(self._iprot)
2472 
    self._iprot.readMessageEnd()
2473 
    if result.success is not None:
2474 
      return result.success
2475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2476 
 
8579 kshitij.so 2477 
  def updateBannerMap(self, bannerMap):
2478 
    """
2479 
    Parameters:
2480 
     - bannerMap
2481 
    """
2482 
    self.send_updateBannerMap(bannerMap)
2483 
    return self.recv_updateBannerMap()
2484 
 
2485 
  def send_updateBannerMap(self, bannerMap):
2486 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2487 
    args = updateBannerMap_args()
2488 
    args.bannerMap = bannerMap
2489 
    args.write(self._oprot)
2490 
    self._oprot.writeMessageEnd()
2491 
    self._oprot.trans.flush()
2492 
 
2493 
  def recv_updateBannerMap(self, ):
2494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2495 
    if mtype == TMessageType.EXCEPTION:
2496 
      x = TApplicationException()
2497 
      x.read(self._iprot)
2498 
      self._iprot.readMessageEnd()
2499 
      raise x
2500 
    result = updateBannerMap_result()
2501 
    result.read(self._iprot)
2502 
    self._iprot.readMessageEnd()
2503 
    if result.success is not None:
2504 
      return result.success
2505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2506 
 
6849 kshitij.so 2507 
  def deleteBannerMap(self, bannerName):
2508 
    """
2509 
    Parameters:
2510 
     - bannerName
2511 
    """
2512 
    self.send_deleteBannerMap(bannerName)
2513 
    return self.recv_deleteBannerMap()
2514 
 
2515 
  def send_deleteBannerMap(self, bannerName):
2516 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2517 
    args = deleteBannerMap_args()
2518 
    args.bannerName = bannerName
2519 
    args.write(self._oprot)
2520 
    self._oprot.writeMessageEnd()
2521 
    self._oprot.trans.flush()
2522 
 
2523 
  def recv_deleteBannerMap(self, ):
2524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2525 
    if mtype == TMessageType.EXCEPTION:
2526 
      x = TApplicationException()
2527 
      x.read(self._iprot)
2528 
      self._iprot.readMessageEnd()
2529 
      raise x
2530 
    result = deleteBannerMap_result()
2531 
    result.read(self._iprot)
2532 
    self._iprot.readMessageEnd()
2533 
    if result.success is not None:
2534 
      return result.success
2535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2536 
 
9155 kshitij.so 2537 
  def getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2538 
    """
2539 
    Parameters:
2540 
     - bannerName
9155 kshitij.so 2541 
     - bannerType
6849 kshitij.so 2542 
    """
9155 kshitij.so 2543 
    self.send_getBannerMapDetails(bannerName, bannerType)
6849 kshitij.so 2544 
    return self.recv_getBannerMapDetails()
2545 
 
9155 kshitij.so 2546 
  def send_getBannerMapDetails(self, bannerName, bannerType):
6849 kshitij.so 2547 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2548 
    args = getBannerMapDetails_args()
2549 
    args.bannerName = bannerName
9155 kshitij.so 2550 
    args.bannerType = bannerType
6849 kshitij.so 2551 
    args.write(self._oprot)
2552 
    self._oprot.writeMessageEnd()
2553 
    self._oprot.trans.flush()
2554 
 
2555 
  def recv_getBannerMapDetails(self, ):
2556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2557 
    if mtype == TMessageType.EXCEPTION:
2558 
      x = TApplicationException()
2559 
      x.read(self._iprot)
2560 
      self._iprot.readMessageEnd()
2561 
      raise x
2562 
    result = getBannerMapDetails_result()
2563 
    result.read(self._iprot)
2564 
    self._iprot.readMessageEnd()
2565 
    if result.success is not None:
2566 
      return result.success
2567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2568 
 
8579 kshitij.so 2569 
  def addBannerUri(self, bannerUriMappings):
2570 
    """
2571 
    Parameters:
2572 
     - bannerUriMappings
2573 
    """
2574 
    self.send_addBannerUri(bannerUriMappings)
2575 
    self.recv_addBannerUri()
2576 
 
2577 
  def send_addBannerUri(self, bannerUriMappings):
2578 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2579 
    args = addBannerUri_args()
2580 
    args.bannerUriMappings = bannerUriMappings
2581 
    args.write(self._oprot)
2582 
    self._oprot.writeMessageEnd()
2583 
    self._oprot.trans.flush()
2584 
 
2585 
  def recv_addBannerUri(self, ):
2586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2587 
    if mtype == TMessageType.EXCEPTION:
2588 
      x = TApplicationException()
2589 
      x.read(self._iprot)
2590 
      self._iprot.readMessageEnd()
2591 
      raise x
2592 
    result = addBannerUri_result()
2593 
    result.read(self._iprot)
2594 
    self._iprot.readMessageEnd()
2595 
    return
2596 
 
9155 kshitij.so 2597 
  def getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2598 
    """
2599 
    Parameters:
2600 
     - bannerName
9155 kshitij.so 2601 
     - bannerType
8579 kshitij.so 2602 
    """
9155 kshitij.so 2603 
    self.send_getUriMapping(bannerName, bannerType)
8579 kshitij.so 2604 
    return self.recv_getUriMapping()
2605 
 
9155 kshitij.so 2606 
  def send_getUriMapping(self, bannerName, bannerType):
8579 kshitij.so 2607 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2608 
    args = getUriMapping_args()
2609 
    args.bannerName = bannerName
9155 kshitij.so 2610 
    args.bannerType = bannerType
8579 kshitij.so 2611 
    args.write(self._oprot)
2612 
    self._oprot.writeMessageEnd()
2613 
    self._oprot.trans.flush()
2614 
 
2615 
  def recv_getUriMapping(self, ):
2616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2617 
    if mtype == TMessageType.EXCEPTION:
2618 
      x = TApplicationException()
2619 
      x.read(self._iprot)
2620 
      self._iprot.readMessageEnd()
2621 
      raise x
2622 
    result = getUriMapping_result()
2623 
    result.read(self._iprot)
2624 
    self._iprot.readMessageEnd()
2625 
    if result.success is not None:
2626 
      return result.success
2627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2628 
 
2629 
  def addCampaign(self, campaign):
2630 
    """
2631 
    Parameters:
2632 
     - campaign
2633 
    """
2634 
    self.send_addCampaign(campaign)
2635 
    self.recv_addCampaign()
2636 
 
2637 
  def send_addCampaign(self, campaign):
2638 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2639 
    args = addCampaign_args()
2640 
    args.campaign = campaign
2641 
    args.write(self._oprot)
2642 
    self._oprot.writeMessageEnd()
2643 
    self._oprot.trans.flush()
2644 
 
2645 
  def recv_addCampaign(self, ):
2646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2647 
    if mtype == TMessageType.EXCEPTION:
2648 
      x = TApplicationException()
2649 
      x.read(self._iprot)
2650 
      self._iprot.readMessageEnd()
2651 
      raise x
2652 
    result = addCampaign_result()
2653 
    result.read(self._iprot)
2654 
    self._iprot.readMessageEnd()
2655 
    return
2656 
 
2657 
  def getCampaigns(self, campaignName):
2658 
    """
2659 
    Parameters:
2660 
     - campaignName
2661 
    """
2662 
    self.send_getCampaigns(campaignName)
2663 
    return self.recv_getCampaigns()
2664 
 
2665 
  def send_getCampaigns(self, campaignName):
2666 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2667 
    args = getCampaigns_args()
2668 
    args.campaignName = campaignName
2669 
    args.write(self._oprot)
2670 
    self._oprot.writeMessageEnd()
2671 
    self._oprot.trans.flush()
2672 
 
2673 
  def recv_getCampaigns(self, ):
2674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2675 
    if mtype == TMessageType.EXCEPTION:
2676 
      x = TApplicationException()
2677 
      x.read(self._iprot)
2678 
      self._iprot.readMessageEnd()
2679 
      raise x
2680 
    result = getCampaigns_result()
2681 
    result.read(self._iprot)
2682 
    self._iprot.readMessageEnd()
2683 
    if result.success is not None:
2684 
      return result.success
2685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2686 
 
2687 
  def deleteCampaign(self, campaignId):
2688 
    """
2689 
    Parameters:
2690 
     - campaignId
2691 
    """
2692 
    self.send_deleteCampaign(campaignId)
2693 
    self.recv_deleteCampaign()
2694 
 
2695 
  def send_deleteCampaign(self, campaignId):
2696 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2697 
    args = deleteCampaign_args()
2698 
    args.campaignId = campaignId
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
2703 
  def recv_deleteCampaign(self, ):
2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
2710 
    result = deleteCampaign_result()
2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
2713 
    return
2714 
 
2715 
  def getAllCampaigns(self, ):
2716 
    self.send_getAllCampaigns()
2717 
    return self.recv_getAllCampaigns()
2718 
 
2719 
  def send_getAllCampaigns(self, ):
2720 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2721 
    args = getAllCampaigns_args()
2722 
    args.write(self._oprot)
2723 
    self._oprot.writeMessageEnd()
2724 
    self._oprot.trans.flush()
2725 
 
2726 
  def recv_getAllCampaigns(self, ):
2727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2728 
    if mtype == TMessageType.EXCEPTION:
2729 
      x = TApplicationException()
2730 
      x.read(self._iprot)
2731 
      self._iprot.readMessageEnd()
2732 
      raise x
2733 
    result = getAllCampaigns_result()
2734 
    result.read(self._iprot)
2735 
    self._iprot.readMessageEnd()
2736 
    if result.success is not None:
2737 
      return result.success
2738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2739 
 
9155 kshitij.so 2740 
  def getActiveBannersForMobileSite(self, ):
2741 
    self.send_getActiveBannersForMobileSite()
2742 
    return self.recv_getActiveBannersForMobileSite()
2743 
 
2744 
  def send_getActiveBannersForMobileSite(self, ):
2745 
    self._oprot.writeMessageBegin('getActiveBannersForMobileSite', TMessageType.CALL, self._seqid)
2746 
    args = getActiveBannersForMobileSite_args()
2747 
    args.write(self._oprot)
2748 
    self._oprot.writeMessageEnd()
2749 
    self._oprot.trans.flush()
2750 
 
2751 
  def recv_getActiveBannersForMobileSite(self, ):
2752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2753 
    if mtype == TMessageType.EXCEPTION:
2754 
      x = TApplicationException()
2755 
      x.read(self._iprot)
2756 
      self._iprot.readMessageEnd()
2757 
      raise x
2758 
    result = getActiveBannersForMobileSite_result()
2759 
    result.read(self._iprot)
2760 
    self._iprot.readMessageEnd()
2761 
    if result.success is not None:
2762 
      return result.success
2763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBannersForMobileSite failed: unknown result");
2764 
 
5944 mandeep.dh 2765 
  def deleteSimilarItem(self, itemId, catalogItemId):
2766 
    """
2767 
    Delete similar item.
2768 
 
2769 
    Parameters:
2770 
     - itemId
2771 
     - catalogItemId
2772 
    """
2773 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2774 
    return self.recv_deleteSimilarItem()
2775 
 
2776 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2777 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2778 
    args = deleteSimilarItem_args()
2779 
    args.itemId = itemId
2780 
    args.catalogItemId = catalogItemId
2781 
    args.write(self._oprot)
2782 
    self._oprot.writeMessageEnd()
2783 
    self._oprot.trans.flush()
2784 
 
2785 
  def recv_deleteSimilarItem(self, ):
2786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2787 
    if mtype == TMessageType.EXCEPTION:
2788 
      x = TApplicationException()
2789 
      x.read(self._iprot)
2790 
      self._iprot.readMessageEnd()
2791 
      raise x
2792 
    result = deleteSimilarItem_result()
2793 
    result.read(self._iprot)
2794 
    self._iprot.readMessageEnd()
2795 
    if result.success is not None:
2796 
      return result.success
2797 
    if result.cex is not None:
2798 
      raise result.cex
2799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2800 
 
2801 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2802 
    """
2803 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2804 
    If yes, returns the itemId else returns 0
2805 
 
2806 
    Parameters:
2807 
     - brand
2808 
     - modelNumber
2809 
     - modelName
2810 
     - color
2811 
    """
2812 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2813 
    return self.recv_checkSimilarItem()
2814 
 
2815 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2816 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2817 
    args = checkSimilarItem_args()
2818 
    args.brand = brand
2819 
    args.modelNumber = modelNumber
2820 
    args.modelName = modelName
2821 
    args.color = color
2822 
    args.write(self._oprot)
2823 
    self._oprot.writeMessageEnd()
2824 
    self._oprot.trans.flush()
2825 
 
2826 
  def recv_checkSimilarItem(self, ):
2827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2828 
    if mtype == TMessageType.EXCEPTION:
2829 
      x = TApplicationException()
2830 
      x.read(self._iprot)
2831 
      self._iprot.readMessageEnd()
2832 
      raise x
2833 
    result = checkSimilarItem_result()
2834 
    result.read(self._iprot)
2835 
    self._iprot.readMessageEnd()
2836 
    if result.success is not None:
2837 
      return result.success
2838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2839 
 
2840 
  def validateRiskyStatus(self, itemId):
2841 
    """
2842 
    Check wether item is risky and change status if inventory is not available for risky items
2843 
 
2844 
    Parameters:
2845 
     - itemId
2846 
    """
2847 
    self.send_validateRiskyStatus(itemId)
2848 
    self.recv_validateRiskyStatus()
2849 
 
2850 
  def send_validateRiskyStatus(self, itemId):
2851 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2852 
    args = validateRiskyStatus_args()
2853 
    args.itemId = itemId
2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2858 
  def recv_validateRiskyStatus(self, ):
2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2865 
    result = validateRiskyStatus_result()
2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
2868 
    return
2869 
 
2870 
  def changeItemRiskyFlag(self, itemId, risky):
2871 
    """
2872 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2873 
 
2874 
    Parameters:
2875 
     - itemId
2876 
     - risky
2877 
    """
2878 
    self.send_changeItemRiskyFlag(itemId, risky)
2879 
    self.recv_changeItemRiskyFlag()
2880 
 
2881 
  def send_changeItemRiskyFlag(self, itemId, risky):
2882 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2883 
    args = changeItemRiskyFlag_args()
2884 
    args.itemId = itemId
2885 
    args.risky = risky
2886 
    args.write(self._oprot)
2887 
    self._oprot.writeMessageEnd()
2888 
    self._oprot.trans.flush()
2889 
 
2890 
  def recv_changeItemRiskyFlag(self, ):
2891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2892 
    if mtype == TMessageType.EXCEPTION:
2893 
      x = TApplicationException()
2894 
      x.read(self._iprot)
2895 
      self._iprot.readMessageEnd()
2896 
      raise x
2897 
    result = changeItemRiskyFlag_result()
2898 
    result.read(self._iprot)
2899 
    self._iprot.readMessageEnd()
2900 
    return
2901 
 
2902 
  def getItemsByRiskyFlag(self, ):
2903 
    """
2904 
    Returns list of items marked as risky.
2905 
    """
2906 
    self.send_getItemsByRiskyFlag()
2907 
    return self.recv_getItemsByRiskyFlag()
2908 
 
2909 
  def send_getItemsByRiskyFlag(self, ):
2910 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2911 
    args = getItemsByRiskyFlag_args()
2912 
    args.write(self._oprot)
2913 
    self._oprot.writeMessageEnd()
2914 
    self._oprot.trans.flush()
2915 
 
2916 
  def recv_getItemsByRiskyFlag(self, ):
2917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2918 
    if mtype == TMessageType.EXCEPTION:
2919 
      x = TApplicationException()
2920 
      x.read(self._iprot)
2921 
      self._iprot.readMessageEnd()
2922 
      raise x
2923 
    result = getItemsByRiskyFlag_result()
2924 
    result.read(self._iprot)
2925 
    self._iprot.readMessageEnd()
2926 
    if result.success is not None:
2927 
      return result.success
2928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2929 
 
2930 
  def getItemsForMasterSheet(self, category, brand):
2931 
    """
2932 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2933 
 
2934 
    Parameters:
2935 
     - category
2936 
     - brand
2937 
    """
2938 
    self.send_getItemsForMasterSheet(category, brand)
2939 
    return self.recv_getItemsForMasterSheet()
2940 
 
2941 
  def send_getItemsForMasterSheet(self, category, brand):
2942 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2943 
    args = getItemsForMasterSheet_args()
2944 
    args.category = category
2945 
    args.brand = brand
2946 
    args.write(self._oprot)
2947 
    self._oprot.writeMessageEnd()
2948 
    self._oprot.trans.flush()
2949 
 
2950 
  def recv_getItemsForMasterSheet(self, ):
2951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2952 
    if mtype == TMessageType.EXCEPTION:
2953 
      x = TApplicationException()
2954 
      x.read(self._iprot)
2955 
      self._iprot.readMessageEnd()
2956 
      raise x
2957 
    result = getItemsForMasterSheet_result()
2958 
    result.read(self._iprot)
2959 
    self._iprot.readMessageEnd()
2960 
    if result.success is not None:
2961 
      return result.success
2962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2963 
 
2964 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2965 
    """
2966 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2967 
 
2968 
    Parameters:
2969 
     - beginIndex
2970 
     - totalItems
2971 
     - itemId
2972 
    """
2973 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2974 
    return self.recv_getSimilarItemsCatalogIds()
2975 
 
2976 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2977 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2978 
    args = getSimilarItemsCatalogIds_args()
2979 
    args.beginIndex = beginIndex
2980 
    args.totalItems = totalItems
2981 
    args.itemId = itemId
2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
2986 
  def recv_getSimilarItemsCatalogIds(self, ):
2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
2993 
    result = getSimilarItemsCatalogIds_result()
2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
2996 
    if result.success is not None:
2997 
      return result.success
2998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2999 
 
3000 
  def addProductNotification(self, itemId, email):
3001 
    """
3002 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
3003 
 
3004 
    Parameters:
3005 
     - itemId
3006 
     - email
3007 
    """
3008 
    self.send_addProductNotification(itemId, email)
3009 
    return self.recv_addProductNotification()
3010 
 
3011 
  def send_addProductNotification(self, itemId, email):
3012 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
3013 
    args = addProductNotification_args()
3014 
    args.itemId = itemId
3015 
    args.email = email
3016 
    args.write(self._oprot)
3017 
    self._oprot.writeMessageEnd()
3018 
    self._oprot.trans.flush()
3019 
 
3020 
  def recv_addProductNotification(self, ):
3021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3022 
    if mtype == TMessageType.EXCEPTION:
3023 
      x = TApplicationException()
3024 
      x.read(self._iprot)
3025 
      self._iprot.readMessageEnd()
3026 
      raise x
3027 
    result = addProductNotification_result()
3028 
    result.read(self._iprot)
3029 
    self._iprot.readMessageEnd()
3030 
    if result.success is not None:
3031 
      return result.success
3032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
3033 
 
3034 
  def sendProductNotifications(self, ):
3035 
    """
3036 
    Send the product notifications to the users for items which has stock.
3037 
    """
3038 
    self.send_sendProductNotifications()
3039 
    return self.recv_sendProductNotifications()
3040 
 
3041 
  def send_sendProductNotifications(self, ):
3042 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
3043 
    args = sendProductNotifications_args()
3044 
    args.write(self._oprot)
3045 
    self._oprot.writeMessageEnd()
3046 
    self._oprot.trans.flush()
3047 
 
3048 
  def recv_sendProductNotifications(self, ):
3049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3050 
    if mtype == TMessageType.EXCEPTION:
3051 
      x = TApplicationException()
3052 
      x.read(self._iprot)
3053 
      self._iprot.readMessageEnd()
3054 
      raise x
3055 
    result = sendProductNotifications_result()
3056 
    result.read(self._iprot)
3057 
    self._iprot.readMessageEnd()
3058 
    if result.success is not None:
3059 
      return result.success
3060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
3061 
 
3062 
  def getAllBrandsByCategory(self, categoryId):
3063 
    """
3064 
    Returns list of brand names for a given category Id
3065 
 
3066 
    Parameters:
3067 
     - categoryId
3068 
    """
3069 
    self.send_getAllBrandsByCategory(categoryId)
3070 
    return self.recv_getAllBrandsByCategory()
3071 
 
3072 
  def send_getAllBrandsByCategory(self, categoryId):
3073 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
3074 
    args = getAllBrandsByCategory_args()
3075 
    args.categoryId = categoryId
3076 
    args.write(self._oprot)
3077 
    self._oprot.writeMessageEnd()
3078 
    self._oprot.trans.flush()
3079 
 
3080 
  def recv_getAllBrandsByCategory(self, ):
3081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3082 
    if mtype == TMessageType.EXCEPTION:
3083 
      x = TApplicationException()
3084 
      x.read(self._iprot)
3085 
      self._iprot.readMessageEnd()
3086 
      raise x
3087 
    result = getAllBrandsByCategory_result()
3088 
    result.read(self._iprot)
3089 
    self._iprot.readMessageEnd()
3090 
    if result.success is not None:
3091 
      return result.success
3092 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3093 
 
3094 
  def getAllBrands(self, ):
3095 
    """
3096 
    Returns list of brand names
3097 
    """
3098 
    self.send_getAllBrands()
3099 
    return self.recv_getAllBrands()
3100 
 
3101 
  def send_getAllBrands(self, ):
3102 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3103 
    args = getAllBrands_args()
3104 
    args.write(self._oprot)
3105 
    self._oprot.writeMessageEnd()
3106 
    self._oprot.trans.flush()
3107 
 
3108 
  def recv_getAllBrands(self, ):
3109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3110 
    if mtype == TMessageType.EXCEPTION:
3111 
      x = TApplicationException()
3112 
      x.read(self._iprot)
3113 
      self._iprot.readMessageEnd()
3114 
      raise x
3115 
    result = getAllBrands_result()
3116 
    result.read(self._iprot)
3117 
    self._iprot.readMessageEnd()
3118 
    if result.success is not None:
3119 
      return result.success
3120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3121 
 
3122 
  def getAllSources(self, ):
3123 
    """
3124 
    Return list of all sources
3125 
    """
3126 
    self.send_getAllSources()
3127 
    return self.recv_getAllSources()
3128 
 
3129 
  def send_getAllSources(self, ):
3130 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3131 
    args = getAllSources_args()
3132 
    args.write(self._oprot)
3133 
    self._oprot.writeMessageEnd()
3134 
    self._oprot.trans.flush()
3135 
 
3136 
  def recv_getAllSources(self, ):
3137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3138 
    if mtype == TMessageType.EXCEPTION:
3139 
      x = TApplicationException()
3140 
      x.read(self._iprot)
3141 
      self._iprot.readMessageEnd()
3142 
      raise x
3143 
    result = getAllSources_result()
3144 
    result.read(self._iprot)
3145 
    self._iprot.readMessageEnd()
3146 
    if result.success is not None:
3147 
      return result.success
3148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3149 
 
3150 
  def getItemPricingBySource(self, itemId, sourceId):
3151 
    """
3152 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3153 
 
3154 
    Parameters:
3155 
     - itemId
3156 
     - sourceId
3157 
    """
3158 
    self.send_getItemPricingBySource(itemId, sourceId)
3159 
    return self.recv_getItemPricingBySource()
3160 
 
3161 
  def send_getItemPricingBySource(self, itemId, sourceId):
3162 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3163 
    args = getItemPricingBySource_args()
3164 
    args.itemId = itemId
3165 
    args.sourceId = sourceId
3166 
    args.write(self._oprot)
3167 
    self._oprot.writeMessageEnd()
3168 
    self._oprot.trans.flush()
3169 
 
3170 
  def recv_getItemPricingBySource(self, ):
3171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3172 
    if mtype == TMessageType.EXCEPTION:
3173 
      x = TApplicationException()
3174 
      x.read(self._iprot)
3175 
      self._iprot.readMessageEnd()
3176 
      raise x
3177 
    result = getItemPricingBySource_result()
3178 
    result.read(self._iprot)
3179 
    self._iprot.readMessageEnd()
3180 
    if result.success is not None:
3181 
      return result.success
3182 
    if result.cex is not None:
3183 
      raise result.cex
3184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3185 
 
3186 
  def addSourceItemPricing(self, sourceItemPricing):
3187 
    """
3188 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3189 
    If item is not found or source is not found, it will throw exception.
3190 
 
3191 
    Parameters:
3192 
     - sourceItemPricing
3193 
    """
3194 
    self.send_addSourceItemPricing(sourceItemPricing)
3195 
    self.recv_addSourceItemPricing()
3196 
 
3197 
  def send_addSourceItemPricing(self, sourceItemPricing):
3198 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3199 
    args = addSourceItemPricing_args()
3200 
    args.sourceItemPricing = sourceItemPricing
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_addSourceItemPricing(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = addSourceItemPricing_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.cex is not None:
3216 
      raise result.cex
3217 
    return
3218 
 
3219 
  def getAllSourcePricing(self, itemId):
3220 
    """
3221 
    Returns the list of source pricing information of an item.
3222 
    Raises an exception if item not found corresponding to itemId
3223 
 
3224 
    Parameters:
3225 
     - itemId
3226 
    """
3227 
    self.send_getAllSourcePricing(itemId)
3228 
    return self.recv_getAllSourcePricing()
3229 
 
3230 
  def send_getAllSourcePricing(self, itemId):
3231 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3232 
    args = getAllSourcePricing_args()
3233 
    args.itemId = itemId
3234 
    args.write(self._oprot)
3235 
    self._oprot.writeMessageEnd()
3236 
    self._oprot.trans.flush()
3237 
 
3238 
  def recv_getAllSourcePricing(self, ):
3239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3240 
    if mtype == TMessageType.EXCEPTION:
3241 
      x = TApplicationException()
3242 
      x.read(self._iprot)
3243 
      self._iprot.readMessageEnd()
3244 
      raise x
3245 
    result = getAllSourcePricing_result()
3246 
    result.read(self._iprot)
3247 
    self._iprot.readMessageEnd()
3248 
    if result.success is not None:
3249 
      return result.success
3250 
    if result.cex is not None:
3251 
      raise result.cex
3252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3253 
 
3254 
  def getItemForSource(self, item_id, sourceId):
3255 
    """
3256 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3257 
 
3258 
    Parameters:
3259 
     - item_id
3260 
     - sourceId
3261 
    """
3262 
    self.send_getItemForSource(item_id, sourceId)
3263 
    return self.recv_getItemForSource()
3264 
 
3265 
  def send_getItemForSource(self, item_id, sourceId):
3266 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3267 
    args = getItemForSource_args()
3268 
    args.item_id = item_id
3269 
    args.sourceId = sourceId
3270 
    args.write(self._oprot)
3271 
    self._oprot.writeMessageEnd()
3272 
    self._oprot.trans.flush()
3273 
 
3274 
  def recv_getItemForSource(self, ):
3275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3276 
    if mtype == TMessageType.EXCEPTION:
3277 
      x = TApplicationException()
3278 
      x.read(self._iprot)
3279 
      self._iprot.readMessageEnd()
3280 
      raise x
3281 
    result = getItemForSource_result()
3282 
    result.read(self._iprot)
3283 
    self._iprot.readMessageEnd()
3284 
    if result.success is not None:
3285 
      return result.success
3286 
    if result.cex is not None:
3287 
      raise result.cex
3288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3289 
 
3290 
  def searchItemsInRange(self, searchTerms, offset, limit):
3291 
    """
3292 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3293 
 
3294 
    Parameters:
3295 
     - searchTerms
3296 
     - offset
3297 
     - limit
3298 
    """
3299 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3300 
    return self.recv_searchItemsInRange()
3301 
 
3302 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3303 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3304 
    args = searchItemsInRange_args()
3305 
    args.searchTerms = searchTerms
3306 
    args.offset = offset
3307 
    args.limit = limit
3308 
    args.write(self._oprot)
3309 
    self._oprot.writeMessageEnd()
3310 
    self._oprot.trans.flush()
3311 
 
3312 
  def recv_searchItemsInRange(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 = searchItemsInRange_result()
3320 
    result.read(self._iprot)
3321 
    self._iprot.readMessageEnd()
3322 
    if result.success is not None:
3323 
      return result.success
3324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3325 
 
3326 
  def getSearchResultCount(self, searchTerms):
3327 
    """
3328 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3329 
 
3330 
    Parameters:
3331 
     - searchTerms
3332 
    """
3333 
    self.send_getSearchResultCount(searchTerms)
3334 
    return self.recv_getSearchResultCount()
3335 
 
3336 
  def send_getSearchResultCount(self, searchTerms):
3337 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3338 
    args = getSearchResultCount_args()
3339 
    args.searchTerms = searchTerms
3340 
    args.write(self._oprot)
3341 
    self._oprot.writeMessageEnd()
3342 
    self._oprot.trans.flush()
3343 
 
3344 
  def recv_getSearchResultCount(self, ):
3345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3346 
    if mtype == TMessageType.EXCEPTION:
3347 
      x = TApplicationException()
3348 
      x.read(self._iprot)
3349 
      self._iprot.readMessageEnd()
3350 
      raise x
3351 
    result = getSearchResultCount_result()
3352 
    result.read(self._iprot)
3353 
    self._iprot.readMessageEnd()
3354 
    if result.success is not None:
3355 
      return result.success
3356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3357 
 
3358 
  def getProductNotifications(self, startDateTime):
3359 
    """
3360 
    Returns a list of product notifications added after a supplied datetime
3361 
 
3362 
    Parameters:
3363 
     - startDateTime
3364 
    """
3365 
    self.send_getProductNotifications(startDateTime)
3366 
    return self.recv_getProductNotifications()
3367 
 
3368 
  def send_getProductNotifications(self, startDateTime):
3369 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3370 
    args = getProductNotifications_args()
3371 
    args.startDateTime = startDateTime
3372 
    args.write(self._oprot)
3373 
    self._oprot.writeMessageEnd()
3374 
    self._oprot.trans.flush()
3375 
 
3376 
  def recv_getProductNotifications(self, ):
3377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3378 
    if mtype == TMessageType.EXCEPTION:
3379 
      x = TApplicationException()
3380 
      x.read(self._iprot)
3381 
      self._iprot.readMessageEnd()
3382 
      raise x
3383 
    result = getProductNotifications_result()
3384 
    result.read(self._iprot)
3385 
    self._iprot.readMessageEnd()
3386 
    if result.success is not None:
3387 
      return result.success
3388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3389 
 
7897 amar.kumar 3390 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3391 
    """
3392 
    Returns a list of count of requests for product notification against each item
3393 
 
3394 
    Parameters:
3395 
     - startDateTime
7897 amar.kumar 3396 
     - categoryId
5944 mandeep.dh 3397 
    """
7897 amar.kumar 3398 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3399 
    return self.recv_getProductNotificationRequestCount()
3400 
 
7897 amar.kumar 3401 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3402 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3403 
    args = getProductNotificationRequestCount_args()
3404 
    args.startDateTime = startDateTime
7897 amar.kumar 3405 
    args.categoryId = categoryId
5944 mandeep.dh 3406 
    args.write(self._oprot)
3407 
    self._oprot.writeMessageEnd()
3408 
    self._oprot.trans.flush()
3409 
 
3410 
  def recv_getProductNotificationRequestCount(self, ):
3411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3412 
    if mtype == TMessageType.EXCEPTION:
3413 
      x = TApplicationException()
3414 
      x.read(self._iprot)
3415 
      self._iprot.readMessageEnd()
3416 
      raise x
3417 
    result = getProductNotificationRequestCount_result()
3418 
    result.read(self._iprot)
3419 
    self._iprot.readMessageEnd()
3420 
    if result.success is not None:
3421 
      return result.success
3422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3423 
 
3424 
  def addAuthorizationLog(self, itemId, username, reason):
3425 
    """
3426 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3427 
 
3428 
    Parameters:
3429 
     - itemId
3430 
     - username
3431 
     - reason
3432 
    """
3433 
    self.send_addAuthorizationLog(itemId, username, reason)
3434 
    return self.recv_addAuthorizationLog()
3435 
 
3436 
  def send_addAuthorizationLog(self, itemId, username, reason):
3437 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3438 
    args = addAuthorizationLog_args()
3439 
    args.itemId = itemId
3440 
    args.username = username
3441 
    args.reason = reason
3442 
    args.write(self._oprot)
3443 
    self._oprot.writeMessageEnd()
3444 
    self._oprot.trans.flush()
3445 
 
3446 
  def recv_addAuthorizationLog(self, ):
3447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3448 
    if mtype == TMessageType.EXCEPTION:
3449 
      x = TApplicationException()
3450 
      x.read(self._iprot)
3451 
      self._iprot.readMessageEnd()
3452 
      raise x
3453 
    result = addAuthorizationLog_result()
3454 
    result.read(self._iprot)
3455 
    self._iprot.readMessageEnd()
3456 
    if result.success is not None:
3457 
      return result.success
3458 
    if result.cex is not None:
3459 
      raise result.cex
3460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3461 
 
3462 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3463 
    """
3464 
    Parameters:
3465 
     - catalog_item_id
3466 
     - voucherType
3467 
     - voucherAmount
3468 
    """
3469 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3470 
    return self.recv_addupdateVoucherForItem()
3471 
 
3472 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3473 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3474 
    args = addupdateVoucherForItem_args()
3475 
    args.catalog_item_id = catalog_item_id
3476 
    args.voucherType = voucherType
3477 
    args.voucherAmount = voucherAmount
3478 
    args.write(self._oprot)
3479 
    self._oprot.writeMessageEnd()
3480 
    self._oprot.trans.flush()
3481 
 
3482 
  def recv_addupdateVoucherForItem(self, ):
3483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3484 
    if mtype == TMessageType.EXCEPTION:
3485 
      x = TApplicationException()
3486 
      x.read(self._iprot)
3487 
      self._iprot.readMessageEnd()
3488 
      raise x
3489 
    result = addupdateVoucherForItem_result()
3490 
    result.read(self._iprot)
3491 
    self._iprot.readMessageEnd()
3492 
    if result.success is not None:
3493 
      return result.success
3494 
    if result.cex is not None:
3495 
      raise result.cex
3496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3497 
 
3498 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3499 
    """
3500 
    Parameters:
3501 
     - catalog_item_id
3502 
     - voucherType
3503 
    """
3504 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3505 
    return self.recv_deleteVoucherForItem()
3506 
 
3507 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3508 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3509 
    args = deleteVoucherForItem_args()
3510 
    args.catalog_item_id = catalog_item_id
3511 
    args.voucherType = voucherType
3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_deleteVoucherForItem(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = deleteVoucherForItem_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3526 
    if result.success is not None:
3527 
      return result.success
3528 
    if result.cex is not None:
3529 
      raise result.cex
3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3531 
 
3532 
  def getVoucherAmount(self, itemId, voucherType):
3533 
    """
3534 
    Parameters:
3535 
     - itemId
3536 
     - voucherType
3537 
    """
3538 
    self.send_getVoucherAmount(itemId, voucherType)
3539 
    return self.recv_getVoucherAmount()
3540 
 
3541 
  def send_getVoucherAmount(self, itemId, voucherType):
3542 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3543 
    args = getVoucherAmount_args()
3544 
    args.itemId = itemId
3545 
    args.voucherType = voucherType
3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_getVoucherAmount(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = getVoucherAmount_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3560 
    if result.success is not None:
3561 
      return result.success
3562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3563 
 
3564 
  def getAllItemVouchers(self, itemId):
3565 
    """
3566 
    Parameters:
3567 
     - itemId
3568 
    """
3569 
    self.send_getAllItemVouchers(itemId)
3570 
    return self.recv_getAllItemVouchers()
3571 
 
3572 
  def send_getAllItemVouchers(self, itemId):
3573 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3574 
    args = getAllItemVouchers_args()
3575 
    args.itemId = itemId
3576 
    args.write(self._oprot)
3577 
    self._oprot.writeMessageEnd()
3578 
    self._oprot.trans.flush()
3579 
 
3580 
  def recv_getAllItemVouchers(self, ):
3581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3582 
    if mtype == TMessageType.EXCEPTION:
3583 
      x = TApplicationException()
3584 
      x.read(self._iprot)
3585 
      self._iprot.readMessageEnd()
3586 
      raise x
3587 
    result = getAllItemVouchers_result()
3588 
    result.read(self._iprot)
3589 
    self._iprot.readMessageEnd()
3590 
    if result.success is not None:
3591 
      return result.success
3592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3593 
 
3594 
  def isValidCatalogItemId(self, catalog_item_id):
3595 
    """
3596 
    Parameters:
3597 
     - catalog_item_id
3598 
    """
3599 
    self.send_isValidCatalogItemId(catalog_item_id)
3600 
    return self.recv_isValidCatalogItemId()
3601 
 
3602 
  def send_isValidCatalogItemId(self, catalog_item_id):
3603 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3604 
    args = isValidCatalogItemId_args()
3605 
    args.catalog_item_id = catalog_item_id
3606 
    args.write(self._oprot)
3607 
    self._oprot.writeMessageEnd()
3608 
    self._oprot.trans.flush()
3609 
 
3610 
  def recv_isValidCatalogItemId(self, ):
3611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3612 
    if mtype == TMessageType.EXCEPTION:
3613 
      x = TApplicationException()
3614 
      x.read(self._iprot)
3615 
      self._iprot.readMessageEnd()
3616 
      raise x
3617 
    result = isValidCatalogItemId_result()
3618 
    result.read(self._iprot)
3619 
    self._iprot.readMessageEnd()
3620 
    if result.success is not None:
3621 
      return result.success
3622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3623 
 
7330 amit.gupta 3624 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3625 
    """
3626 
    Parameters:
3627 
     - itemId
7330 amit.gupta 3628 
     - stateId
6039 amit.gupta 3629 
     - price
3630 
    """
7330 amit.gupta 3631 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3632 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3633 
 
7330 amit.gupta 3634 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3635 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3636 
    args = getVatPercentageForItem_args()
3637 
    args.itemId = itemId
7330 amit.gupta 3638 
    args.stateId = stateId
6039 amit.gupta 3639 
    args.price = price
3640 
    args.write(self._oprot)
3641 
    self._oprot.writeMessageEnd()
3642 
    self._oprot.trans.flush()
3643 
 
3644 
  def recv_getVatPercentageForItem(self, ):
3645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3646 
    if mtype == TMessageType.EXCEPTION:
3647 
      x = TApplicationException()
3648 
      x.read(self._iprot)
3649 
      self._iprot.readMessageEnd()
3650 
      raise x
3651 
    result = getVatPercentageForItem_result()
3652 
    result.read(self._iprot)
3653 
    self._iprot.readMessageEnd()
3654 
    if result.success is not None:
3655 
      return result.success
7340 amit.gupta 3656 
    if result.cex is not None:
3657 
      raise result.cex
6039 amit.gupta 3658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3659 
 
3660 
  def getVatAmountForItem(self, itemId, price):
3661 
    """
3662 
    Parameters:
3663 
     - itemId
3664 
     - price
3665 
    """
3666 
    self.send_getVatAmountForItem(itemId, price)
3667 
    return self.recv_getVatAmountForItem()
3668 
 
3669 
  def send_getVatAmountForItem(self, itemId, price):
3670 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3671 
    args = getVatAmountForItem_args()
3672 
    args.itemId = itemId
3673 
    args.price = price
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_getVatAmountForItem(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = getVatAmountForItem_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
3688 
    if result.success is not None:
3689 
      return result.success
3690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3691 
 
6531 vikram.rag 3692 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3693 
    """
3694 
    Parameters:
3695 
     - offset
3696 
     - limit
3697 
    """
3698 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3699 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3700 
 
6531 vikram.rag 3701 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3702 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3703 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3704 
    args.offset = offset
3705 
    args.limit = limit
3706 
    args.write(self._oprot)
3707 
    self._oprot.writeMessageEnd()
3708 
    self._oprot.trans.flush()
3709 
 
3710 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3712 
    if mtype == TMessageType.EXCEPTION:
3713 
      x = TApplicationException()
3714 
      x.read(self._iprot)
3715 
      self._iprot.readMessageEnd()
3716 
      raise x
3717 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3718 
    result.read(self._iprot)
3719 
    self._iprot.readMessageEnd()
3720 
    if result.success is not None:
3721 
      return result.success
3722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3723 
 
6821 amar.kumar 3724 
  def getAllAliveItems(self, ):
3725 
    self.send_getAllAliveItems()
3726 
    return self.recv_getAllAliveItems()
3727 
 
3728 
  def send_getAllAliveItems(self, ):
3729 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3730 
    args = getAllAliveItems_args()
3731 
    args.write(self._oprot)
3732 
    self._oprot.writeMessageEnd()
3733 
    self._oprot.trans.flush()
3734 
 
3735 
  def recv_getAllAliveItems(self, ):
3736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3737 
    if mtype == TMessageType.EXCEPTION:
3738 
      x = TApplicationException()
3739 
      x.read(self._iprot)
3740 
      self._iprot.readMessageEnd()
3741 
      raise x
3742 
    result = getAllAliveItems_result()
3743 
    result.read(self._iprot)
3744 
    self._iprot.readMessageEnd()
3745 
    if result.success is not None:
3746 
      return result.success
3747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3748 
 
6921 anupam.sin 3749 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3750 
    """
3751 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3752 
 
6805 anupam.sin 3753 
    Parameters:
3754 
     - itemId
6921 anupam.sin 3755 
     - price
6805 anupam.sin 3756 
     - insurerId
3757 
     - quantity
3758 
    """
6921 anupam.sin 3759 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3760 
    return self.recv_getInsuranceAmount()
3761 
 
6921 anupam.sin 3762 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3763 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3764 
    args = getInsuranceAmount_args()
3765 
    args.itemId = itemId
6921 anupam.sin 3766 
    args.price = price
6805 anupam.sin 3767 
    args.insurerId = insurerId
3768 
    args.quantity = quantity
3769 
    args.write(self._oprot)
3770 
    self._oprot.writeMessageEnd()
3771 
    self._oprot.trans.flush()
3772 
 
3773 
  def recv_getInsuranceAmount(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 = getInsuranceAmount_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, "getInsuranceAmount failed: unknown result");
3786 
 
3787 
  def getInsurer(self, insurerId):
3788 
    """
3789 
    Parameters:
3790 
     - insurerId
3791 
    """
3792 
    self.send_getInsurer(insurerId)
3793 
    return self.recv_getInsurer()
3794 
 
3795 
  def send_getInsurer(self, insurerId):
3796 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3797 
    args = getInsurer_args()
3798 
    args.insurerId = insurerId
3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_getInsurer(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = getInsurer_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3813 
    if result.success is not None:
3814 
      return result.success
3815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3816 
 
6838 vikram.rag 3817 
  def getAllInsurers(self, ):
3818 
    self.send_getAllInsurers()
3819 
    return self.recv_getAllInsurers()
6805 anupam.sin 3820 
 
6838 vikram.rag 3821 
  def send_getAllInsurers(self, ):
3822 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3823 
    args = getAllInsurers_args()
3824 
    args.write(self._oprot)
3825 
    self._oprot.writeMessageEnd()
3826 
    self._oprot.trans.flush()
3827 
 
3828 
  def recv_getAllInsurers(self, ):
3829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3830 
    if mtype == TMessageType.EXCEPTION:
3831 
      x = TApplicationException()
3832 
      x.read(self._iprot)
3833 
      self._iprot.readMessageEnd()
3834 
      raise x
3835 
    result = getAllInsurers_result()
3836 
    result.read(self._iprot)
3837 
    self._iprot.readMessageEnd()
3838 
    if result.success is not None:
3839 
      return result.success
3840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3841 
 
6962 rajveer 3842 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3843 
    """
3844 
    Parameters:
3845 
     - insurerId
3846 
     - amount
3847 
    """
3848 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3849 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3850 
 
6962 rajveer 3851 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3852 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3853 
    args = updateInsuranceDeclaredAmount_args()
3854 
    args.insurerId = insurerId
3855 
    args.amount = amount
3856 
    args.write(self._oprot)
3857 
    self._oprot.writeMessageEnd()
3858 
    self._oprot.trans.flush()
3859 
 
3860 
  def recv_updateInsuranceDeclaredAmount(self, ):
3861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3862 
    if mtype == TMessageType.EXCEPTION:
3863 
      x = TApplicationException()
3864 
      x.read(self._iprot)
3865 
      self._iprot.readMessageEnd()
3866 
      raise x
3867 
    result = updateInsuranceDeclaredAmount_result()
3868 
    result.read(self._iprot)
3869 
    self._iprot.readMessageEnd()
3870 
    return
3871 
 
7190 amar.kumar 3872 
  def getFreebieForItem(self, itemId):
3873 
    """
3874 
    Parameters:
3875 
     - itemId
3876 
    """
3877 
    self.send_getFreebieForItem(itemId)
3878 
    return self.recv_getFreebieForItem()
6962 rajveer 3879 
 
7190 amar.kumar 3880 
  def send_getFreebieForItem(self, itemId):
3881 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3882 
    args = getFreebieForItem_args()
3883 
    args.itemId = itemId
3884 
    args.write(self._oprot)
3885 
    self._oprot.writeMessageEnd()
3886 
    self._oprot.trans.flush()
3887 
 
3888 
  def recv_getFreebieForItem(self, ):
3889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3890 
    if mtype == TMessageType.EXCEPTION:
3891 
      x = TApplicationException()
3892 
      x.read(self._iprot)
3893 
      self._iprot.readMessageEnd()
3894 
      raise x
3895 
    result = getFreebieForItem_result()
3896 
    result.read(self._iprot)
3897 
    self._iprot.readMessageEnd()
3898 
    if result.success is not None:
3899 
      return result.success
3900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3901 
 
3902 
  def addOrUpdateFreebieForItem(self, freebieItem):
3903 
    """
3904 
    Parameters:
3905 
     - freebieItem
3906 
    """
3907 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3908 
    self.recv_addOrUpdateFreebieForItem()
3909 
 
3910 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3911 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3912 
    args = addOrUpdateFreebieForItem_args()
3913 
    args.freebieItem = freebieItem
3914 
    args.write(self._oprot)
3915 
    self._oprot.writeMessageEnd()
3916 
    self._oprot.trans.flush()
3917 
 
3918 
  def recv_addOrUpdateFreebieForItem(self, ):
3919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3920 
    if mtype == TMessageType.EXCEPTION:
3921 
      x = TApplicationException()
3922 
      x.read(self._iprot)
3923 
      self._iprot.readMessageEnd()
3924 
      raise x
3925 
    result = addOrUpdateFreebieForItem_result()
3926 
    result.read(self._iprot)
3927 
    self._iprot.readMessageEnd()
3928 
    return
3929 
 
7272 amit.gupta 3930 
  def addOrUpdateBrandInfo(self, brandInfo):
3931 
    """
3932 
    Parameters:
3933 
     - brandInfo
3934 
    """
3935 
    self.send_addOrUpdateBrandInfo(brandInfo)
3936 
    self.recv_addOrUpdateBrandInfo()
3937 
 
3938 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3939 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3940 
    args = addOrUpdateBrandInfo_args()
3941 
    args.brandInfo = brandInfo
3942 
    args.write(self._oprot)
3943 
    self._oprot.writeMessageEnd()
3944 
    self._oprot.trans.flush()
3945 
 
3946 
  def recv_addOrUpdateBrandInfo(self, ):
3947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3948 
    if mtype == TMessageType.EXCEPTION:
3949 
      x = TApplicationException()
3950 
      x.read(self._iprot)
3951 
      self._iprot.readMessageEnd()
3952 
      raise x
3953 
    result = addOrUpdateBrandInfo_result()
3954 
    result.read(self._iprot)
3955 
    self._iprot.readMessageEnd()
3956 
    return
3957 
 
3958 
  def getBrandInfo(self, ):
3959 
    self.send_getBrandInfo()
3960 
    return self.recv_getBrandInfo()
3961 
 
3962 
  def send_getBrandInfo(self, ):
3963 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3964 
    args = getBrandInfo_args()
3965 
    args.write(self._oprot)
3966 
    self._oprot.writeMessageEnd()
3967 
    self._oprot.trans.flush()
3968 
 
3969 
  def recv_getBrandInfo(self, ):
3970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3971 
    if mtype == TMessageType.EXCEPTION:
3972 
      x = TApplicationException()
3973 
      x.read(self._iprot)
3974 
      self._iprot.readMessageEnd()
3975 
      raise x
3976 
    result = getBrandInfo_result()
3977 
    result.read(self._iprot)
3978 
    self._iprot.readMessageEnd()
3979 
    if result.success is not None:
3980 
      return result.success
3981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3982 
 
7256 rajveer 3983 
  def getStorePricing(self, itemId):
3984 
    """
3985 
    Parameters:
3986 
     - itemId
3987 
    """
3988 
    self.send_getStorePricing(itemId)
3989 
    return self.recv_getStorePricing()
7190 amar.kumar 3990 
 
7256 rajveer 3991 
  def send_getStorePricing(self, itemId):
3992 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3993 
    args = getStorePricing_args()
3994 
    args.itemId = itemId
3995 
    args.write(self._oprot)
3996 
    self._oprot.writeMessageEnd()
3997 
    self._oprot.trans.flush()
3998 
 
3999 
  def recv_getStorePricing(self, ):
4000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4001 
    if mtype == TMessageType.EXCEPTION:
4002 
      x = TApplicationException()
4003 
      x.read(self._iprot)
4004 
      self._iprot.readMessageEnd()
4005 
      raise x
4006 
    result = getStorePricing_result()
4007 
    result.read(self._iprot)
4008 
    self._iprot.readMessageEnd()
4009 
    if result.success is not None:
4010 
      return result.success
4011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
4012 
 
7306 rajveer 4013 
  def getStorePricings(self, itemIds):
4014 
    """
4015 
    Parameters:
4016 
     - itemIds
4017 
    """
4018 
    self.send_getStorePricings(itemIds)
4019 
    return self.recv_getStorePricings()
4020 
 
4021 
  def send_getStorePricings(self, itemIds):
4022 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
4023 
    args = getStorePricings_args()
4024 
    args.itemIds = itemIds
4025 
    args.write(self._oprot)
4026 
    self._oprot.writeMessageEnd()
4027 
    self._oprot.trans.flush()
4028 
 
4029 
  def recv_getStorePricings(self, ):
4030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4031 
    if mtype == TMessageType.EXCEPTION:
4032 
      x = TApplicationException()
4033 
      x.read(self._iprot)
4034 
      self._iprot.readMessageEnd()
4035 
      raise x
4036 
    result = getStorePricings_result()
4037 
    result.read(self._iprot)
4038 
    self._iprot.readMessageEnd()
4039 
    if result.success is not None:
4040 
      return result.success
4041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
4042 
 
7382 rajveer 4043 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 4044 
    """
4045 
    Parameters:
4046 
     - sp
7382 rajveer 4047 
     - allColors
7265 rajveer 4048 
    """
7382 rajveer 4049 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 4050 
    self.recv_updateStorePricing()
7256 rajveer 4051 
 
7382 rajveer 4052 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 4053 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
4054 
    args = updateStorePricing_args()
4055 
    args.sp = sp
7382 rajveer 4056 
    args.allColors = allColors
7265 rajveer 4057 
    args.write(self._oprot)
4058 
    self._oprot.writeMessageEnd()
4059 
    self._oprot.trans.flush()
4060 
 
4061 
  def recv_updateStorePricing(self, ):
4062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4063 
    if mtype == TMessageType.EXCEPTION:
4064 
      x = TApplicationException()
4065 
      x.read(self._iprot)
4066 
      self._iprot.readMessageEnd()
4067 
      raise x
4068 
    result = updateStorePricing_result()
4069 
    result.read(self._iprot)
4070 
    self._iprot.readMessageEnd()
4071 
    return
4072 
 
7281 kshitij.so 4073 
  def getAllAmazonListedItems(self, ):
4074 
    self.send_getAllAmazonListedItems()
4075 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 4076 
 
7281 kshitij.so 4077 
  def send_getAllAmazonListedItems(self, ):
4078 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
4079 
    args = getAllAmazonListedItems_args()
4080 
    args.write(self._oprot)
4081 
    self._oprot.writeMessageEnd()
4082 
    self._oprot.trans.flush()
4083 
 
4084 
  def recv_getAllAmazonListedItems(self, ):
4085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4086 
    if mtype == TMessageType.EXCEPTION:
4087 
      x = TApplicationException()
4088 
      x.read(self._iprot)
4089 
      self._iprot.readMessageEnd()
4090 
      raise x
4091 
    result = getAllAmazonListedItems_result()
4092 
    result.read(self._iprot)
4093 
    self._iprot.readMessageEnd()
4094 
    if result.success is not None:
4095 
      return result.success
4096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4097 
 
8619 kshitij.so 4098 
  def searchAmazonItems(self, searchTerm, offset, limit):
4099 
    """
4100 
    Parameters:
4101 
     - searchTerm
4102 
     - offset
4103 
     - limit
4104 
    """
4105 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4106 
    return self.recv_searchAmazonItems()
4107 
 
4108 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4109 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4110 
    args = searchAmazonItems_args()
4111 
    args.searchTerm = searchTerm
4112 
    args.offset = offset
4113 
    args.limit = limit
4114 
    args.write(self._oprot)
4115 
    self._oprot.writeMessageEnd()
4116 
    self._oprot.trans.flush()
4117 
 
4118 
  def recv_searchAmazonItems(self, ):
4119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4120 
    if mtype == TMessageType.EXCEPTION:
4121 
      x = TApplicationException()
4122 
      x.read(self._iprot)
4123 
      self._iprot.readMessageEnd()
4124 
      raise x
4125 
    result = searchAmazonItems_result()
4126 
    result.read(self._iprot)
4127 
    self._iprot.readMessageEnd()
4128 
    if result.success is not None:
4129 
      return result.success
4130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4131 
 
4132 
  def getAmazonSearchResultCount(self, searchTerm):
4133 
    """
4134 
    Parameters:
4135 
     - searchTerm
4136 
    """
4137 
    self.send_getAmazonSearchResultCount(searchTerm)
4138 
    return self.recv_getAmazonSearchResultCount()
4139 
 
4140 
  def send_getAmazonSearchResultCount(self, searchTerm):
4141 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4142 
    args = getAmazonSearchResultCount_args()
4143 
    args.searchTerm = searchTerm
4144 
    args.write(self._oprot)
4145 
    self._oprot.writeMessageEnd()
4146 
    self._oprot.trans.flush()
4147 
 
4148 
  def recv_getAmazonSearchResultCount(self, ):
4149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4150 
    if mtype == TMessageType.EXCEPTION:
4151 
      x = TApplicationException()
4152 
      x.read(self._iprot)
4153 
      self._iprot.readMessageEnd()
4154 
      raise x
4155 
    result = getAmazonSearchResultCount_result()
4156 
    result.read(self._iprot)
4157 
    self._iprot.readMessageEnd()
4158 
    if result.success is not None:
4159 
      return result.success
4160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4161 
 
4162 
  def getCountForAmazonlistedItems(self, ):
4163 
    self.send_getCountForAmazonlistedItems()
4164 
    return self.recv_getCountForAmazonlistedItems()
4165 
 
4166 
  def send_getCountForAmazonlistedItems(self, ):
4167 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4168 
    args = getCountForAmazonlistedItems_args()
4169 
    args.write(self._oprot)
4170 
    self._oprot.writeMessageEnd()
4171 
    self._oprot.trans.flush()
4172 
 
4173 
  def recv_getCountForAmazonlistedItems(self, ):
4174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4175 
    if mtype == TMessageType.EXCEPTION:
4176 
      x = TApplicationException()
4177 
      x.read(self._iprot)
4178 
      self._iprot.readMessageEnd()
4179 
      raise x
4180 
    result = getCountForAmazonlistedItems_result()
4181 
    result.read(self._iprot)
4182 
    self._iprot.readMessageEnd()
4183 
    if result.success is not None:
4184 
      return result.success
4185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4186 
 
7281 kshitij.so 4187 
  def getAmazonItemDetails(self, itemId):
4188 
    """
4189 
    Parameters:
4190 
     - itemId
4191 
    """
4192 
    self.send_getAmazonItemDetails(itemId)
4193 
    return self.recv_getAmazonItemDetails()
4194 
 
4195 
  def send_getAmazonItemDetails(self, itemId):
4196 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4197 
    args = getAmazonItemDetails_args()
4198 
    args.itemId = itemId
4199 
    args.write(self._oprot)
4200 
    self._oprot.writeMessageEnd()
4201 
    self._oprot.trans.flush()
4202 
 
4203 
  def recv_getAmazonItemDetails(self, ):
4204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4205 
    if mtype == TMessageType.EXCEPTION:
4206 
      x = TApplicationException()
4207 
      x.read(self._iprot)
4208 
      self._iprot.readMessageEnd()
4209 
      raise x
4210 
    result = getAmazonItemDetails_result()
4211 
    result.read(self._iprot)
4212 
    self._iprot.readMessageEnd()
4213 
    if result.success is not None:
4214 
      return result.success
4215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4216 
 
8168 kshitij.so 4217 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4218 
    """
4219 
    Parameters:
8168 kshitij.so 4220 
     - amazonlisted
7281 kshitij.so 4221 
    """
8168 kshitij.so 4222 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4223 
    self.recv_updateAmazonItemDetails()
4224 
 
8168 kshitij.so 4225 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4226 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4227 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4228 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4229 
    args.write(self._oprot)
4230 
    self._oprot.writeMessageEnd()
4231 
    self._oprot.trans.flush()
4232 
 
4233 
  def recv_updateAmazonItemDetails(self, ):
4234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4235 
    if mtype == TMessageType.EXCEPTION:
4236 
      x = TApplicationException()
4237 
      x.read(self._iprot)
4238 
      self._iprot.readMessageEnd()
4239 
      raise x
4240 
    result = updateAmazonItemDetails_result()
4241 
    result.read(self._iprot)
4242 
    self._iprot.readMessageEnd()
4243 
    return
4244 
 
4245 
  def addAmazonItem(self, amazonlisted):
4246 
    """
4247 
    Parameters:
4248 
     - amazonlisted
4249 
    """
4250 
    self.send_addAmazonItem(amazonlisted)
4251 
    self.recv_addAmazonItem()
4252 
 
4253 
  def send_addAmazonItem(self, amazonlisted):
4254 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4255 
    args = addAmazonItem_args()
4256 
    args.amazonlisted = amazonlisted
4257 
    args.write(self._oprot)
4258 
    self._oprot.writeMessageEnd()
4259 
    self._oprot.trans.flush()
4260 
 
4261 
  def recv_addAmazonItem(self, ):
4262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4263 
    if mtype == TMessageType.EXCEPTION:
4264 
      x = TApplicationException()
4265 
      x.read(self._iprot)
4266 
      self._iprot.readMessageEnd()
4267 
      raise x
4268 
    result = addAmazonItem_result()
4269 
    result.read(self._iprot)
4270 
    self._iprot.readMessageEnd()
4271 
    return
4272 
 
7291 vikram.rag 4273 
  def getAsinItems(self, ):
4274 
    self.send_getAsinItems()
4275 
    return self.recv_getAsinItems()
7281 kshitij.so 4276 
 
7291 vikram.rag 4277 
  def send_getAsinItems(self, ):
4278 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4279 
    args = getAsinItems_args()
4280 
    args.write(self._oprot)
4281 
    self._oprot.writeMessageEnd()
4282 
    self._oprot.trans.flush()
4283 
 
4284 
  def recv_getAsinItems(self, ):
4285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4286 
    if mtype == TMessageType.EXCEPTION:
4287 
      x = TApplicationException()
4288 
      x.read(self._iprot)
4289 
      self._iprot.readMessageEnd()
4290 
      raise x
4291 
    result = getAsinItems_result()
4292 
    result.read(self._iprot)
4293 
    self._iprot.readMessageEnd()
4294 
    if result.success is not None:
4295 
      return result.success
4296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4297 
 
4298 
  def getAllFbaListedItems(self, ):
4299 
    self.send_getAllFbaListedItems()
4300 
    return self.recv_getAllFbaListedItems()
4301 
 
4302 
  def send_getAllFbaListedItems(self, ):
4303 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4304 
    args = getAllFbaListedItems_args()
4305 
    args.write(self._oprot)
4306 
    self._oprot.writeMessageEnd()
4307 
    self._oprot.trans.flush()
4308 
 
4309 
  def recv_getAllFbaListedItems(self, ):
4310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4311 
    if mtype == TMessageType.EXCEPTION:
4312 
      x = TApplicationException()
4313 
      x.read(self._iprot)
4314 
      self._iprot.readMessageEnd()
4315 
      raise x
4316 
    result = getAllFbaListedItems_result()
4317 
    result.read(self._iprot)
4318 
    self._iprot.readMessageEnd()
4319 
    if result.success is not None:
4320 
      return result.success
4321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4322 
 
4323 
  def getAllNonFbaListedItems(self, ):
4324 
    self.send_getAllNonFbaListedItems()
4325 
    return self.recv_getAllNonFbaListedItems()
4326 
 
4327 
  def send_getAllNonFbaListedItems(self, ):
4328 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4329 
    args = getAllNonFbaListedItems_args()
4330 
    args.write(self._oprot)
4331 
    self._oprot.writeMessageEnd()
4332 
    self._oprot.trans.flush()
4333 
 
4334 
  def recv_getAllNonFbaListedItems(self, ):
4335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4336 
    if mtype == TMessageType.EXCEPTION:
4337 
      x = TApplicationException()
4338 
      x.read(self._iprot)
4339 
      self._iprot.readMessageEnd()
4340 
      raise x
4341 
    result = getAllNonFbaListedItems_result()
4342 
    result.read(self._iprot)
4343 
    self._iprot.readMessageEnd()
4344 
    if result.success is not None:
4345 
      return result.success
4346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4347 
 
7460 kshitij.so 4348 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4349 
    """
4350 
    Parameters:
4351 
     - itemId
4352 
     - holdInventory
4353 
     - defaultInventory
4354 
    """
4355 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4356 
    return self.recv_updateItemInventory()
7291 vikram.rag 4357 
 
7460 kshitij.so 4358 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4359 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4360 
    args = updateItemInventory_args()
4361 
    args.itemId = itemId
4362 
    args.holdInventory = holdInventory
4363 
    args.defaultInventory = defaultInventory
4364 
    args.write(self._oprot)
4365 
    self._oprot.writeMessageEnd()
4366 
    self._oprot.trans.flush()
4367 
 
4368 
  def recv_updateItemInventory(self, ):
4369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4370 
    if mtype == TMessageType.EXCEPTION:
4371 
      x = TApplicationException()
4372 
      x.read(self._iprot)
4373 
      self._iprot.readMessageEnd()
4374 
      raise x
4375 
    result = updateItemInventory_result()
4376 
    result.read(self._iprot)
4377 
    self._iprot.readMessageEnd()
4378 
    if result.success is not None:
4379 
      return result.success
4380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4381 
 
7770 kshitij.so 4382 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4383 
    """
4384 
    Parameters:
4385 
     - type
4386 
     - sku
4387 
     - timestamp
4388 
    """
4389 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4390 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4391 
 
7770 kshitij.so 4392 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4393 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4394 
    args = updateTimestampForAmazonFeeds_args()
4395 
    args.type = type
4396 
    args.sku = sku
4397 
    args.timestamp = timestamp
4398 
    args.write(self._oprot)
4399 
    self._oprot.writeMessageEnd()
4400 
    self._oprot.trans.flush()
4401 
 
4402 
  def recv_updateTimestampForAmazonFeeds(self, ):
4403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4404 
    if mtype == TMessageType.EXCEPTION:
4405 
      x = TApplicationException()
4406 
      x.read(self._iprot)
4407 
      self._iprot.readMessageEnd()
4408 
      raise x
4409 
    result = updateTimestampForAmazonFeeds_result()
4410 
    result.read(self._iprot)
4411 
    self._iprot.readMessageEnd()
4412 
    if result.success is not None:
4413 
      return result.success
4414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4415 
 
7897 amar.kumar 4416 
  def getAllParentCategories(self, ):
4417 
    self.send_getAllParentCategories()
4418 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4419 
 
7897 amar.kumar 4420 
  def send_getAllParentCategories(self, ):
4421 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4422 
    args = getAllParentCategories_args()
4423 
    args.write(self._oprot)
4424 
    self._oprot.writeMessageEnd()
4425 
    self._oprot.trans.flush()
4426 
 
4427 
  def recv_getAllParentCategories(self, ):
4428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4429 
    if mtype == TMessageType.EXCEPTION:
4430 
      x = TApplicationException()
4431 
      x.read(self._iprot)
4432 
      self._iprot.readMessageEnd()
4433 
      raise x
4434 
    result = getAllParentCategories_result()
4435 
    result.read(self._iprot)
4436 
    self._iprot.readMessageEnd()
4437 
    if result.success is not None:
4438 
      return result.success
4439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4440 
 
7977 kshitij.so 4441 
  def addPageViewEvent(self, pageViewEvents):
4442 
    """
4443 
    Parameters:
4444 
     - pageViewEvents
4445 
    """
4446 
    self.send_addPageViewEvent(pageViewEvents)
4447 
    self.recv_addPageViewEvent()
7897 amar.kumar 4448 
 
7977 kshitij.so 4449 
  def send_addPageViewEvent(self, pageViewEvents):
4450 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4451 
    args = addPageViewEvent_args()
4452 
    args.pageViewEvents = pageViewEvents
4453 
    args.write(self._oprot)
4454 
    self._oprot.writeMessageEnd()
4455 
    self._oprot.trans.flush()
4456 
 
4457 
  def recv_addPageViewEvent(self, ):
4458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4459 
    if mtype == TMessageType.EXCEPTION:
4460 
      x = TApplicationException()
4461 
      x.read(self._iprot)
4462 
      self._iprot.readMessageEnd()
4463 
      raise x
4464 
    result = addPageViewEvent_result()
4465 
    result.read(self._iprot)
4466 
    self._iprot.readMessageEnd()
4467 
    return
4468 
 
4469 
  def addCartEvent(self, cartEvents):
4470 
    """
4471 
    Parameters:
4472 
     - cartEvents
4473 
    """
4474 
    self.send_addCartEvent(cartEvents)
4475 
    self.recv_addCartEvent()
4476 
 
4477 
  def send_addCartEvent(self, cartEvents):
4478 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4479 
    args = addCartEvent_args()
4480 
    args.cartEvents = cartEvents
4481 
    args.write(self._oprot)
4482 
    self._oprot.writeMessageEnd()
4483 
    self._oprot.trans.flush()
4484 
 
4485 
  def recv_addCartEvent(self, ):
4486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4487 
    if mtype == TMessageType.EXCEPTION:
4488 
      x = TApplicationException()
4489 
      x.read(self._iprot)
4490 
      self._iprot.readMessageEnd()
4491 
      raise x
4492 
    result = addCartEvent_result()
4493 
    result.read(self._iprot)
4494 
    self._iprot.readMessageEnd()
4495 
    return
4496 
 
8182 amar.kumar 4497 
  def addEbayItem(self, ebayItem):
4498 
    """
4499 
    Parameters:
4500 
     - ebayItem
4501 
    """
4502 
    self.send_addEbayItem(ebayItem)
4503 
    self.recv_addEbayItem()
4504 
 
4505 
  def send_addEbayItem(self, ebayItem):
4506 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4507 
    args = addEbayItem_args()
4508 
    args.ebayItem = ebayItem
4509 
    args.write(self._oprot)
4510 
    self._oprot.writeMessageEnd()
4511 
    self._oprot.trans.flush()
4512 
 
4513 
  def recv_addEbayItem(self, ):
4514 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4515 
    if mtype == TMessageType.EXCEPTION:
4516 
      x = TApplicationException()
4517 
      x.read(self._iprot)
4518 
      self._iprot.readMessageEnd()
4519 
      raise x
4520 
    result = addEbayItem_result()
4521 
    result.read(self._iprot)
4522 
    self._iprot.readMessageEnd()
4523 
    return
4524 
 
4525 
  def getEbayItem(self, listingId):
4526 
    """
4527 
    Parameters:
4528 
     - listingId
4529 
    """
4530 
    self.send_getEbayItem(listingId)
4531 
    return self.recv_getEbayItem()
4532 
 
4533 
  def send_getEbayItem(self, listingId):
4534 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4535 
    args = getEbayItem_args()
4536 
    args.listingId = listingId
4537 
    args.write(self._oprot)
4538 
    self._oprot.writeMessageEnd()
4539 
    self._oprot.trans.flush()
4540 
 
4541 
  def recv_getEbayItem(self, ):
4542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4543 
    if mtype == TMessageType.EXCEPTION:
4544 
      x = TApplicationException()
4545 
      x.read(self._iprot)
4546 
      self._iprot.readMessageEnd()
4547 
      raise x
4548 
    result = getEbayItem_result()
4549 
    result.read(self._iprot)
4550 
    self._iprot.readMessageEnd()
4551 
    if result.success is not None:
4552 
      return result.success
4553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4554 
 
4555 
  def updateEbayItem(self, ebayItem):
4556 
    """
4557 
    Parameters:
4558 
     - ebayItem
4559 
    """
4560 
    self.send_updateEbayItem(ebayItem)
4561 
    self.recv_updateEbayItem()
4562 
 
4563 
  def send_updateEbayItem(self, ebayItem):
4564 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4565 
    args = updateEbayItem_args()
4566 
    args.ebayItem = ebayItem
4567 
    args.write(self._oprot)
4568 
    self._oprot.writeMessageEnd()
4569 
    self._oprot.trans.flush()
4570 
 
4571 
  def recv_updateEbayItem(self, ):
4572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4573 
    if mtype == TMessageType.EXCEPTION:
4574 
      x = TApplicationException()
4575 
      x.read(self._iprot)
4576 
      self._iprot.readMessageEnd()
4577 
      raise x
4578 
    result = updateEbayItem_result()
4579 
    result.read(self._iprot)
4580 
    self._iprot.readMessageEnd()
4581 
    return
4582 
 
8139 kshitij.so 4583 
  def getAmazonListedItems(self, offset, limit):
4584 
    """
4585 
    Parameters:
4586 
     - offset
4587 
     - limit
4588 
    """
4589 
    self.send_getAmazonListedItems(offset, limit)
4590 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4591 
 
8139 kshitij.so 4592 
  def send_getAmazonListedItems(self, offset, limit):
4593 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4594 
    args = getAmazonListedItems_args()
4595 
    args.offset = offset
4596 
    args.limit = limit
4597 
    args.write(self._oprot)
4598 
    self._oprot.writeMessageEnd()
4599 
    self._oprot.trans.flush()
4600 
 
4601 
  def recv_getAmazonListedItems(self, ):
4602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4603 
    if mtype == TMessageType.EXCEPTION:
4604 
      x = TApplicationException()
4605 
      x.read(self._iprot)
4606 
      self._iprot.readMessageEnd()
4607 
      raise x
4608 
    result = getAmazonListedItems_result()
4609 
    result.read(self._iprot)
4610 
    self._iprot.readMessageEnd()
4611 
    if result.success is not None:
4612 
      return result.success
4613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4614 
 
8168 kshitij.so 4615 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4616 
    """
4617 
    Parameters:
4618 
     - amazonlisted
4619 
    """
4620 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4621 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4622 
 
8168 kshitij.so 4623 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4624 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4625 
    args = updateAmazonAttributesInBulk_args()
4626 
    args.amazonlisted = amazonlisted
4627 
    args.write(self._oprot)
4628 
    self._oprot.writeMessageEnd()
4629 
    self._oprot.trans.flush()
4630 
 
4631 
  def recv_updateAmazonAttributesInBulk(self, ):
4632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4633 
    if mtype == TMessageType.EXCEPTION:
4634 
      x = TApplicationException()
4635 
      x.read(self._iprot)
4636 
      self._iprot.readMessageEnd()
4637 
      raise x
4638 
    result = updateAmazonAttributesInBulk_result()
4639 
    result.read(self._iprot)
4640 
    self._iprot.readMessageEnd()
4641 
    if result.success is not None:
4642 
      return result.success
4643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4644 
 
8379 vikram.rag 4645 
  def getAllItemstoListOnFba(self, ):
4646 
    self.send_getAllItemstoListOnFba()
4647 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4648 
 
8379 vikram.rag 4649 
  def send_getAllItemstoListOnFba(self, ):
4650 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4651 
    args = getAllItemstoListOnFba_args()
4652 
    args.write(self._oprot)
4653 
    self._oprot.writeMessageEnd()
4654 
    self._oprot.trans.flush()
4655 
 
4656 
  def recv_getAllItemstoListOnFba(self, ):
4657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4658 
    if mtype == TMessageType.EXCEPTION:
4659 
      x = TApplicationException()
4660 
      x.read(self._iprot)
4661 
      self._iprot.readMessageEnd()
4662 
      raise x
4663 
    result = getAllItemstoListOnFba_result()
4664 
    result.read(self._iprot)
4665 
    self._iprot.readMessageEnd()
4666 
    if result.success is not None:
4667 
      return result.success
4668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4669 
 
4670 
  def getAllItemstoListOnNonFba(self, ):
4671 
    self.send_getAllItemstoListOnNonFba()
4672 
    return self.recv_getAllItemstoListOnNonFba()
4673 
 
4674 
  def send_getAllItemstoListOnNonFba(self, ):
4675 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4676 
    args = getAllItemstoListOnNonFba_args()
4677 
    args.write(self._oprot)
4678 
    self._oprot.writeMessageEnd()
4679 
    self._oprot.trans.flush()
4680 
 
4681 
  def recv_getAllItemstoListOnNonFba(self, ):
4682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4683 
    if mtype == TMessageType.EXCEPTION:
4684 
      x = TApplicationException()
4685 
      x.read(self._iprot)
4686 
      self._iprot.readMessageEnd()
4687 
      raise x
4688 
    result = getAllItemstoListOnNonFba_result()
4689 
    result.read(self._iprot)
4690 
    self._iprot.readMessageEnd()
4691 
    if result.success is not None:
4692 
      return result.success
4693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4694 
 
8619 kshitij.so 4695 
  def updateAsin(self, item):
4696 
    """
4697 
    Parameters:
4698 
     - item
4699 
    """
4700 
    self.send_updateAsin(item)
4701 
    self.recv_updateAsin()
8616 vikram.rag 4702 
 
8619 kshitij.so 4703 
  def send_updateAsin(self, item):
4704 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4705 
    args = updateAsin_args()
4706 
    args.item = item
4707 
    args.write(self._oprot)
4708 
    self._oprot.writeMessageEnd()
4709 
    self._oprot.trans.flush()
4710 
 
4711 
  def recv_updateAsin(self, ):
4712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4713 
    if mtype == TMessageType.EXCEPTION:
4714 
      x = TApplicationException()
4715 
      x.read(self._iprot)
4716 
      self._iprot.readMessageEnd()
4717 
      raise x
4718 
    result = updateAsin_result()
4719 
    result.read(self._iprot)
4720 
    self._iprot.readMessageEnd()
4721 
    return
4722 
 
8739 vikram.rag 4723 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4724 
    """
4725 
    Parameters:
4726 
     - snapdealitem
4727 
    """
4728 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4729 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4730 
 
8739 vikram.rag 4731 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4732 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4733 
    args = addOrUpdateSnapdealItem_args()
4734 
    args.snapdealitem = snapdealitem
4735 
    args.write(self._oprot)
4736 
    self._oprot.writeMessageEnd()
4737 
    self._oprot.trans.flush()
4738 
 
4739 
  def recv_addOrUpdateSnapdealItem(self, ):
4740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4741 
    if mtype == TMessageType.EXCEPTION:
4742 
      x = TApplicationException()
4743 
      x.read(self._iprot)
4744 
      self._iprot.readMessageEnd()
4745 
      raise x
4746 
    result = addOrUpdateSnapdealItem_result()
4747 
    result.read(self._iprot)
4748 
    self._iprot.readMessageEnd()
4749 
    if result.success is not None:
4750 
      return result.success
4751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4752 
 
4753 
  def getSnapdealItem(self, item_id):
4754 
    """
4755 
    Parameters:
4756 
     - item_id
4757 
    """
4758 
    self.send_getSnapdealItem(item_id)
4759 
    return self.recv_getSnapdealItem()
4760 
 
4761 
  def send_getSnapdealItem(self, item_id):
4762 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4763 
    args = getSnapdealItem_args()
4764 
    args.item_id = item_id
4765 
    args.write(self._oprot)
4766 
    self._oprot.writeMessageEnd()
4767 
    self._oprot.trans.flush()
4768 
 
4769 
  def recv_getSnapdealItem(self, ):
4770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4771 
    if mtype == TMessageType.EXCEPTION:
4772 
      x = TApplicationException()
4773 
      x.read(self._iprot)
4774 
      self._iprot.readMessageEnd()
4775 
      raise x
4776 
    result = getSnapdealItem_result()
4777 
    result.read(self._iprot)
4778 
    self._iprot.readMessageEnd()
4779 
    if result.success is not None:
4780 
      return result.success
4781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4782 
 
9242 kshitij.so 4783 
  def getSnapdealItemDetails(self, item_id):
4784 
    """
4785 
    Parameters:
4786 
     - item_id
4787 
    """
4788 
    self.send_getSnapdealItemDetails(item_id)
4789 
    return self.recv_getSnapdealItemDetails()
4790 
 
4791 
  def send_getSnapdealItemDetails(self, item_id):
4792 
    self._oprot.writeMessageBegin('getSnapdealItemDetails', TMessageType.CALL, self._seqid)
4793 
    args = getSnapdealItemDetails_args()
4794 
    args.item_id = item_id
4795 
    args.write(self._oprot)
4796 
    self._oprot.writeMessageEnd()
4797 
    self._oprot.trans.flush()
4798 
 
4799 
  def recv_getSnapdealItemDetails(self, ):
4800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4801 
    if mtype == TMessageType.EXCEPTION:
4802 
      x = TApplicationException()
4803 
      x.read(self._iprot)
4804 
      self._iprot.readMessageEnd()
4805 
      raise x
4806 
    result = getSnapdealItemDetails_result()
4807 
    result.read(self._iprot)
4808 
    self._iprot.readMessageEnd()
4809 
    if result.success is not None:
4810 
      return result.success
4811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItemDetails failed: unknown result");
4812 
 
8739 vikram.rag 4813 
  def getAllSnapdealItems(self, ):
4814 
    self.send_getAllSnapdealItems()
4815 
    return self.recv_getAllSnapdealItems()
4816 
 
4817 
  def send_getAllSnapdealItems(self, ):
4818 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4819 
    args = getAllSnapdealItems_args()
4820 
    args.write(self._oprot)
4821 
    self._oprot.writeMessageEnd()
4822 
    self._oprot.trans.flush()
4823 
 
4824 
  def recv_getAllSnapdealItems(self, ):
4825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4826 
    if mtype == TMessageType.EXCEPTION:
4827 
      x = TApplicationException()
4828 
      x.read(self._iprot)
4829 
      self._iprot.readMessageEnd()
4830 
      raise x
4831 
    result = getAllSnapdealItems_result()
4832 
    result.read(self._iprot)
4833 
    self._iprot.readMessageEnd()
4834 
    if result.success is not None:
4835 
      return result.success
4836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4837 
 
9242 kshitij.so 4838 
  def getSnapdealItems(self, offset, limit):
4839 
    """
4840 
    Parameters:
4841 
     - offset
4842 
     - limit
4843 
    """
4844 
    self.send_getSnapdealItems(offset, limit)
4845 
    return self.recv_getSnapdealItems()
8739 vikram.rag 4846 
 
9242 kshitij.so 4847 
  def send_getSnapdealItems(self, offset, limit):
4848 
    self._oprot.writeMessageBegin('getSnapdealItems', TMessageType.CALL, self._seqid)
4849 
    args = getSnapdealItems_args()
4850 
    args.offset = offset
4851 
    args.limit = limit
4852 
    args.write(self._oprot)
4853 
    self._oprot.writeMessageEnd()
4854 
    self._oprot.trans.flush()
4855 
 
4856 
  def recv_getSnapdealItems(self, ):
4857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4858 
    if mtype == TMessageType.EXCEPTION:
4859 
      x = TApplicationException()
4860 
      x.read(self._iprot)
4861 
      self._iprot.readMessageEnd()
4862 
      raise x
4863 
    result = getSnapdealItems_result()
4864 
    result.read(self._iprot)
4865 
    self._iprot.readMessageEnd()
4866 
    if result.success is not None:
4867 
      return result.success
4868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItems failed: unknown result");
4869 
 
4870 
  def searchSnapdealItems(self, searchTerm, offset, limit):
4871 
    """
4872 
    Parameters:
4873 
     - searchTerm
4874 
     - offset
4875 
     - limit
4876 
    """
4877 
    self.send_searchSnapdealItems(searchTerm, offset, limit)
4878 
    return self.recv_searchSnapdealItems()
4879 
 
4880 
  def send_searchSnapdealItems(self, searchTerm, offset, limit):
4881 
    self._oprot.writeMessageBegin('searchSnapdealItems', TMessageType.CALL, self._seqid)
4882 
    args = searchSnapdealItems_args()
4883 
    args.searchTerm = searchTerm
4884 
    args.offset = offset
4885 
    args.limit = limit
4886 
    args.write(self._oprot)
4887 
    self._oprot.writeMessageEnd()
4888 
    self._oprot.trans.flush()
4889 
 
4890 
  def recv_searchSnapdealItems(self, ):
4891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4892 
    if mtype == TMessageType.EXCEPTION:
4893 
      x = TApplicationException()
4894 
      x.read(self._iprot)
4895 
      self._iprot.readMessageEnd()
4896 
      raise x
4897 
    result = searchSnapdealItems_result()
4898 
    result.read(self._iprot)
4899 
    self._iprot.readMessageEnd()
4900 
    if result.success is not None:
4901 
      return result.success
4902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchSnapdealItems failed: unknown result");
4903 
 
4904 
  def getCountForSnapdealItems(self, ):
4905 
    self.send_getCountForSnapdealItems()
4906 
    return self.recv_getCountForSnapdealItems()
4907 
 
4908 
  def send_getCountForSnapdealItems(self, ):
4909 
    self._oprot.writeMessageBegin('getCountForSnapdealItems', TMessageType.CALL, self._seqid)
4910 
    args = getCountForSnapdealItems_args()
4911 
    args.write(self._oprot)
4912 
    self._oprot.writeMessageEnd()
4913 
    self._oprot.trans.flush()
4914 
 
4915 
  def recv_getCountForSnapdealItems(self, ):
4916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4917 
    if mtype == TMessageType.EXCEPTION:
4918 
      x = TApplicationException()
4919 
      x.read(self._iprot)
4920 
      self._iprot.readMessageEnd()
4921 
      raise x
4922 
    result = getCountForSnapdealItems_result()
4923 
    result.read(self._iprot)
4924 
    self._iprot.readMessageEnd()
4925 
    if result.success is not None:
4926 
      return result.success
4927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForSnapdealItems failed: unknown result");
4928 
 
4929 
  def getSnapdealSearchResultCount(self, searchTerm):
4930 
    """
4931 
    Parameters:
4932 
     - searchTerm
4933 
    """
4934 
    self.send_getSnapdealSearchResultCount(searchTerm)
4935 
    return self.recv_getSnapdealSearchResultCount()
4936 
 
4937 
  def send_getSnapdealSearchResultCount(self, searchTerm):
4938 
    self._oprot.writeMessageBegin('getSnapdealSearchResultCount', TMessageType.CALL, self._seqid)
4939 
    args = getSnapdealSearchResultCount_args()
4940 
    args.searchTerm = searchTerm
4941 
    args.write(self._oprot)
4942 
    self._oprot.writeMessageEnd()
4943 
    self._oprot.trans.flush()
4944 
 
4945 
  def recv_getSnapdealSearchResultCount(self, ):
4946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4947 
    if mtype == TMessageType.EXCEPTION:
4948 
      x = TApplicationException()
4949 
      x.read(self._iprot)
4950 
      self._iprot.readMessageEnd()
4951 
      raise x
4952 
    result = getSnapdealSearchResultCount_result()
4953 
    result.read(self._iprot)
4954 
    self._iprot.readMessageEnd()
4955 
    if result.success is not None:
4956 
      return result.success
4957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealSearchResultCount failed: unknown result");
4958 
 
9299 kshitij.so 4959 
  def getPrefferedInsurerForItem(self, itemId, insurerType):
4960 
    """
4961 
    Parameters:
4962 
     - itemId
4963 
     - insurerType
4964 
    """
4965 
    self.send_getPrefferedInsurerForItem(itemId, insurerType)
4966 
    return self.recv_getPrefferedInsurerForItem()
9242 kshitij.so 4967 
 
9299 kshitij.so 4968 
  def send_getPrefferedInsurerForItem(self, itemId, insurerType):
4969 
    self._oprot.writeMessageBegin('getPrefferedInsurerForItem', TMessageType.CALL, self._seqid)
4970 
    args = getPrefferedInsurerForItem_args()
4971 
    args.itemId = itemId
4972 
    args.insurerType = insurerType
4973 
    args.write(self._oprot)
4974 
    self._oprot.writeMessageEnd()
4975 
    self._oprot.trans.flush()
4976 
 
4977 
  def recv_getPrefferedInsurerForItem(self, ):
4978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4979 
    if mtype == TMessageType.EXCEPTION:
4980 
      x = TApplicationException()
4981 
      x.read(self._iprot)
4982 
      self._iprot.readMessageEnd()
4983 
      raise x
4984 
    result = getPrefferedInsurerForItem_result()
4985 
    result.read(self._iprot)
4986 
    self._iprot.readMessageEnd()
4987 
    if result.success is not None:
4988 
      return result.success
4989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrefferedInsurerForItem failed: unknown result");
4990 
 
4991 
 
5944 mandeep.dh 4992 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4993 
  def __init__(self, handler):
4994 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4995 
    self._processMap["addItem"] = Processor.process_addItem
4996 
    self._processMap["updateItem"] = Processor.process_updateItem
4997 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4998 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4999 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
5000 
    self._processMap["startItemOn"] = Processor.process_startItemOn
5001 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
5002 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
5003 
    self._processMap["getItem"] = Processor.process_getItem
5004 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
5005 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
5006 
    self._processMap["getAllItems"] = Processor.process_getAllItems
5007 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
5008 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
5009 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
5010 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
5011 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
5012 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
5013 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
5014 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
5015 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
5016 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
5017 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
5018 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
5019 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
5020 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
5021 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
5022 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
5023 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
5024 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
5025 
    self._processMap["addCategory"] = Processor.process_addCategory
5026 
    self._processMap["getCategory"] = Processor.process_getCategory
5027 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
5028 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
5029 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 5030 
    self._processMap["addTag"] = Processor.process_addTag
5031 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
5032 
    self._processMap["deleteTag"] = Processor.process_deleteTag
5033 
    self._processMap["getAllTags"] = Processor.process_getAllTags
5034 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 5035 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 5036 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 5037 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 5038 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
5039 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
5040 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
5041 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 5042 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 5043 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 5044 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
5045 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 5046 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
5047 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
5048 
    self._processMap["addCampaign"] = Processor.process_addCampaign
5049 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
5050 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
5051 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
9155 kshitij.so 5052 
    self._processMap["getActiveBannersForMobileSite"] = Processor.process_getActiveBannersForMobileSite
5944 mandeep.dh 5053 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
5054 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
5055 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
5056 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
5057 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
5058 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
5059 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
5060 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
5061 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
5062 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
5063 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
5064 
    self._processMap["getAllSources"] = Processor.process_getAllSources
5065 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
5066 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
5067 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
5068 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
5069 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
5070 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
5071 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
5072 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
5073 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
5074 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
5075 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
5076 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
5077 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
5078 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 5079 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
5080 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 5081 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 5082 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 5083 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
5084 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 5085 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 5086 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 5087 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
5088 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 5089 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
5090 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 5091 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 5092 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 5093 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 5094 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 5095 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
5096 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
5097 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 5098 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
5099 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
5100 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 5101 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
5102 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
5103 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 5104 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 5105 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 5106 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 5107 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
5108 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 5109 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
5110 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
5111 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 5112 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 5113 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 5114 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
5115 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8619 kshitij.so 5116 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 5117 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
5118 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
9242 kshitij.so 5119 
    self._processMap["getSnapdealItemDetails"] = Processor.process_getSnapdealItemDetails
8739 vikram.rag 5120 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
9242 kshitij.so 5121 
    self._processMap["getSnapdealItems"] = Processor.process_getSnapdealItems
5122 
    self._processMap["searchSnapdealItems"] = Processor.process_searchSnapdealItems
5123 
    self._processMap["getCountForSnapdealItems"] = Processor.process_getCountForSnapdealItems
5124 
    self._processMap["getSnapdealSearchResultCount"] = Processor.process_getSnapdealSearchResultCount
9299 kshitij.so 5125 
    self._processMap["getPrefferedInsurerForItem"] = Processor.process_getPrefferedInsurerForItem
5944 mandeep.dh 5126 
 
5127 
  def process(self, iprot, oprot):
5128 
    (name, type, seqid) = iprot.readMessageBegin()
5129 
    if name not in self._processMap:
5130 
      iprot.skip(TType.STRUCT)
5131 
      iprot.readMessageEnd()
5132 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5133 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5134 
      x.write(oprot)
5135 
      oprot.writeMessageEnd()
5136 
      oprot.trans.flush()
5137 
      return
5138 
    else:
5139 
      self._processMap[name](self, seqid, iprot, oprot)
5140 
    return True
5141 
 
5142 
  def process_addItem(self, seqid, iprot, oprot):
5143 
    args = addItem_args()
5144 
    args.read(iprot)
5145 
    iprot.readMessageEnd()
5146 
    result = addItem_result()
5147 
    try:
5148 
      result.success = self._handler.addItem(args.item)
5149 
    except CatalogServiceException, cex:
5150 
      result.cex = cex
5151 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
5152 
    result.write(oprot)
5153 
    oprot.writeMessageEnd()
5154 
    oprot.trans.flush()
5155 
 
5156 
  def process_updateItem(self, seqid, iprot, oprot):
5157 
    args = updateItem_args()
5158 
    args.read(iprot)
5159 
    iprot.readMessageEnd()
5160 
    result = updateItem_result()
5161 
    try:
5162 
      result.success = self._handler.updateItem(args.item)
5163 
    except CatalogServiceException, cex:
5164 
      result.cex = cex
5165 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
5166 
    result.write(oprot)
5167 
    oprot.writeMessageEnd()
5168 
    oprot.trans.flush()
5169 
 
5170 
  def process_isActive(self, seqid, iprot, oprot):
5171 
    args = isActive_args()
5172 
    args.read(iprot)
5173 
    iprot.readMessageEnd()
5174 
    result = isActive_result()
5175 
    try:
5176 
      result.success = self._handler.isActive(args.itemId)
5177 
    except CatalogServiceException, isex:
5178 
      result.isex = isex
5179 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
5180 
    result.write(oprot)
5181 
    oprot.writeMessageEnd()
5182 
    oprot.trans.flush()
5183 
 
7438 amit.gupta 5184 
  def process_getItemsStatus(self, seqid, iprot, oprot):
5185 
    args = getItemsStatus_args()
5186 
    args.read(iprot)
5187 
    iprot.readMessageEnd()
5188 
    result = getItemsStatus_result()
5189 
    try:
5190 
      result.success = self._handler.getItemsStatus(args.itemIds)
5191 
    except CatalogServiceException, isex:
5192 
      result.isex = isex
5193 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
5194 
    result.write(oprot)
5195 
    oprot.writeMessageEnd()
5196 
    oprot.trans.flush()
5197 
 
5944 mandeep.dh 5198 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
5199 
    args = getItemStatusDescription_args()
5200 
    args.read(iprot)
5201 
    iprot.readMessageEnd()
5202 
    result = getItemStatusDescription_result()
5203 
    try:
5204 
      result.success = self._handler.getItemStatusDescription(args.itemId)
5205 
    except CatalogServiceException, isex:
5206 
      result.isex = isex
5207 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
5208 
    result.write(oprot)
5209 
    oprot.writeMessageEnd()
5210 
    oprot.trans.flush()
5211 
 
5212 
  def process_startItemOn(self, seqid, iprot, oprot):
5213 
    args = startItemOn_args()
5214 
    args.read(iprot)
5215 
    iprot.readMessageEnd()
5216 
    result = startItemOn_result()
5217 
    try:
5218 
      self._handler.startItemOn(args.item_id, args.timestamp)
5219 
    except CatalogServiceException, cex:
5220 
      result.cex = cex
5221 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
5222 
    result.write(oprot)
5223 
    oprot.writeMessageEnd()
5224 
    oprot.trans.flush()
5225 
 
5226 
  def process_retireItemOn(self, seqid, iprot, oprot):
5227 
    args = retireItemOn_args()
5228 
    args.read(iprot)
5229 
    iprot.readMessageEnd()
5230 
    result = retireItemOn_result()
5231 
    try:
5232 
      self._handler.retireItemOn(args.item_id, args.timestamp)
5233 
    except CatalogServiceException, cex:
5234 
      result.cex = cex
5235 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
5236 
    result.write(oprot)
5237 
    oprot.writeMessageEnd()
5238 
    oprot.trans.flush()
5239 
 
5240 
  def process_changeItemStatus(self, seqid, iprot, oprot):
5241 
    args = changeItemStatus_args()
5242 
    args.read(iprot)
5243 
    iprot.readMessageEnd()
5244 
    result = changeItemStatus_result()
5245 
    try:
5246 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5247 
    except CatalogServiceException, cex:
5248 
      result.cex = cex
5249 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5250 
    result.write(oprot)
5251 
    oprot.writeMessageEnd()
5252 
    oprot.trans.flush()
5253 
 
5254 
  def process_getItem(self, seqid, iprot, oprot):
5255 
    args = getItem_args()
5256 
    args.read(iprot)
5257 
    iprot.readMessageEnd()
5258 
    result = getItem_result()
5259 
    try:
5260 
      result.success = self._handler.getItem(args.item_id)
5261 
    except CatalogServiceException, cex:
5262 
      result.cex = cex
5263 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5264 
    result.write(oprot)
5265 
    oprot.writeMessageEnd()
5266 
    oprot.trans.flush()
5267 
 
5268 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5269 
    args = getItemsByCatalogId_args()
5270 
    args.read(iprot)
5271 
    iprot.readMessageEnd()
5272 
    result = getItemsByCatalogId_result()
5273 
    try:
5274 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5275 
    except CatalogServiceException, cex:
5276 
      result.cex = cex
5277 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5278 
    result.write(oprot)
5279 
    oprot.writeMessageEnd()
5280 
    oprot.trans.flush()
5281 
 
5282 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5283 
    args = getValidItemsByCatalogId_args()
5284 
    args.read(iprot)
5285 
    iprot.readMessageEnd()
5286 
    result = getValidItemsByCatalogId_result()
5287 
    try:
5288 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5289 
    except CatalogServiceException, cex:
5290 
      result.cex = cex
5291 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5292 
    result.write(oprot)
5293 
    oprot.writeMessageEnd()
5294 
    oprot.trans.flush()
5295 
 
5296 
  def process_getAllItems(self, seqid, iprot, oprot):
5297 
    args = getAllItems_args()
5298 
    args.read(iprot)
5299 
    iprot.readMessageEnd()
5300 
    result = getAllItems_result()
5301 
    try:
5302 
      result.success = self._handler.getAllItems(args.isActive)
5303 
    except CatalogServiceException, cex:
5304 
      result.cex = cex
5305 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5306 
    result.write(oprot)
5307 
    oprot.writeMessageEnd()
5308 
    oprot.trans.flush()
5309 
 
5310 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5311 
    args = getAllItemsByStatus_args()
5312 
    args.read(iprot)
5313 
    iprot.readMessageEnd()
5314 
    result = getAllItemsByStatus_result()
5315 
    try:
5316 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5317 
    except CatalogServiceException, cex:
5318 
      result.cex = cex
5319 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5320 
    result.write(oprot)
5321 
    oprot.writeMessageEnd()
5322 
    oprot.trans.flush()
5323 
 
5324 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5325 
    args = markItemAsContentComplete_args()
5326 
    args.read(iprot)
5327 
    iprot.readMessageEnd()
5328 
    result = markItemAsContentComplete_result()
5329 
    try:
9253 rajveer 5330 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber, args.isAndroid)
5944 mandeep.dh 5331 
    except CatalogServiceException, cex:
5332 
      result.cex = cex
5333 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5334 
    result.write(oprot)
5335 
    oprot.writeMessageEnd()
5336 
    oprot.trans.flush()
5337 
 
5338 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5339 
    args = getAllItemsInRange_args()
5340 
    args.read(iprot)
5341 
    iprot.readMessageEnd()
5342 
    result = getAllItemsInRange_result()
5343 
    try:
5344 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5345 
    except CatalogServiceException, cex:
5346 
      result.cex = cex
5347 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5348 
    result.write(oprot)
5349 
    oprot.writeMessageEnd()
5350 
    oprot.trans.flush()
5351 
 
5352 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5353 
    args = getAllItemsByStatusInRange_args()
5354 
    args.read(iprot)
5355 
    iprot.readMessageEnd()
5356 
    result = getAllItemsByStatusInRange_result()
5357 
    try:
5358 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5359 
    except CatalogServiceException, cex:
5360 
      result.cex = cex
5361 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5362 
    result.write(oprot)
5363 
    oprot.writeMessageEnd()
5364 
    oprot.trans.flush()
5365 
 
5366 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5367 
    args = getItemCountByStatus_args()
5368 
    args.read(iprot)
5369 
    iprot.readMessageEnd()
5370 
    result = getItemCountByStatus_result()
5371 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5372 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5373 
    result.write(oprot)
5374 
    oprot.writeMessageEnd()
5375 
    oprot.trans.flush()
5376 
 
5377 
  def process_getBestSellers(self, seqid, iprot, oprot):
5378 
    args = getBestSellers_args()
5379 
    args.read(iprot)
5380 
    iprot.readMessageEnd()
5381 
    result = getBestSellers_result()
5382 
    try:
5383 
      result.success = self._handler.getBestSellers()
5384 
    except CatalogServiceException, isex:
5385 
      result.isex = isex
5386 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5387 
    result.write(oprot)
5388 
    oprot.writeMessageEnd()
5389 
    oprot.trans.flush()
5390 
 
5391 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5392 
    args = getBestSellersCatalogIds_args()
5393 
    args.read(iprot)
5394 
    iprot.readMessageEnd()
5395 
    result = getBestSellersCatalogIds_result()
5396 
    try:
5397 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5398 
    except CatalogServiceException, cex:
5399 
      result.cex = cex
5400 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5401 
    result.write(oprot)
5402 
    oprot.writeMessageEnd()
5403 
    oprot.trans.flush()
5404 
 
5405 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5406 
    args = getBestSellersCount_args()
5407 
    args.read(iprot)
5408 
    iprot.readMessageEnd()
5409 
    result = getBestSellersCount_result()
5410 
    try:
5411 
      result.success = self._handler.getBestSellersCount()
5412 
    except CatalogServiceException, cex:
5413 
      result.cex = cex
5414 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5415 
    result.write(oprot)
5416 
    oprot.writeMessageEnd()
5417 
    oprot.trans.flush()
5418 
 
5419 
  def process_getBestDeals(self, seqid, iprot, oprot):
5420 
    args = getBestDeals_args()
5421 
    args.read(iprot)
5422 
    iprot.readMessageEnd()
5423 
    result = getBestDeals_result()
5424 
    try:
5425 
      result.success = self._handler.getBestDeals()
5426 
    except CatalogServiceException, isex:
5427 
      result.isex = isex
5428 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5429 
    result.write(oprot)
5430 
    oprot.writeMessageEnd()
5431 
    oprot.trans.flush()
5432 
 
5433 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5434 
    args = getBestDealsCatalogIds_args()
5435 
    args.read(iprot)
5436 
    iprot.readMessageEnd()
5437 
    result = getBestDealsCatalogIds_result()
5438 
    try:
5439 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5440 
    except CatalogServiceException, cex:
5441 
      result.cex = cex
5442 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5443 
    result.write(oprot)
5444 
    oprot.writeMessageEnd()
5445 
    oprot.trans.flush()
5446 
 
5447 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5448 
    args = getBestDealsCount_args()
5449 
    args.read(iprot)
5450 
    iprot.readMessageEnd()
5451 
    result = getBestDealsCount_result()
5452 
    try:
5453 
      result.success = self._handler.getBestDealsCount()
5454 
    except CatalogServiceException, cex:
5455 
      result.cex = cex
5456 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5457 
    result.write(oprot)
5458 
    oprot.writeMessageEnd()
5459 
    oprot.trans.flush()
5460 
 
5461 
  def process_getComingSoon(self, seqid, iprot, oprot):
5462 
    args = getComingSoon_args()
5463 
    args.read(iprot)
5464 
    iprot.readMessageEnd()
5465 
    result = getComingSoon_result()
5466 
    try:
5467 
      result.success = self._handler.getComingSoon()
5468 
    except CatalogServiceException, isex:
5469 
      result.isex = isex
5470 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5471 
    result.write(oprot)
5472 
    oprot.writeMessageEnd()
5473 
    oprot.trans.flush()
5474 
 
5475 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5476 
    args = getComingSoonCatalogIds_args()
5477 
    args.read(iprot)
5478 
    iprot.readMessageEnd()
5479 
    result = getComingSoonCatalogIds_result()
5480 
    try:
5481 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5482 
    except CatalogServiceException, cex:
5483 
      result.cex = cex
5484 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5485 
    result.write(oprot)
5486 
    oprot.writeMessageEnd()
5487 
    oprot.trans.flush()
5488 
 
5489 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5490 
    args = getComingSoonCount_args()
5491 
    args.read(iprot)
5492 
    iprot.readMessageEnd()
5493 
    result = getComingSoonCount_result()
5494 
    try:
5495 
      result.success = self._handler.getComingSoonCount()
5496 
    except CatalogServiceException, cex:
5497 
      result.cex = cex
5498 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5499 
    result.write(oprot)
5500 
    oprot.writeMessageEnd()
5501 
    oprot.trans.flush()
5502 
 
5503 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5504 
    args = getLatestArrivals_args()
5505 
    args.read(iprot)
5506 
    iprot.readMessageEnd()
5507 
    result = getLatestArrivals_result()
5508 
    try:
5509 
      result.success = self._handler.getLatestArrivals()
5510 
    except CatalogServiceException, isex:
5511 
      result.isex = isex
5512 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5513 
    result.write(oprot)
5514 
    oprot.writeMessageEnd()
5515 
    oprot.trans.flush()
5516 
 
5517 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5518 
    args = getLatestArrivalsCatalogIds_args()
5519 
    args.read(iprot)
5520 
    iprot.readMessageEnd()
5521 
    result = getLatestArrivalsCatalogIds_result()
5522 
    try:
5523 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5524 
    except CatalogServiceException, cex:
5525 
      result.cex = cex
5526 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5527 
    result.write(oprot)
5528 
    oprot.writeMessageEnd()
5529 
    oprot.trans.flush()
5530 
 
5531 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5532 
    args = getLatestArrivalsCount_args()
5533 
    args.read(iprot)
5534 
    iprot.readMessageEnd()
5535 
    result = getLatestArrivalsCount_result()
5536 
    try:
5537 
      result.success = self._handler.getLatestArrivalsCount()
5538 
    except CatalogServiceException, cex:
5539 
      result.cex = cex
5540 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5541 
    result.write(oprot)
5542 
    oprot.writeMessageEnd()
5543 
    oprot.trans.flush()
5544 
 
5545 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5546 
    args = generateNewEntityID_args()
5547 
    args.read(iprot)
5548 
    iprot.readMessageEnd()
5549 
    result = generateNewEntityID_result()
5550 
    result.success = self._handler.generateNewEntityID()
5551 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5552 
    result.write(oprot)
5553 
    oprot.writeMessageEnd()
5554 
    oprot.trans.flush()
5555 
 
5556 
  def process_addCategory(self, seqid, iprot, oprot):
5557 
    args = addCategory_args()
5558 
    args.read(iprot)
5559 
    iprot.readMessageEnd()
5560 
    result = addCategory_result()
5561 
    result.success = self._handler.addCategory(args.category)
5562 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5563 
    result.write(oprot)
5564 
    oprot.writeMessageEnd()
5565 
    oprot.trans.flush()
5566 
 
5567 
  def process_getCategory(self, seqid, iprot, oprot):
5568 
    args = getCategory_args()
5569 
    args.read(iprot)
5570 
    iprot.readMessageEnd()
5571 
    result = getCategory_result()
5572 
    result.success = self._handler.getCategory(args.id)
5573 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5574 
    result.write(oprot)
5575 
    oprot.writeMessageEnd()
5576 
    oprot.trans.flush()
5577 
 
5578 
  def process_getAllCategories(self, seqid, iprot, oprot):
5579 
    args = getAllCategories_args()
5580 
    args.read(iprot)
5581 
    iprot.readMessageEnd()
5582 
    result = getAllCategories_result()
5583 
    result.success = self._handler.getAllCategories()
5584 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5585 
    result.write(oprot)
5586 
    oprot.writeMessageEnd()
5587 
    oprot.trans.flush()
5588 
 
5589 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5590 
    args = getAllSimilarItems_args()
5591 
    args.read(iprot)
5592 
    iprot.readMessageEnd()
5593 
    result = getAllSimilarItems_result()
5594 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5595 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5596 
    result.write(oprot)
5597 
    oprot.writeMessageEnd()
5598 
    oprot.trans.flush()
5599 
 
5600 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5601 
    args = addSimilarItem_args()
5602 
    args.read(iprot)
5603 
    iprot.readMessageEnd()
5604 
    result = addSimilarItem_result()
5605 
    try:
5606 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5607 
    except CatalogServiceException, cex:
5608 
      result.cex = cex
5609 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5610 
    result.write(oprot)
5611 
    oprot.writeMessageEnd()
5612 
    oprot.trans.flush()
5613 
 
6512 kshitij.so 5614 
  def process_addTag(self, seqid, iprot, oprot):
5615 
    args = addTag_args()
5616 
    args.read(iprot)
5617 
    iprot.readMessageEnd()
5618 
    result = addTag_result()
5619 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5620 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5621 
    result.write(oprot)
5622 
    oprot.writeMessageEnd()
5623 
    oprot.trans.flush()
5624 
 
5625 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5626 
    args = deleteEntityTag_args()
5627 
    args.read(iprot)
5628 
    iprot.readMessageEnd()
5629 
    result = deleteEntityTag_result()
5630 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5631 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5632 
    result.write(oprot)
5633 
    oprot.writeMessageEnd()
5634 
    oprot.trans.flush()
5635 
 
5636 
  def process_deleteTag(self, seqid, iprot, oprot):
5637 
    args = deleteTag_args()
5638 
    args.read(iprot)
5639 
    iprot.readMessageEnd()
5640 
    result = deleteTag_result()
5641 
    result.success = self._handler.deleteTag(args.displayName)
5642 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5643 
    result.write(oprot)
5644 
    oprot.writeMessageEnd()
5645 
    oprot.trans.flush()
5646 
 
5647 
  def process_getAllTags(self, seqid, iprot, oprot):
5648 
    args = getAllTags_args()
5649 
    args.read(iprot)
5650 
    iprot.readMessageEnd()
5651 
    result = getAllTags_result()
5652 
    result.success = self._handler.getAllTags()
5653 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5654 
    result.write(oprot)
5655 
    oprot.writeMessageEnd()
5656 
    oprot.trans.flush()
5657 
 
5658 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5659 
    args = getAllEntitiesByTagName_args()
5660 
    args.read(iprot)
5661 
    iprot.readMessageEnd()
5662 
    result = getAllEntitiesByTagName_result()
5663 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5664 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5665 
    result.write(oprot)
5666 
    oprot.writeMessageEnd()
5667 
    oprot.trans.flush()
5668 
 
6845 amit.gupta 5669 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5670 
    args = getAllEntityTags_args()
5671 
    args.read(iprot)
5672 
    iprot.readMessageEnd()
5673 
    result = getAllEntityTags_result()
5674 
    result.success = self._handler.getAllEntityTags()
5675 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5676 
    result.write(oprot)
5677 
    oprot.writeMessageEnd()
5678 
    oprot.trans.flush()
5679 
 
6850 kshitij.so 5680 
  def process_addBanner(self, seqid, iprot, oprot):
5681 
    args = addBanner_args()
5682 
    args.read(iprot)
5683 
    iprot.readMessageEnd()
5684 
    result = addBanner_result()
8590 kshitij.so 5685 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5686 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5687 
    result.write(oprot)
5688 
    oprot.writeMessageEnd()
5689 
    oprot.trans.flush()
5690 
 
8579 kshitij.so 5691 
  def process_updateBanner(self, seqid, iprot, oprot):
5692 
    args = updateBanner_args()
5693 
    args.read(iprot)
5694 
    iprot.readMessageEnd()
5695 
    result = updateBanner_result()
5696 
    result.success = self._handler.updateBanner(args.banner)
5697 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5698 
    result.write(oprot)
5699 
    oprot.writeMessageEnd()
5700 
    oprot.trans.flush()
5701 
 
6850 kshitij.so 5702 
  def process_getAllBanners(self, seqid, iprot, oprot):
5703 
    args = getAllBanners_args()
5704 
    args.read(iprot)
5705 
    iprot.readMessageEnd()
5706 
    result = getAllBanners_result()
5707 
    result.success = self._handler.getAllBanners()
5708 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5709 
    result.write(oprot)
5710 
    oprot.writeMessageEnd()
5711 
    oprot.trans.flush()
5712 
 
5713 
  def process_deleteBanner(self, seqid, iprot, oprot):
5714 
    args = deleteBanner_args()
5715 
    args.read(iprot)
5716 
    iprot.readMessageEnd()
5717 
    result = deleteBanner_result()
9155 kshitij.so 5718 
    result.success = self._handler.deleteBanner(args.bannerName, args.bannerType)
6850 kshitij.so 5719 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5720 
    result.write(oprot)
5721 
    oprot.writeMessageEnd()
5722 
    oprot.trans.flush()
5723 
 
5724 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5725 
    args = getBannerDetails_args()
5726 
    args.read(iprot)
5727 
    iprot.readMessageEnd()
5728 
    result = getBannerDetails_result()
9155 kshitij.so 5729 
    result.success = self._handler.getBannerDetails(args.bannerName, args.bannerType)
6850 kshitij.so 5730 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5731 
    result.write(oprot)
5732 
    oprot.writeMessageEnd()
5733 
    oprot.trans.flush()
5734 
 
5735 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5736 
    args = getActiveBanners_args()
5737 
    args.read(iprot)
5738 
    iprot.readMessageEnd()
5739 
    result = getActiveBanners_result()
5740 
    result.success = self._handler.getActiveBanners()
5741 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5742 
    result.write(oprot)
5743 
    oprot.writeMessageEnd()
5744 
    oprot.trans.flush()
5745 
 
6849 kshitij.so 5746 
  def process_addBannerMap(self, seqid, iprot, oprot):
5747 
    args = addBannerMap_args()
5748 
    args.read(iprot)
5749 
    iprot.readMessageEnd()
5750 
    result = addBannerMap_result()
8579 kshitij.so 5751 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5752 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5753 
    result.write(oprot)
5754 
    oprot.writeMessageEnd()
5755 
    oprot.trans.flush()
5756 
 
8579 kshitij.so 5757 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5758 
    args = updateBannerMap_args()
5759 
    args.read(iprot)
5760 
    iprot.readMessageEnd()
5761 
    result = updateBannerMap_result()
5762 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5763 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5764 
    result.write(oprot)
5765 
    oprot.writeMessageEnd()
5766 
    oprot.trans.flush()
5767 
 
6849 kshitij.so 5768 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5769 
    args = deleteBannerMap_args()
5770 
    args.read(iprot)
5771 
    iprot.readMessageEnd()
5772 
    result = deleteBannerMap_result()
5773 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5774 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5775 
    result.write(oprot)
5776 
    oprot.writeMessageEnd()
5777 
    oprot.trans.flush()
5778 
 
5779 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5780 
    args = getBannerMapDetails_args()
5781 
    args.read(iprot)
5782 
    iprot.readMessageEnd()
5783 
    result = getBannerMapDetails_result()
9155 kshitij.so 5784 
    result.success = self._handler.getBannerMapDetails(args.bannerName, args.bannerType)
6849 kshitij.so 5785 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5786 
    result.write(oprot)
5787 
    oprot.writeMessageEnd()
5788 
    oprot.trans.flush()
5789 
 
8579 kshitij.so 5790 
  def process_addBannerUri(self, seqid, iprot, oprot):
5791 
    args = addBannerUri_args()
5792 
    args.read(iprot)
5793 
    iprot.readMessageEnd()
5794 
    result = addBannerUri_result()
5795 
    self._handler.addBannerUri(args.bannerUriMappings)
5796 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5797 
    result.write(oprot)
5798 
    oprot.writeMessageEnd()
5799 
    oprot.trans.flush()
5800 
 
5801 
  def process_getUriMapping(self, seqid, iprot, oprot):
5802 
    args = getUriMapping_args()
5803 
    args.read(iprot)
5804 
    iprot.readMessageEnd()
5805 
    result = getUriMapping_result()
9155 kshitij.so 5806 
    result.success = self._handler.getUriMapping(args.bannerName, args.bannerType)
8579 kshitij.so 5807 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5808 
    result.write(oprot)
5809 
    oprot.writeMessageEnd()
5810 
    oprot.trans.flush()
5811 
 
5812 
  def process_addCampaign(self, seqid, iprot, oprot):
5813 
    args = addCampaign_args()
5814 
    args.read(iprot)
5815 
    iprot.readMessageEnd()
5816 
    result = addCampaign_result()
5817 
    self._handler.addCampaign(args.campaign)
5818 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5819 
    result.write(oprot)
5820 
    oprot.writeMessageEnd()
5821 
    oprot.trans.flush()
5822 
 
5823 
  def process_getCampaigns(self, seqid, iprot, oprot):
5824 
    args = getCampaigns_args()
5825 
    args.read(iprot)
5826 
    iprot.readMessageEnd()
5827 
    result = getCampaigns_result()
5828 
    result.success = self._handler.getCampaigns(args.campaignName)
5829 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5830 
    result.write(oprot)
5831 
    oprot.writeMessageEnd()
5832 
    oprot.trans.flush()
5833 
 
5834 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5835 
    args = deleteCampaign_args()
5836 
    args.read(iprot)
5837 
    iprot.readMessageEnd()
5838 
    result = deleteCampaign_result()
5839 
    self._handler.deleteCampaign(args.campaignId)
5840 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5841 
    result.write(oprot)
5842 
    oprot.writeMessageEnd()
5843 
    oprot.trans.flush()
5844 
 
5845 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5846 
    args = getAllCampaigns_args()
5847 
    args.read(iprot)
5848 
    iprot.readMessageEnd()
5849 
    result = getAllCampaigns_result()
5850 
    result.success = self._handler.getAllCampaigns()
5851 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5852 
    result.write(oprot)
5853 
    oprot.writeMessageEnd()
5854 
    oprot.trans.flush()
5855 
 
9155 kshitij.so 5856 
  def process_getActiveBannersForMobileSite(self, seqid, iprot, oprot):
5857 
    args = getActiveBannersForMobileSite_args()
5858 
    args.read(iprot)
5859 
    iprot.readMessageEnd()
5860 
    result = getActiveBannersForMobileSite_result()
5861 
    result.success = self._handler.getActiveBannersForMobileSite()
5862 
    oprot.writeMessageBegin("getActiveBannersForMobileSite", TMessageType.REPLY, seqid)
5863 
    result.write(oprot)
5864 
    oprot.writeMessageEnd()
5865 
    oprot.trans.flush()
5866 
 
5944 mandeep.dh 5867 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5868 
    args = deleteSimilarItem_args()
5869 
    args.read(iprot)
5870 
    iprot.readMessageEnd()
5871 
    result = deleteSimilarItem_result()
5872 
    try:
5873 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5874 
    except CatalogServiceException, cex:
5875 
      result.cex = cex
5876 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5877 
    result.write(oprot)
5878 
    oprot.writeMessageEnd()
5879 
    oprot.trans.flush()
5880 
 
5881 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5882 
    args = checkSimilarItem_args()
5883 
    args.read(iprot)
5884 
    iprot.readMessageEnd()
5885 
    result = checkSimilarItem_result()
5886 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5887 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5888 
    result.write(oprot)
5889 
    oprot.writeMessageEnd()
5890 
    oprot.trans.flush()
5891 
 
5892 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5893 
    args = validateRiskyStatus_args()
5894 
    args.read(iprot)
5895 
    iprot.readMessageEnd()
5896 
    result = validateRiskyStatus_result()
5897 
    self._handler.validateRiskyStatus(args.itemId)
5898 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5899 
    result.write(oprot)
5900 
    oprot.writeMessageEnd()
5901 
    oprot.trans.flush()
5902 
 
5903 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5904 
    args = changeItemRiskyFlag_args()
5905 
    args.read(iprot)
5906 
    iprot.readMessageEnd()
5907 
    result = changeItemRiskyFlag_result()
5908 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5909 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5910 
    result.write(oprot)
5911 
    oprot.writeMessageEnd()
5912 
    oprot.trans.flush()
5913 
 
5914 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5915 
    args = getItemsByRiskyFlag_args()
5916 
    args.read(iprot)
5917 
    iprot.readMessageEnd()
5918 
    result = getItemsByRiskyFlag_result()
5919 
    result.success = self._handler.getItemsByRiskyFlag()
5920 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5921 
    result.write(oprot)
5922 
    oprot.writeMessageEnd()
5923 
    oprot.trans.flush()
5924 
 
5925 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5926 
    args = getItemsForMasterSheet_args()
5927 
    args.read(iprot)
5928 
    iprot.readMessageEnd()
5929 
    result = getItemsForMasterSheet_result()
5930 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5931 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5932 
    result.write(oprot)
5933 
    oprot.writeMessageEnd()
5934 
    oprot.trans.flush()
5935 
 
5936 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5937 
    args = getSimilarItemsCatalogIds_args()
5938 
    args.read(iprot)
5939 
    iprot.readMessageEnd()
5940 
    result = getSimilarItemsCatalogIds_result()
5941 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5942 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5943 
    result.write(oprot)
5944 
    oprot.writeMessageEnd()
5945 
    oprot.trans.flush()
5946 
 
5947 
  def process_addProductNotification(self, seqid, iprot, oprot):
5948 
    args = addProductNotification_args()
5949 
    args.read(iprot)
5950 
    iprot.readMessageEnd()
5951 
    result = addProductNotification_result()
5952 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5953 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5954 
    result.write(oprot)
5955 
    oprot.writeMessageEnd()
5956 
    oprot.trans.flush()
5957 
 
5958 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5959 
    args = sendProductNotifications_args()
5960 
    args.read(iprot)
5961 
    iprot.readMessageEnd()
5962 
    result = sendProductNotifications_result()
5963 
    result.success = self._handler.sendProductNotifications()
5964 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5965 
    result.write(oprot)
5966 
    oprot.writeMessageEnd()
5967 
    oprot.trans.flush()
5968 
 
5969 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5970 
    args = getAllBrandsByCategory_args()
5971 
    args.read(iprot)
5972 
    iprot.readMessageEnd()
5973 
    result = getAllBrandsByCategory_result()
5974 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5975 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5976 
    result.write(oprot)
5977 
    oprot.writeMessageEnd()
5978 
    oprot.trans.flush()
5979 
 
5980 
  def process_getAllBrands(self, seqid, iprot, oprot):
5981 
    args = getAllBrands_args()
5982 
    args.read(iprot)
5983 
    iprot.readMessageEnd()
5984 
    result = getAllBrands_result()
5985 
    result.success = self._handler.getAllBrands()
5986 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5987 
    result.write(oprot)
5988 
    oprot.writeMessageEnd()
5989 
    oprot.trans.flush()
5990 
 
5991 
  def process_getAllSources(self, seqid, iprot, oprot):
5992 
    args = getAllSources_args()
5993 
    args.read(iprot)
5994 
    iprot.readMessageEnd()
5995 
    result = getAllSources_result()
5996 
    result.success = self._handler.getAllSources()
5997 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5998 
    result.write(oprot)
5999 
    oprot.writeMessageEnd()
6000 
    oprot.trans.flush()
6001 
 
6002 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
6003 
    args = getItemPricingBySource_args()
6004 
    args.read(iprot)
6005 
    iprot.readMessageEnd()
6006 
    result = getItemPricingBySource_result()
6007 
    try:
6008 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
6009 
    except CatalogServiceException, cex:
6010 
      result.cex = cex
6011 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
6012 
    result.write(oprot)
6013 
    oprot.writeMessageEnd()
6014 
    oprot.trans.flush()
6015 
 
6016 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
6017 
    args = addSourceItemPricing_args()
6018 
    args.read(iprot)
6019 
    iprot.readMessageEnd()
6020 
    result = addSourceItemPricing_result()
6021 
    try:
6022 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
6023 
    except CatalogServiceException, cex:
6024 
      result.cex = cex
6025 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
6026 
    result.write(oprot)
6027 
    oprot.writeMessageEnd()
6028 
    oprot.trans.flush()
6029 
 
6030 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
6031 
    args = getAllSourcePricing_args()
6032 
    args.read(iprot)
6033 
    iprot.readMessageEnd()
6034 
    result = getAllSourcePricing_result()
6035 
    try:
6036 
      result.success = self._handler.getAllSourcePricing(args.itemId)
6037 
    except CatalogServiceException, cex:
6038 
      result.cex = cex
6039 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
6040 
    result.write(oprot)
6041 
    oprot.writeMessageEnd()
6042 
    oprot.trans.flush()
6043 
 
6044 
  def process_getItemForSource(self, seqid, iprot, oprot):
6045 
    args = getItemForSource_args()
6046 
    args.read(iprot)
6047 
    iprot.readMessageEnd()
6048 
    result = getItemForSource_result()
6049 
    try:
6050 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
6051 
    except CatalogServiceException, cex:
6052 
      result.cex = cex
6053 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
6054 
    result.write(oprot)
6055 
    oprot.writeMessageEnd()
6056 
    oprot.trans.flush()
6057 
 
6058 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
6059 
    args = searchItemsInRange_args()
6060 
    args.read(iprot)
6061 
    iprot.readMessageEnd()
6062 
    result = searchItemsInRange_result()
6063 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
6064 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
6065 
    result.write(oprot)
6066 
    oprot.writeMessageEnd()
6067 
    oprot.trans.flush()
6068 
 
6069 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
6070 
    args = getSearchResultCount_args()
6071 
    args.read(iprot)
6072 
    iprot.readMessageEnd()
6073 
    result = getSearchResultCount_result()
6074 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
6075 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
6076 
    result.write(oprot)
6077 
    oprot.writeMessageEnd()
6078 
    oprot.trans.flush()
6079 
 
6080 
  def process_getProductNotifications(self, seqid, iprot, oprot):
6081 
    args = getProductNotifications_args()
6082 
    args.read(iprot)
6083 
    iprot.readMessageEnd()
6084 
    result = getProductNotifications_result()
6085 
    result.success = self._handler.getProductNotifications(args.startDateTime)
6086 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
6087 
    result.write(oprot)
6088 
    oprot.writeMessageEnd()
6089 
    oprot.trans.flush()
6090 
 
6091 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
6092 
    args = getProductNotificationRequestCount_args()
6093 
    args.read(iprot)
6094 
    iprot.readMessageEnd()
6095 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 6096 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 6097 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
6098 
    result.write(oprot)
6099 
    oprot.writeMessageEnd()
6100 
    oprot.trans.flush()
6101 
 
6102 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
6103 
    args = addAuthorizationLog_args()
6104 
    args.read(iprot)
6105 
    iprot.readMessageEnd()
6106 
    result = addAuthorizationLog_result()
6107 
    try:
6108 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
6109 
    except CatalogServiceException, cex:
6110 
      result.cex = cex
6111 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
6112 
    result.write(oprot)
6113 
    oprot.writeMessageEnd()
6114 
    oprot.trans.flush()
6115 
 
6116 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
6117 
    args = addupdateVoucherForItem_args()
6118 
    args.read(iprot)
6119 
    iprot.readMessageEnd()
6120 
    result = addupdateVoucherForItem_result()
6121 
    try:
6122 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
6123 
    except CatalogServiceException, cex:
6124 
      result.cex = cex
6125 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
6126 
    result.write(oprot)
6127 
    oprot.writeMessageEnd()
6128 
    oprot.trans.flush()
6129 
 
6130 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
6131 
    args = deleteVoucherForItem_args()
6132 
    args.read(iprot)
6133 
    iprot.readMessageEnd()
6134 
    result = deleteVoucherForItem_result()
6135 
    try:
6136 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
6137 
    except CatalogServiceException, cex:
6138 
      result.cex = cex
6139 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
6140 
    result.write(oprot)
6141 
    oprot.writeMessageEnd()
6142 
    oprot.trans.flush()
6143 
 
6144 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
6145 
    args = getVoucherAmount_args()
6146 
    args.read(iprot)
6147 
    iprot.readMessageEnd()
6148 
    result = getVoucherAmount_result()
6149 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
6150 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
6151 
    result.write(oprot)
6152 
    oprot.writeMessageEnd()
6153 
    oprot.trans.flush()
6154 
 
6155 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
6156 
    args = getAllItemVouchers_args()
6157 
    args.read(iprot)
6158 
    iprot.readMessageEnd()
6159 
    result = getAllItemVouchers_result()
6160 
    result.success = self._handler.getAllItemVouchers(args.itemId)
6161 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
6162 
    result.write(oprot)
6163 
    oprot.writeMessageEnd()
6164 
    oprot.trans.flush()
6165 
 
6166 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
6167 
    args = isValidCatalogItemId_args()
6168 
    args.read(iprot)
6169 
    iprot.readMessageEnd()
6170 
    result = isValidCatalogItemId_result()
6171 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
6172 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
6173 
    result.write(oprot)
6174 
    oprot.writeMessageEnd()
6175 
    oprot.trans.flush()
6176 
 
6039 amit.gupta 6177 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
6178 
    args = getVatPercentageForItem_args()
6179 
    args.read(iprot)
6180 
    iprot.readMessageEnd()
6181 
    result = getVatPercentageForItem_result()
7340 amit.gupta 6182 
    try:
6183 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
6184 
    except CatalogServiceException, cex:
6185 
      result.cex = cex
6039 amit.gupta 6186 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
6187 
    result.write(oprot)
6188 
    oprot.writeMessageEnd()
6189 
    oprot.trans.flush()
5944 mandeep.dh 6190 
 
6039 amit.gupta 6191 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
6192 
    args = getVatAmountForItem_args()
6193 
    args.read(iprot)
6194 
    iprot.readMessageEnd()
6195 
    result = getVatAmountForItem_result()
6196 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
6197 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
6198 
    result.write(oprot)
6199 
    oprot.writeMessageEnd()
6200 
    oprot.trans.flush()
6201 
 
6531 vikram.rag 6202 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
6203 
    args = getAllIgnoredInventoryUpdateItemsList_args()
6204 
    args.read(iprot)
6205 
    iprot.readMessageEnd()
6206 
    result = getAllIgnoredInventoryUpdateItemsList_result()
6207 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
6208 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
6209 
    result.write(oprot)
6210 
    oprot.writeMessageEnd()
6211 
    oprot.trans.flush()
6039 amit.gupta 6212 
 
6821 amar.kumar 6213 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
6214 
    args = getAllAliveItems_args()
6215 
    args.read(iprot)
6216 
    iprot.readMessageEnd()
6217 
    result = getAllAliveItems_result()
6218 
    result.success = self._handler.getAllAliveItems()
6219 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
6220 
    result.write(oprot)
6221 
    oprot.writeMessageEnd()
6222 
    oprot.trans.flush()
6223 
 
6805 anupam.sin 6224 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
6225 
    args = getInsuranceAmount_args()
6226 
    args.read(iprot)
6227 
    iprot.readMessageEnd()
6228 
    result = getInsuranceAmount_result()
6921 anupam.sin 6229 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 6230 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
6231 
    result.write(oprot)
6232 
    oprot.writeMessageEnd()
6233 
    oprot.trans.flush()
6531 vikram.rag 6234 
 
6805 anupam.sin 6235 
  def process_getInsurer(self, seqid, iprot, oprot):
6236 
    args = getInsurer_args()
6237 
    args.read(iprot)
6238 
    iprot.readMessageEnd()
6239 
    result = getInsurer_result()
6240 
    result.success = self._handler.getInsurer(args.insurerId)
6241 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
6242 
    result.write(oprot)
6243 
    oprot.writeMessageEnd()
6244 
    oprot.trans.flush()
6245 
 
6838 vikram.rag 6246 
  def process_getAllInsurers(self, seqid, iprot, oprot):
6247 
    args = getAllInsurers_args()
6248 
    args.read(iprot)
6249 
    iprot.readMessageEnd()
6250 
    result = getAllInsurers_result()
6251 
    result.success = self._handler.getAllInsurers()
6252 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
6253 
    result.write(oprot)
6254 
    oprot.writeMessageEnd()
6255 
    oprot.trans.flush()
6805 anupam.sin 6256 
 
6962 rajveer 6257 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6258 
    args = updateInsuranceDeclaredAmount_args()
6259 
    args.read(iprot)
6260 
    iprot.readMessageEnd()
6261 
    result = updateInsuranceDeclaredAmount_result()
6262 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6263 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6264 
    result.write(oprot)
6265 
    oprot.writeMessageEnd()
6266 
    oprot.trans.flush()
6838 vikram.rag 6267 
 
7190 amar.kumar 6268 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6269 
    args = getFreebieForItem_args()
6270 
    args.read(iprot)
6271 
    iprot.readMessageEnd()
6272 
    result = getFreebieForItem_result()
6273 
    result.success = self._handler.getFreebieForItem(args.itemId)
6274 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6275 
    result.write(oprot)
6276 
    oprot.writeMessageEnd()
6277 
    oprot.trans.flush()
6962 rajveer 6278 
 
7190 amar.kumar 6279 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6280 
    args = addOrUpdateFreebieForItem_args()
6281 
    args.read(iprot)
6282 
    iprot.readMessageEnd()
6283 
    result = addOrUpdateFreebieForItem_result()
6284 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6285 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6286 
    result.write(oprot)
6287 
    oprot.writeMessageEnd()
6288 
    oprot.trans.flush()
6289 
 
7272 amit.gupta 6290 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6291 
    args = addOrUpdateBrandInfo_args()
6292 
    args.read(iprot)
6293 
    iprot.readMessageEnd()
6294 
    result = addOrUpdateBrandInfo_result()
6295 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6296 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6297 
    result.write(oprot)
6298 
    oprot.writeMessageEnd()
6299 
    oprot.trans.flush()
6300 
 
6301 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6302 
    args = getBrandInfo_args()
6303 
    args.read(iprot)
6304 
    iprot.readMessageEnd()
6305 
    result = getBrandInfo_result()
6306 
    result.success = self._handler.getBrandInfo()
6307 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6308 
    result.write(oprot)
6309 
    oprot.writeMessageEnd()
6310 
    oprot.trans.flush()
6311 
 
7256 rajveer 6312 
  def process_getStorePricing(self, seqid, iprot, oprot):
6313 
    args = getStorePricing_args()
6314 
    args.read(iprot)
6315 
    iprot.readMessageEnd()
6316 
    result = getStorePricing_result()
6317 
    result.success = self._handler.getStorePricing(args.itemId)
6318 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6319 
    result.write(oprot)
6320 
    oprot.writeMessageEnd()
6321 
    oprot.trans.flush()
7190 amar.kumar 6322 
 
7306 rajveer 6323 
  def process_getStorePricings(self, seqid, iprot, oprot):
6324 
    args = getStorePricings_args()
6325 
    args.read(iprot)
6326 
    iprot.readMessageEnd()
6327 
    result = getStorePricings_result()
6328 
    result.success = self._handler.getStorePricings(args.itemIds)
6329 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6330 
    result.write(oprot)
6331 
    oprot.writeMessageEnd()
6332 
    oprot.trans.flush()
6333 
 
7265 rajveer 6334 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6335 
    args = updateStorePricing_args()
6336 
    args.read(iprot)
6337 
    iprot.readMessageEnd()
6338 
    result = updateStorePricing_result()
7382 rajveer 6339 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6340 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6341 
    result.write(oprot)
6342 
    oprot.writeMessageEnd()
6343 
    oprot.trans.flush()
7256 rajveer 6344 
 
7281 kshitij.so 6345 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6346 
    args = getAllAmazonListedItems_args()
6347 
    args.read(iprot)
6348 
    iprot.readMessageEnd()
6349 
    result = getAllAmazonListedItems_result()
6350 
    result.success = self._handler.getAllAmazonListedItems()
6351 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6352 
    result.write(oprot)
6353 
    oprot.writeMessageEnd()
6354 
    oprot.trans.flush()
7265 rajveer 6355 
 
8619 kshitij.so 6356 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6357 
    args = searchAmazonItems_args()
6358 
    args.read(iprot)
6359 
    iprot.readMessageEnd()
6360 
    result = searchAmazonItems_result()
6361 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6362 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6363 
    result.write(oprot)
6364 
    oprot.writeMessageEnd()
6365 
    oprot.trans.flush()
6366 
 
6367 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6368 
    args = getAmazonSearchResultCount_args()
6369 
    args.read(iprot)
6370 
    iprot.readMessageEnd()
6371 
    result = getAmazonSearchResultCount_result()
6372 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6373 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6374 
    result.write(oprot)
6375 
    oprot.writeMessageEnd()
6376 
    oprot.trans.flush()
6377 
 
6378 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6379 
    args = getCountForAmazonlistedItems_args()
6380 
    args.read(iprot)
6381 
    iprot.readMessageEnd()
6382 
    result = getCountForAmazonlistedItems_result()
6383 
    result.success = self._handler.getCountForAmazonlistedItems()
6384 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6385 
    result.write(oprot)
6386 
    oprot.writeMessageEnd()
6387 
    oprot.trans.flush()
6388 
 
7281 kshitij.so 6389 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6390 
    args = getAmazonItemDetails_args()
6391 
    args.read(iprot)
6392 
    iprot.readMessageEnd()
6393 
    result = getAmazonItemDetails_result()
6394 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6395 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6396 
    result.write(oprot)
6397 
    oprot.writeMessageEnd()
6398 
    oprot.trans.flush()
6399 
 
6400 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6401 
    args = updateAmazonItemDetails_args()
6402 
    args.read(iprot)
6403 
    iprot.readMessageEnd()
6404 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6405 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6406 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6407 
    result.write(oprot)
6408 
    oprot.writeMessageEnd()
6409 
    oprot.trans.flush()
6410 
 
6411 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6412 
    args = addAmazonItem_args()
6413 
    args.read(iprot)
6414 
    iprot.readMessageEnd()
6415 
    result = addAmazonItem_result()
6416 
    self._handler.addAmazonItem(args.amazonlisted)
6417 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6418 
    result.write(oprot)
6419 
    oprot.writeMessageEnd()
6420 
    oprot.trans.flush()
6421 
 
7291 vikram.rag 6422 
  def process_getAsinItems(self, seqid, iprot, oprot):
6423 
    args = getAsinItems_args()
6424 
    args.read(iprot)
6425 
    iprot.readMessageEnd()
6426 
    result = getAsinItems_result()
6427 
    result.success = self._handler.getAsinItems()
6428 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6429 
    result.write(oprot)
6430 
    oprot.writeMessageEnd()
6431 
    oprot.trans.flush()
7281 kshitij.so 6432 
 
7291 vikram.rag 6433 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6434 
    args = getAllFbaListedItems_args()
6435 
    args.read(iprot)
6436 
    iprot.readMessageEnd()
6437 
    result = getAllFbaListedItems_result()
6438 
    result.success = self._handler.getAllFbaListedItems()
6439 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6440 
    result.write(oprot)
6441 
    oprot.writeMessageEnd()
6442 
    oprot.trans.flush()
6443 
 
6444 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6445 
    args = getAllNonFbaListedItems_args()
6446 
    args.read(iprot)
6447 
    iprot.readMessageEnd()
6448 
    result = getAllNonFbaListedItems_result()
6449 
    result.success = self._handler.getAllNonFbaListedItems()
6450 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6451 
    result.write(oprot)
6452 
    oprot.writeMessageEnd()
6453 
    oprot.trans.flush()
6454 
 
7460 kshitij.so 6455 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6456 
    args = updateItemInventory_args()
6457 
    args.read(iprot)
6458 
    iprot.readMessageEnd()
6459 
    result = updateItemInventory_result()
6460 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6461 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6462 
    result.write(oprot)
6463 
    oprot.writeMessageEnd()
6464 
    oprot.trans.flush()
7291 vikram.rag 6465 
 
7770 kshitij.so 6466 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6467 
    args = updateTimestampForAmazonFeeds_args()
6468 
    args.read(iprot)
6469 
    iprot.readMessageEnd()
6470 
    result = updateTimestampForAmazonFeeds_result()
6471 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6472 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6473 
    result.write(oprot)
6474 
    oprot.writeMessageEnd()
6475 
    oprot.trans.flush()
7460 kshitij.so 6476 
 
7897 amar.kumar 6477 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6478 
    args = getAllParentCategories_args()
6479 
    args.read(iprot)
6480 
    iprot.readMessageEnd()
6481 
    result = getAllParentCategories_result()
6482 
    result.success = self._handler.getAllParentCategories()
6483 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6484 
    result.write(oprot)
6485 
    oprot.writeMessageEnd()
6486 
    oprot.trans.flush()
7770 kshitij.so 6487 
 
7977 kshitij.so 6488 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6489 
    args = addPageViewEvent_args()
6490 
    args.read(iprot)
6491 
    iprot.readMessageEnd()
6492 
    result = addPageViewEvent_result()
6493 
    self._handler.addPageViewEvent(args.pageViewEvents)
6494 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6495 
    result.write(oprot)
6496 
    oprot.writeMessageEnd()
6497 
    oprot.trans.flush()
7897 amar.kumar 6498 
 
7977 kshitij.so 6499 
  def process_addCartEvent(self, seqid, iprot, oprot):
6500 
    args = addCartEvent_args()
6501 
    args.read(iprot)
6502 
    iprot.readMessageEnd()
6503 
    result = addCartEvent_result()
6504 
    self._handler.addCartEvent(args.cartEvents)
6505 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6506 
    result.write(oprot)
6507 
    oprot.writeMessageEnd()
6508 
    oprot.trans.flush()
6509 
 
8182 amar.kumar 6510 
  def process_addEbayItem(self, seqid, iprot, oprot):
6511 
    args = addEbayItem_args()
6512 
    args.read(iprot)
6513 
    iprot.readMessageEnd()
6514 
    result = addEbayItem_result()
6515 
    self._handler.addEbayItem(args.ebayItem)
6516 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
6520 
 
6521 
  def process_getEbayItem(self, seqid, iprot, oprot):
6522 
    args = getEbayItem_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = getEbayItem_result()
6526 
    result.success = self._handler.getEbayItem(args.listingId)
6527 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6528 
    result.write(oprot)
6529 
    oprot.writeMessageEnd()
6530 
    oprot.trans.flush()
6531 
 
6532 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6533 
    args = updateEbayItem_args()
6534 
    args.read(iprot)
6535 
    iprot.readMessageEnd()
6536 
    result = updateEbayItem_result()
6537 
    self._handler.updateEbayItem(args.ebayItem)
6538 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6539 
    result.write(oprot)
6540 
    oprot.writeMessageEnd()
6541 
    oprot.trans.flush()
6542 
 
8139 kshitij.so 6543 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6544 
    args = getAmazonListedItems_args()
6545 
    args.read(iprot)
6546 
    iprot.readMessageEnd()
6547 
    result = getAmazonListedItems_result()
6548 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6549 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6550 
    result.write(oprot)
6551 
    oprot.writeMessageEnd()
6552 
    oprot.trans.flush()
7977 kshitij.so 6553 
 
8168 kshitij.so 6554 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6555 
    args = updateAmazonAttributesInBulk_args()
6556 
    args.read(iprot)
6557 
    iprot.readMessageEnd()
6558 
    result = updateAmazonAttributesInBulk_result()
6559 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6560 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6561 
    result.write(oprot)
6562 
    oprot.writeMessageEnd()
6563 
    oprot.trans.flush()
8139 kshitij.so 6564 
 
8379 vikram.rag 6565 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6566 
    args = getAllItemstoListOnFba_args()
6567 
    args.read(iprot)
6568 
    iprot.readMessageEnd()
6569 
    result = getAllItemstoListOnFba_result()
6570 
    result.success = self._handler.getAllItemstoListOnFba()
6571 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
8168 kshitij.so 6575 
 
8379 vikram.rag 6576 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6577 
    args = getAllItemstoListOnNonFba_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = getAllItemstoListOnNonFba_result()
6581 
    result.success = self._handler.getAllItemstoListOnNonFba()
6582 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
8619 kshitij.so 6587 
  def process_updateAsin(self, seqid, iprot, oprot):
6588 
    args = updateAsin_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = updateAsin_result()
6592 
    self._handler.updateAsin(args.item)
6593 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6594 
    result.write(oprot)
6595 
    oprot.writeMessageEnd()
6596 
    oprot.trans.flush()
8616 vikram.rag 6597 
 
8739 vikram.rag 6598 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
6599 
    args = addOrUpdateSnapdealItem_args()
6600 
    args.read(iprot)
6601 
    iprot.readMessageEnd()
6602 
    result = addOrUpdateSnapdealItem_result()
6603 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
6604 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
8619 kshitij.so 6608 
 
8739 vikram.rag 6609 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
6610 
    args = getSnapdealItem_args()
6611 
    args.read(iprot)
6612 
    iprot.readMessageEnd()
6613 
    result = getSnapdealItem_result()
6614 
    result.success = self._handler.getSnapdealItem(args.item_id)
6615 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
6616 
    result.write(oprot)
6617 
    oprot.writeMessageEnd()
6618 
    oprot.trans.flush()
6619 
 
9242 kshitij.so 6620 
  def process_getSnapdealItemDetails(self, seqid, iprot, oprot):
6621 
    args = getSnapdealItemDetails_args()
6622 
    args.read(iprot)
6623 
    iprot.readMessageEnd()
6624 
    result = getSnapdealItemDetails_result()
6625 
    result.success = self._handler.getSnapdealItemDetails(args.item_id)
6626 
    oprot.writeMessageBegin("getSnapdealItemDetails", TMessageType.REPLY, seqid)
6627 
    result.write(oprot)
6628 
    oprot.writeMessageEnd()
6629 
    oprot.trans.flush()
6630 
 
8739 vikram.rag 6631 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
6632 
    args = getAllSnapdealItems_args()
6633 
    args.read(iprot)
6634 
    iprot.readMessageEnd()
6635 
    result = getAllSnapdealItems_result()
6636 
    result.success = self._handler.getAllSnapdealItems()
6637 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
6638 
    result.write(oprot)
6639 
    oprot.writeMessageEnd()
6640 
    oprot.trans.flush()
6641 
 
9242 kshitij.so 6642 
  def process_getSnapdealItems(self, seqid, iprot, oprot):
6643 
    args = getSnapdealItems_args()
6644 
    args.read(iprot)
6645 
    iprot.readMessageEnd()
6646 
    result = getSnapdealItems_result()
6647 
    result.success = self._handler.getSnapdealItems(args.offset, args.limit)
6648 
    oprot.writeMessageBegin("getSnapdealItems", TMessageType.REPLY, seqid)
6649 
    result.write(oprot)
6650 
    oprot.writeMessageEnd()
6651 
    oprot.trans.flush()
8739 vikram.rag 6652 
 
9242 kshitij.so 6653 
  def process_searchSnapdealItems(self, seqid, iprot, oprot):
6654 
    args = searchSnapdealItems_args()
6655 
    args.read(iprot)
6656 
    iprot.readMessageEnd()
6657 
    result = searchSnapdealItems_result()
6658 
    result.success = self._handler.searchSnapdealItems(args.searchTerm, args.offset, args.limit)
6659 
    oprot.writeMessageBegin("searchSnapdealItems", TMessageType.REPLY, seqid)
6660 
    result.write(oprot)
6661 
    oprot.writeMessageEnd()
6662 
    oprot.trans.flush()
6663 
 
6664 
  def process_getCountForSnapdealItems(self, seqid, iprot, oprot):
6665 
    args = getCountForSnapdealItems_args()
6666 
    args.read(iprot)
6667 
    iprot.readMessageEnd()
6668 
    result = getCountForSnapdealItems_result()
6669 
    result.success = self._handler.getCountForSnapdealItems()
6670 
    oprot.writeMessageBegin("getCountForSnapdealItems", TMessageType.REPLY, seqid)
6671 
    result.write(oprot)
6672 
    oprot.writeMessageEnd()
6673 
    oprot.trans.flush()
6674 
 
6675 
  def process_getSnapdealSearchResultCount(self, seqid, iprot, oprot):
6676 
    args = getSnapdealSearchResultCount_args()
6677 
    args.read(iprot)
6678 
    iprot.readMessageEnd()
6679 
    result = getSnapdealSearchResultCount_result()
6680 
    result.success = self._handler.getSnapdealSearchResultCount(args.searchTerm)
6681 
    oprot.writeMessageBegin("getSnapdealSearchResultCount", TMessageType.REPLY, seqid)
6682 
    result.write(oprot)
6683 
    oprot.writeMessageEnd()
6684 
    oprot.trans.flush()
6685 
 
9299 kshitij.so 6686 
  def process_getPrefferedInsurerForItem(self, seqid, iprot, oprot):
6687 
    args = getPrefferedInsurerForItem_args()
6688 
    args.read(iprot)
6689 
    iprot.readMessageEnd()
6690 
    result = getPrefferedInsurerForItem_result()
6691 
    result.success = self._handler.getPrefferedInsurerForItem(args.itemId, args.insurerType)
6692 
    oprot.writeMessageBegin("getPrefferedInsurerForItem", TMessageType.REPLY, seqid)
6693 
    result.write(oprot)
6694 
    oprot.writeMessageEnd()
6695 
    oprot.trans.flush()
9242 kshitij.so 6696 
 
9299 kshitij.so 6697 
 
5944 mandeep.dh 6698 
# HELPER FUNCTIONS AND STRUCTURES
6699 
 
6700 
class addItem_args:
6701 
  """
6702 
  Attributes:
6703 
   - item
6704 
  """
6705 
 
6706 
  thrift_spec = (
6707 
    None, # 0
6708 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6709 
  )
6710 
 
6711 
  def __init__(self, item=None,):
6712 
    self.item = item
6713 
 
6714 
  def read(self, iprot):
6715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6717 
      return
6718 
    iprot.readStructBegin()
6719 
    while True:
6720 
      (fname, ftype, fid) = iprot.readFieldBegin()
6721 
      if ftype == TType.STOP:
6722 
        break
6723 
      if fid == 1:
6724 
        if ftype == TType.STRUCT:
6725 
          self.item = Item()
6726 
          self.item.read(iprot)
6727 
        else:
6728 
          iprot.skip(ftype)
6729 
      else:
6730 
        iprot.skip(ftype)
6731 
      iprot.readFieldEnd()
6732 
    iprot.readStructEnd()
6733 
 
6734 
  def write(self, oprot):
6735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6737 
      return
6738 
    oprot.writeStructBegin('addItem_args')
6739 
    if self.item is not None:
6740 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6741 
      self.item.write(oprot)
6742 
      oprot.writeFieldEnd()
6743 
    oprot.writeFieldStop()
6744 
    oprot.writeStructEnd()
6745 
 
6746 
  def validate(self):
6747 
    return
6748 
 
6749 
 
6750 
  def __repr__(self):
6751 
    L = ['%s=%r' % (key, value)
6752 
      for key, value in self.__dict__.iteritems()]
6753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6754 
 
6755 
  def __eq__(self, other):
6756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6757 
 
6758 
  def __ne__(self, other):
6759 
    return not (self == other)
6760 
 
6761 
class addItem_result:
6762 
  """
6763 
  Attributes:
6764 
   - success
6765 
   - cex
6766 
  """
6767 
 
6768 
  thrift_spec = (
6769 
    (0, TType.I64, 'success', None, None, ), # 0
6770 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6771 
  )
6772 
 
6773 
  def __init__(self, success=None, cex=None,):
6774 
    self.success = success
6775 
    self.cex = cex
6776 
 
6777 
  def read(self, iprot):
6778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6780 
      return
6781 
    iprot.readStructBegin()
6782 
    while True:
6783 
      (fname, ftype, fid) = iprot.readFieldBegin()
6784 
      if ftype == TType.STOP:
6785 
        break
6786 
      if fid == 0:
6787 
        if ftype == TType.I64:
6788 
          self.success = iprot.readI64();
6789 
        else:
6790 
          iprot.skip(ftype)
6791 
      elif fid == 1:
6792 
        if ftype == TType.STRUCT:
6793 
          self.cex = CatalogServiceException()
6794 
          self.cex.read(iprot)
6795 
        else:
6796 
          iprot.skip(ftype)
6797 
      else:
6798 
        iprot.skip(ftype)
6799 
      iprot.readFieldEnd()
6800 
    iprot.readStructEnd()
6801 
 
6802 
  def write(self, oprot):
6803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6805 
      return
6806 
    oprot.writeStructBegin('addItem_result')
6807 
    if self.success is not None:
6808 
      oprot.writeFieldBegin('success', TType.I64, 0)
6809 
      oprot.writeI64(self.success)
6810 
      oprot.writeFieldEnd()
6811 
    if self.cex is not None:
6812 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6813 
      self.cex.write(oprot)
6814 
      oprot.writeFieldEnd()
6815 
    oprot.writeFieldStop()
6816 
    oprot.writeStructEnd()
6817 
 
6818 
  def validate(self):
6819 
    return
6820 
 
6821 
 
6822 
  def __repr__(self):
6823 
    L = ['%s=%r' % (key, value)
6824 
      for key, value in self.__dict__.iteritems()]
6825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6826 
 
6827 
  def __eq__(self, other):
6828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6829 
 
6830 
  def __ne__(self, other):
6831 
    return not (self == other)
6832 
 
6833 
class updateItem_args:
6834 
  """
6835 
  Attributes:
6836 
   - item
6837 
  """
6838 
 
6839 
  thrift_spec = (
6840 
    None, # 0
6841 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6842 
  )
6843 
 
6844 
  def __init__(self, item=None,):
6845 
    self.item = item
6846 
 
6847 
  def read(self, iprot):
6848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6850 
      return
6851 
    iprot.readStructBegin()
6852 
    while True:
6853 
      (fname, ftype, fid) = iprot.readFieldBegin()
6854 
      if ftype == TType.STOP:
6855 
        break
6856 
      if fid == 1:
6857 
        if ftype == TType.STRUCT:
6858 
          self.item = Item()
6859 
          self.item.read(iprot)
6860 
        else:
6861 
          iprot.skip(ftype)
6862 
      else:
6863 
        iprot.skip(ftype)
6864 
      iprot.readFieldEnd()
6865 
    iprot.readStructEnd()
6866 
 
6867 
  def write(self, oprot):
6868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6870 
      return
6871 
    oprot.writeStructBegin('updateItem_args')
6872 
    if self.item is not None:
6873 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6874 
      self.item.write(oprot)
6875 
      oprot.writeFieldEnd()
6876 
    oprot.writeFieldStop()
6877 
    oprot.writeStructEnd()
6878 
 
6879 
  def validate(self):
6880 
    return
6881 
 
6882 
 
6883 
  def __repr__(self):
6884 
    L = ['%s=%r' % (key, value)
6885 
      for key, value in self.__dict__.iteritems()]
6886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6887 
 
6888 
  def __eq__(self, other):
6889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6890 
 
6891 
  def __ne__(self, other):
6892 
    return not (self == other)
6893 
 
6894 
class updateItem_result:
6895 
  """
6896 
  Attributes:
6897 
   - success
6898 
   - cex
6899 
  """
6900 
 
6901 
  thrift_spec = (
6902 
    (0, TType.I64, 'success', None, None, ), # 0
6903 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6904 
  )
6905 
 
6906 
  def __init__(self, success=None, cex=None,):
6907 
    self.success = success
6908 
    self.cex = cex
6909 
 
6910 
  def read(self, iprot):
6911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6913 
      return
6914 
    iprot.readStructBegin()
6915 
    while True:
6916 
      (fname, ftype, fid) = iprot.readFieldBegin()
6917 
      if ftype == TType.STOP:
6918 
        break
6919 
      if fid == 0:
6920 
        if ftype == TType.I64:
6921 
          self.success = iprot.readI64();
6922 
        else:
6923 
          iprot.skip(ftype)
6924 
      elif fid == 1:
6925 
        if ftype == TType.STRUCT:
6926 
          self.cex = CatalogServiceException()
6927 
          self.cex.read(iprot)
6928 
        else:
6929 
          iprot.skip(ftype)
6930 
      else:
6931 
        iprot.skip(ftype)
6932 
      iprot.readFieldEnd()
6933 
    iprot.readStructEnd()
6934 
 
6935 
  def write(self, oprot):
6936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6938 
      return
6939 
    oprot.writeStructBegin('updateItem_result')
6940 
    if self.success is not None:
6941 
      oprot.writeFieldBegin('success', TType.I64, 0)
6942 
      oprot.writeI64(self.success)
6943 
      oprot.writeFieldEnd()
6944 
    if self.cex is not None:
6945 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6946 
      self.cex.write(oprot)
6947 
      oprot.writeFieldEnd()
6948 
    oprot.writeFieldStop()
6949 
    oprot.writeStructEnd()
6950 
 
6951 
  def validate(self):
6952 
    return
6953 
 
6954 
 
6955 
  def __repr__(self):
6956 
    L = ['%s=%r' % (key, value)
6957 
      for key, value in self.__dict__.iteritems()]
6958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6959 
 
6960 
  def __eq__(self, other):
6961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6962 
 
6963 
  def __ne__(self, other):
6964 
    return not (self == other)
6965 
 
6966 
class isActive_args:
6967 
  """
6968 
  Attributes:
6969 
   - itemId
6970 
  """
6971 
 
6972 
  thrift_spec = (
6973 
    None, # 0
6974 
    (1, TType.I64, 'itemId', None, None, ), # 1
6975 
  )
6976 
 
6977 
  def __init__(self, itemId=None,):
6978 
    self.itemId = itemId
6979 
 
6980 
  def read(self, iprot):
6981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6983 
      return
6984 
    iprot.readStructBegin()
6985 
    while True:
6986 
      (fname, ftype, fid) = iprot.readFieldBegin()
6987 
      if ftype == TType.STOP:
6988 
        break
6989 
      if fid == 1:
6990 
        if ftype == TType.I64:
6991 
          self.itemId = iprot.readI64();
6992 
        else:
6993 
          iprot.skip(ftype)
6994 
      else:
6995 
        iprot.skip(ftype)
6996 
      iprot.readFieldEnd()
6997 
    iprot.readStructEnd()
6998 
 
6999 
  def write(self, oprot):
7000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7002 
      return
7003 
    oprot.writeStructBegin('isActive_args')
7004 
    if self.itemId is not None:
7005 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7006 
      oprot.writeI64(self.itemId)
7007 
      oprot.writeFieldEnd()
7008 
    oprot.writeFieldStop()
7009 
    oprot.writeStructEnd()
7010 
 
7011 
  def validate(self):
7012 
    return
7013 
 
7014 
 
7015 
  def __repr__(self):
7016 
    L = ['%s=%r' % (key, value)
7017 
      for key, value in self.__dict__.iteritems()]
7018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7019 
 
7020 
  def __eq__(self, other):
7021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7022 
 
7023 
  def __ne__(self, other):
7024 
    return not (self == other)
7025 
 
7026 
class isActive_result:
7027 
  """
7028 
  Attributes:
7029 
   - success
7030 
   - isex
7031 
  """
7032 
 
7033 
  thrift_spec = (
7034 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
7035 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7036 
  )
7037 
 
7038 
  def __init__(self, success=None, isex=None,):
7039 
    self.success = success
7040 
    self.isex = isex
7041 
 
7042 
  def read(self, iprot):
7043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7045 
      return
7046 
    iprot.readStructBegin()
7047 
    while True:
7048 
      (fname, ftype, fid) = iprot.readFieldBegin()
7049 
      if ftype == TType.STOP:
7050 
        break
7051 
      if fid == 0:
7052 
        if ftype == TType.STRUCT:
7053 
          self.success = ItemShippingInfo()
7054 
          self.success.read(iprot)
7055 
        else:
7056 
          iprot.skip(ftype)
7057 
      elif fid == 1:
7058 
        if ftype == TType.STRUCT:
7059 
          self.isex = CatalogServiceException()
7060 
          self.isex.read(iprot)
7061 
        else:
7062 
          iprot.skip(ftype)
7063 
      else:
7064 
        iprot.skip(ftype)
7065 
      iprot.readFieldEnd()
7066 
    iprot.readStructEnd()
7067 
 
7068 
  def write(self, oprot):
7069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7071 
      return
7072 
    oprot.writeStructBegin('isActive_result')
7073 
    if self.success is not None:
7074 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7075 
      self.success.write(oprot)
7076 
      oprot.writeFieldEnd()
7077 
    if self.isex is not None:
7078 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7079 
      self.isex.write(oprot)
7080 
      oprot.writeFieldEnd()
7081 
    oprot.writeFieldStop()
7082 
    oprot.writeStructEnd()
7083 
 
7084 
  def validate(self):
7085 
    return
7086 
 
7087 
 
7088 
  def __repr__(self):
7089 
    L = ['%s=%r' % (key, value)
7090 
      for key, value in self.__dict__.iteritems()]
7091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7092 
 
7093 
  def __eq__(self, other):
7094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7095 
 
7096 
  def __ne__(self, other):
7097 
    return not (self == other)
7098 
 
7438 amit.gupta 7099 
class getItemsStatus_args:
7100 
  """
7101 
  Attributes:
7102 
   - itemIds
7103 
  """
7104 
 
7105 
  thrift_spec = (
7106 
    None, # 0
7107 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
7108 
  )
7109 
 
7110 
  def __init__(self, itemIds=None,):
7111 
    self.itemIds = itemIds
7112 
 
7113 
  def read(self, iprot):
7114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7116 
      return
7117 
    iprot.readStructBegin()
7118 
    while True:
7119 
      (fname, ftype, fid) = iprot.readFieldBegin()
7120 
      if ftype == TType.STOP:
7121 
        break
7122 
      if fid == 1:
7123 
        if ftype == TType.LIST:
7124 
          self.itemIds = []
8590 kshitij.so 7125 
          (_etype33, _size30) = iprot.readListBegin()
7126 
          for _i34 in xrange(_size30):
7127 
            _elem35 = iprot.readI64();
7128 
            self.itemIds.append(_elem35)
7438 amit.gupta 7129 
          iprot.readListEnd()
7130 
        else:
7131 
          iprot.skip(ftype)
7132 
      else:
7133 
        iprot.skip(ftype)
7134 
      iprot.readFieldEnd()
7135 
    iprot.readStructEnd()
7136 
 
7137 
  def write(self, oprot):
7138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7140 
      return
7141 
    oprot.writeStructBegin('getItemsStatus_args')
7142 
    if self.itemIds is not None:
7143 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
7144 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 7145 
      for iter36 in self.itemIds:
7146 
        oprot.writeI64(iter36)
7438 amit.gupta 7147 
      oprot.writeListEnd()
7148 
      oprot.writeFieldEnd()
7149 
    oprot.writeFieldStop()
7150 
    oprot.writeStructEnd()
7151 
 
7152 
  def validate(self):
7153 
    return
7154 
 
7155 
 
7156 
  def __repr__(self):
7157 
    L = ['%s=%r' % (key, value)
7158 
      for key, value in self.__dict__.iteritems()]
7159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7160 
 
7161 
  def __eq__(self, other):
7162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7163 
 
7164 
  def __ne__(self, other):
7165 
    return not (self == other)
7166 
 
7167 
class getItemsStatus_result:
7168 
  """
7169 
  Attributes:
7170 
   - success
7171 
   - isex
7172 
  """
7173 
 
7174 
  thrift_spec = (
7175 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
7176 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7177 
  )
7178 
 
7179 
  def __init__(self, success=None, isex=None,):
7180 
    self.success = success
7181 
    self.isex = isex
7182 
 
7183 
  def read(self, iprot):
7184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7186 
      return
7187 
    iprot.readStructBegin()
7188 
    while True:
7189 
      (fname, ftype, fid) = iprot.readFieldBegin()
7190 
      if ftype == TType.STOP:
7191 
        break
7192 
      if fid == 0:
7193 
        if ftype == TType.MAP:
7194 
          self.success = {}
8590 kshitij.so 7195 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
7196 
          for _i41 in xrange(_size37):
7197 
            _key42 = iprot.readI64();
7198 
            _val43 = iprot.readBool();
7199 
            self.success[_key42] = _val43
7438 amit.gupta 7200 
          iprot.readMapEnd()
7201 
        else:
7202 
          iprot.skip(ftype)
7203 
      elif fid == 1:
7204 
        if ftype == TType.STRUCT:
7205 
          self.isex = CatalogServiceException()
7206 
          self.isex.read(iprot)
7207 
        else:
7208 
          iprot.skip(ftype)
7209 
      else:
7210 
        iprot.skip(ftype)
7211 
      iprot.readFieldEnd()
7212 
    iprot.readStructEnd()
7213 
 
7214 
  def write(self, oprot):
7215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7217 
      return
7218 
    oprot.writeStructBegin('getItemsStatus_result')
7219 
    if self.success is not None:
7220 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7221 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 7222 
      for kiter44,viter45 in self.success.items():
7223 
        oprot.writeI64(kiter44)
7224 
        oprot.writeBool(viter45)
7438 amit.gupta 7225 
      oprot.writeMapEnd()
7226 
      oprot.writeFieldEnd()
7227 
    if self.isex is not None:
7228 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7229 
      self.isex.write(oprot)
7230 
      oprot.writeFieldEnd()
7231 
    oprot.writeFieldStop()
7232 
    oprot.writeStructEnd()
7233 
 
7234 
  def validate(self):
7235 
    return
7236 
 
7237 
 
7238 
  def __repr__(self):
7239 
    L = ['%s=%r' % (key, value)
7240 
      for key, value in self.__dict__.iteritems()]
7241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7242 
 
7243 
  def __eq__(self, other):
7244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7245 
 
7246 
  def __ne__(self, other):
7247 
    return not (self == other)
7248 
 
5944 mandeep.dh 7249 
class getItemStatusDescription_args:
7250 
  """
7251 
  Attributes:
7252 
   - itemId
7253 
  """
7254 
 
7255 
  thrift_spec = (
7256 
    None, # 0
7257 
    (1, TType.I64, 'itemId', None, None, ), # 1
7258 
  )
7259 
 
7260 
  def __init__(self, itemId=None,):
7261 
    self.itemId = itemId
7262 
 
7263 
  def read(self, iprot):
7264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7266 
      return
7267 
    iprot.readStructBegin()
7268 
    while True:
7269 
      (fname, ftype, fid) = iprot.readFieldBegin()
7270 
      if ftype == TType.STOP:
7271 
        break
7272 
      if fid == 1:
7273 
        if ftype == TType.I64:
7274 
          self.itemId = iprot.readI64();
7275 
        else:
7276 
          iprot.skip(ftype)
7277 
      else:
7278 
        iprot.skip(ftype)
7279 
      iprot.readFieldEnd()
7280 
    iprot.readStructEnd()
7281 
 
7282 
  def write(self, oprot):
7283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7285 
      return
7286 
    oprot.writeStructBegin('getItemStatusDescription_args')
7287 
    if self.itemId is not None:
7288 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7289 
      oprot.writeI64(self.itemId)
7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
7294 
  def validate(self):
7295 
    return
7296 
 
7297 
 
7298 
  def __repr__(self):
7299 
    L = ['%s=%r' % (key, value)
7300 
      for key, value in self.__dict__.iteritems()]
7301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7302 
 
7303 
  def __eq__(self, other):
7304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7305 
 
7306 
  def __ne__(self, other):
7307 
    return not (self == other)
7308 
 
7309 
class getItemStatusDescription_result:
7310 
  """
7311 
  Attributes:
7312 
   - success
7313 
   - isex
7314 
  """
7315 
 
7316 
  thrift_spec = (
7317 
    (0, TType.STRING, 'success', None, None, ), # 0
7318 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7319 
  )
7320 
 
7321 
  def __init__(self, success=None, isex=None,):
7322 
    self.success = success
7323 
    self.isex = isex
7324 
 
7325 
  def read(self, iprot):
7326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7328 
      return
7329 
    iprot.readStructBegin()
7330 
    while True:
7331 
      (fname, ftype, fid) = iprot.readFieldBegin()
7332 
      if ftype == TType.STOP:
7333 
        break
7334 
      if fid == 0:
7335 
        if ftype == TType.STRING:
7336 
          self.success = iprot.readString();
7337 
        else:
7338 
          iprot.skip(ftype)
7339 
      elif fid == 1:
7340 
        if ftype == TType.STRUCT:
7341 
          self.isex = CatalogServiceException()
7342 
          self.isex.read(iprot)
7343 
        else:
7344 
          iprot.skip(ftype)
7345 
      else:
7346 
        iprot.skip(ftype)
7347 
      iprot.readFieldEnd()
7348 
    iprot.readStructEnd()
7349 
 
7350 
  def write(self, oprot):
7351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7353 
      return
7354 
    oprot.writeStructBegin('getItemStatusDescription_result')
7355 
    if self.success is not None:
7356 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7357 
      oprot.writeString(self.success)
7358 
      oprot.writeFieldEnd()
7359 
    if self.isex is not None:
7360 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7361 
      self.isex.write(oprot)
7362 
      oprot.writeFieldEnd()
7363 
    oprot.writeFieldStop()
7364 
    oprot.writeStructEnd()
7365 
 
7366 
  def validate(self):
7367 
    return
7368 
 
7369 
 
7370 
  def __repr__(self):
7371 
    L = ['%s=%r' % (key, value)
7372 
      for key, value in self.__dict__.iteritems()]
7373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7374 
 
7375 
  def __eq__(self, other):
7376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7377 
 
7378 
  def __ne__(self, other):
7379 
    return not (self == other)
7380 
 
7381 
class startItemOn_args:
7382 
  """
7383 
  Attributes:
7384 
   - item_id
7385 
   - timestamp
7386 
  """
7387 
 
7388 
  thrift_spec = (
7389 
    None, # 0
7390 
    (1, TType.I64, 'item_id', None, None, ), # 1
7391 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7392 
  )
7393 
 
7394 
  def __init__(self, item_id=None, timestamp=None,):
7395 
    self.item_id = item_id
7396 
    self.timestamp = timestamp
7397 
 
7398 
  def read(self, iprot):
7399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7401 
      return
7402 
    iprot.readStructBegin()
7403 
    while True:
7404 
      (fname, ftype, fid) = iprot.readFieldBegin()
7405 
      if ftype == TType.STOP:
7406 
        break
7407 
      if fid == 1:
7408 
        if ftype == TType.I64:
7409 
          self.item_id = iprot.readI64();
7410 
        else:
7411 
          iprot.skip(ftype)
7412 
      elif fid == 2:
7413 
        if ftype == TType.I64:
7414 
          self.timestamp = iprot.readI64();
7415 
        else:
7416 
          iprot.skip(ftype)
7417 
      else:
7418 
        iprot.skip(ftype)
7419 
      iprot.readFieldEnd()
7420 
    iprot.readStructEnd()
7421 
 
7422 
  def write(self, oprot):
7423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7425 
      return
7426 
    oprot.writeStructBegin('startItemOn_args')
7427 
    if self.item_id is not None:
7428 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7429 
      oprot.writeI64(self.item_id)
7430 
      oprot.writeFieldEnd()
7431 
    if self.timestamp is not None:
7432 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7433 
      oprot.writeI64(self.timestamp)
7434 
      oprot.writeFieldEnd()
7435 
    oprot.writeFieldStop()
7436 
    oprot.writeStructEnd()
7437 
 
7438 
  def validate(self):
7439 
    return
7440 
 
7441 
 
7442 
  def __repr__(self):
7443 
    L = ['%s=%r' % (key, value)
7444 
      for key, value in self.__dict__.iteritems()]
7445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7446 
 
7447 
  def __eq__(self, other):
7448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7449 
 
7450 
  def __ne__(self, other):
7451 
    return not (self == other)
7452 
 
7453 
class startItemOn_result:
7454 
  """
7455 
  Attributes:
7456 
   - cex
7457 
  """
7458 
 
7459 
  thrift_spec = (
7460 
    None, # 0
7461 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7462 
  )
7463 
 
7464 
  def __init__(self, cex=None,):
7465 
    self.cex = cex
7466 
 
7467 
  def read(self, iprot):
7468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7470 
      return
7471 
    iprot.readStructBegin()
7472 
    while True:
7473 
      (fname, ftype, fid) = iprot.readFieldBegin()
7474 
      if ftype == TType.STOP:
7475 
        break
7476 
      if fid == 1:
7477 
        if ftype == TType.STRUCT:
7478 
          self.cex = CatalogServiceException()
7479 
          self.cex.read(iprot)
7480 
        else:
7481 
          iprot.skip(ftype)
7482 
      else:
7483 
        iprot.skip(ftype)
7484 
      iprot.readFieldEnd()
7485 
    iprot.readStructEnd()
7486 
 
7487 
  def write(self, oprot):
7488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7490 
      return
7491 
    oprot.writeStructBegin('startItemOn_result')
7492 
    if self.cex is not None:
7493 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7494 
      self.cex.write(oprot)
7495 
      oprot.writeFieldEnd()
7496 
    oprot.writeFieldStop()
7497 
    oprot.writeStructEnd()
7498 
 
7499 
  def validate(self):
7500 
    return
7501 
 
7502 
 
7503 
  def __repr__(self):
7504 
    L = ['%s=%r' % (key, value)
7505 
      for key, value in self.__dict__.iteritems()]
7506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7507 
 
7508 
  def __eq__(self, other):
7509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7510 
 
7511 
  def __ne__(self, other):
7512 
    return not (self == other)
7513 
 
7514 
class retireItemOn_args:
7515 
  """
7516 
  Attributes:
7517 
   - item_id
7518 
   - timestamp
7519 
  """
7520 
 
7521 
  thrift_spec = (
7522 
    None, # 0
7523 
    (1, TType.I64, 'item_id', None, None, ), # 1
7524 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7525 
  )
7526 
 
7527 
  def __init__(self, item_id=None, timestamp=None,):
7528 
    self.item_id = item_id
7529 
    self.timestamp = timestamp
7530 
 
7531 
  def read(self, iprot):
7532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7534 
      return
7535 
    iprot.readStructBegin()
7536 
    while True:
7537 
      (fname, ftype, fid) = iprot.readFieldBegin()
7538 
      if ftype == TType.STOP:
7539 
        break
7540 
      if fid == 1:
7541 
        if ftype == TType.I64:
7542 
          self.item_id = iprot.readI64();
7543 
        else:
7544 
          iprot.skip(ftype)
7545 
      elif fid == 2:
7546 
        if ftype == TType.I64:
7547 
          self.timestamp = iprot.readI64();
7548 
        else:
7549 
          iprot.skip(ftype)
7550 
      else:
7551 
        iprot.skip(ftype)
7552 
      iprot.readFieldEnd()
7553 
    iprot.readStructEnd()
7554 
 
7555 
  def write(self, oprot):
7556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7558 
      return
7559 
    oprot.writeStructBegin('retireItemOn_args')
7560 
    if self.item_id is not None:
7561 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7562 
      oprot.writeI64(self.item_id)
7563 
      oprot.writeFieldEnd()
7564 
    if self.timestamp is not None:
7565 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7566 
      oprot.writeI64(self.timestamp)
7567 
      oprot.writeFieldEnd()
7568 
    oprot.writeFieldStop()
7569 
    oprot.writeStructEnd()
7570 
 
7571 
  def validate(self):
7572 
    return
7573 
 
7574 
 
7575 
  def __repr__(self):
7576 
    L = ['%s=%r' % (key, value)
7577 
      for key, value in self.__dict__.iteritems()]
7578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7579 
 
7580 
  def __eq__(self, other):
7581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7582 
 
7583 
  def __ne__(self, other):
7584 
    return not (self == other)
7585 
 
7586 
class retireItemOn_result:
7587 
  """
7588 
  Attributes:
7589 
   - cex
7590 
  """
7591 
 
7592 
  thrift_spec = (
7593 
    None, # 0
7594 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7595 
  )
7596 
 
7597 
  def __init__(self, cex=None,):
7598 
    self.cex = cex
7599 
 
7600 
  def read(self, iprot):
7601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7603 
      return
7604 
    iprot.readStructBegin()
7605 
    while True:
7606 
      (fname, ftype, fid) = iprot.readFieldBegin()
7607 
      if ftype == TType.STOP:
7608 
        break
7609 
      if fid == 1:
7610 
        if ftype == TType.STRUCT:
7611 
          self.cex = CatalogServiceException()
7612 
          self.cex.read(iprot)
7613 
        else:
7614 
          iprot.skip(ftype)
7615 
      else:
7616 
        iprot.skip(ftype)
7617 
      iprot.readFieldEnd()
7618 
    iprot.readStructEnd()
7619 
 
7620 
  def write(self, oprot):
7621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7623 
      return
7624 
    oprot.writeStructBegin('retireItemOn_result')
7625 
    if self.cex is not None:
7626 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7627 
      self.cex.write(oprot)
7628 
      oprot.writeFieldEnd()
7629 
    oprot.writeFieldStop()
7630 
    oprot.writeStructEnd()
7631 
 
7632 
  def validate(self):
7633 
    return
7634 
 
7635 
 
7636 
  def __repr__(self):
7637 
    L = ['%s=%r' % (key, value)
7638 
      for key, value in self.__dict__.iteritems()]
7639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7640 
 
7641 
  def __eq__(self, other):
7642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7643 
 
7644 
  def __ne__(self, other):
7645 
    return not (self == other)
7646 
 
7647 
class changeItemStatus_args:
7648 
  """
7649 
  Attributes:
7650 
   - item_id
7651 
   - timestamp
7652 
   - newstatus
7653 
  """
7654 
 
7655 
  thrift_spec = (
7656 
    None, # 0
7657 
    (1, TType.I64, 'item_id', None, None, ), # 1
7658 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7659 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7660 
  )
7661 
 
7662 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7663 
    self.item_id = item_id
7664 
    self.timestamp = timestamp
7665 
    self.newstatus = newstatus
7666 
 
7667 
  def read(self, iprot):
7668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7670 
      return
7671 
    iprot.readStructBegin()
7672 
    while True:
7673 
      (fname, ftype, fid) = iprot.readFieldBegin()
7674 
      if ftype == TType.STOP:
7675 
        break
7676 
      if fid == 1:
7677 
        if ftype == TType.I64:
7678 
          self.item_id = iprot.readI64();
7679 
        else:
7680 
          iprot.skip(ftype)
7681 
      elif fid == 2:
7682 
        if ftype == TType.I64:
7683 
          self.timestamp = iprot.readI64();
7684 
        else:
7685 
          iprot.skip(ftype)
7686 
      elif fid == 3:
7687 
        if ftype == TType.I32:
7688 
          self.newstatus = iprot.readI32();
7689 
        else:
7690 
          iprot.skip(ftype)
7691 
      else:
7692 
        iprot.skip(ftype)
7693 
      iprot.readFieldEnd()
7694 
    iprot.readStructEnd()
7695 
 
7696 
  def write(self, oprot):
7697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7699 
      return
7700 
    oprot.writeStructBegin('changeItemStatus_args')
7701 
    if self.item_id is not None:
7702 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7703 
      oprot.writeI64(self.item_id)
7704 
      oprot.writeFieldEnd()
7705 
    if self.timestamp is not None:
7706 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7707 
      oprot.writeI64(self.timestamp)
7708 
      oprot.writeFieldEnd()
7709 
    if self.newstatus is not None:
7710 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7711 
      oprot.writeI32(self.newstatus)
7712 
      oprot.writeFieldEnd()
7713 
    oprot.writeFieldStop()
7714 
    oprot.writeStructEnd()
7715 
 
7716 
  def validate(self):
7717 
    return
7718 
 
7719 
 
7720 
  def __repr__(self):
7721 
    L = ['%s=%r' % (key, value)
7722 
      for key, value in self.__dict__.iteritems()]
7723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7724 
 
7725 
  def __eq__(self, other):
7726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7727 
 
7728 
  def __ne__(self, other):
7729 
    return not (self == other)
7730 
 
7731 
class changeItemStatus_result:
7732 
  """
7733 
  Attributes:
7734 
   - cex
7735 
  """
7736 
 
7737 
  thrift_spec = (
7738 
    None, # 0
7739 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7740 
  )
7741 
 
7742 
  def __init__(self, cex=None,):
7743 
    self.cex = cex
7744 
 
7745 
  def read(self, iprot):
7746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7748 
      return
7749 
    iprot.readStructBegin()
7750 
    while True:
7751 
      (fname, ftype, fid) = iprot.readFieldBegin()
7752 
      if ftype == TType.STOP:
7753 
        break
7754 
      if fid == 1:
7755 
        if ftype == TType.STRUCT:
7756 
          self.cex = CatalogServiceException()
7757 
          self.cex.read(iprot)
7758 
        else:
7759 
          iprot.skip(ftype)
7760 
      else:
7761 
        iprot.skip(ftype)
7762 
      iprot.readFieldEnd()
7763 
    iprot.readStructEnd()
7764 
 
7765 
  def write(self, oprot):
7766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7768 
      return
7769 
    oprot.writeStructBegin('changeItemStatus_result')
7770 
    if self.cex is not None:
7771 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7772 
      self.cex.write(oprot)
7773 
      oprot.writeFieldEnd()
7774 
    oprot.writeFieldStop()
7775 
    oprot.writeStructEnd()
7776 
 
7777 
  def validate(self):
7778 
    return
7779 
 
7780 
 
7781 
  def __repr__(self):
7782 
    L = ['%s=%r' % (key, value)
7783 
      for key, value in self.__dict__.iteritems()]
7784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7785 
 
7786 
  def __eq__(self, other):
7787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7788 
 
7789 
  def __ne__(self, other):
7790 
    return not (self == other)
7791 
 
7792 
class getItem_args:
7793 
  """
7794 
  Attributes:
7795 
   - item_id
7796 
  """
7797 
 
7798 
  thrift_spec = (
7799 
    None, # 0
7800 
    (1, TType.I64, 'item_id', None, None, ), # 1
7801 
  )
7802 
 
7803 
  def __init__(self, item_id=None,):
7804 
    self.item_id = item_id
7805 
 
7806 
  def read(self, iprot):
7807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7809 
      return
7810 
    iprot.readStructBegin()
7811 
    while True:
7812 
      (fname, ftype, fid) = iprot.readFieldBegin()
7813 
      if ftype == TType.STOP:
7814 
        break
7815 
      if fid == 1:
7816 
        if ftype == TType.I64:
7817 
          self.item_id = iprot.readI64();
7818 
        else:
7819 
          iprot.skip(ftype)
7820 
      else:
7821 
        iprot.skip(ftype)
7822 
      iprot.readFieldEnd()
7823 
    iprot.readStructEnd()
7824 
 
7825 
  def write(self, oprot):
7826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7828 
      return
7829 
    oprot.writeStructBegin('getItem_args')
7830 
    if self.item_id is not None:
7831 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7832 
      oprot.writeI64(self.item_id)
7833 
      oprot.writeFieldEnd()
7834 
    oprot.writeFieldStop()
7835 
    oprot.writeStructEnd()
7836 
 
7837 
  def validate(self):
7838 
    return
7839 
 
7840 
 
7841 
  def __repr__(self):
7842 
    L = ['%s=%r' % (key, value)
7843 
      for key, value in self.__dict__.iteritems()]
7844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7845 
 
7846 
  def __eq__(self, other):
7847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7848 
 
7849 
  def __ne__(self, other):
7850 
    return not (self == other)
7851 
 
7852 
class getItem_result:
7853 
  """
7854 
  Attributes:
7855 
   - success
7856 
   - cex
7857 
  """
7858 
 
7859 
  thrift_spec = (
7860 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7861 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7862 
  )
7863 
 
7864 
  def __init__(self, success=None, cex=None,):
7865 
    self.success = success
7866 
    self.cex = cex
7867 
 
7868 
  def read(self, iprot):
7869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7871 
      return
7872 
    iprot.readStructBegin()
7873 
    while True:
7874 
      (fname, ftype, fid) = iprot.readFieldBegin()
7875 
      if ftype == TType.STOP:
7876 
        break
7877 
      if fid == 0:
7878 
        if ftype == TType.STRUCT:
7879 
          self.success = Item()
7880 
          self.success.read(iprot)
7881 
        else:
7882 
          iprot.skip(ftype)
7883 
      elif fid == 1:
7884 
        if ftype == TType.STRUCT:
7885 
          self.cex = CatalogServiceException()
7886 
          self.cex.read(iprot)
7887 
        else:
7888 
          iprot.skip(ftype)
7889 
      else:
7890 
        iprot.skip(ftype)
7891 
      iprot.readFieldEnd()
7892 
    iprot.readStructEnd()
7893 
 
7894 
  def write(self, oprot):
7895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7897 
      return
7898 
    oprot.writeStructBegin('getItem_result')
7899 
    if self.success is not None:
7900 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7901 
      self.success.write(oprot)
7902 
      oprot.writeFieldEnd()
7903 
    if self.cex is not None:
7904 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7905 
      self.cex.write(oprot)
7906 
      oprot.writeFieldEnd()
7907 
    oprot.writeFieldStop()
7908 
    oprot.writeStructEnd()
7909 
 
7910 
  def validate(self):
7911 
    return
7912 
 
7913 
 
7914 
  def __repr__(self):
7915 
    L = ['%s=%r' % (key, value)
7916 
      for key, value in self.__dict__.iteritems()]
7917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7918 
 
7919 
  def __eq__(self, other):
7920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7921 
 
7922 
  def __ne__(self, other):
7923 
    return not (self == other)
7924 
 
7925 
class getItemsByCatalogId_args:
7926 
  """
7927 
  Attributes:
7928 
   - catalog_item_id
7929 
  """
7930 
 
7931 
  thrift_spec = (
7932 
    None, # 0
7933 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7934 
  )
7935 
 
7936 
  def __init__(self, catalog_item_id=None,):
7937 
    self.catalog_item_id = catalog_item_id
7938 
 
7939 
  def read(self, iprot):
7940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7942 
      return
7943 
    iprot.readStructBegin()
7944 
    while True:
7945 
      (fname, ftype, fid) = iprot.readFieldBegin()
7946 
      if ftype == TType.STOP:
7947 
        break
7948 
      if fid == 1:
7949 
        if ftype == TType.I64:
7950 
          self.catalog_item_id = iprot.readI64();
7951 
        else:
7952 
          iprot.skip(ftype)
7953 
      else:
7954 
        iprot.skip(ftype)
7955 
      iprot.readFieldEnd()
7956 
    iprot.readStructEnd()
7957 
 
7958 
  def write(self, oprot):
7959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7961 
      return
7962 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7963 
    if self.catalog_item_id is not None:
7964 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7965 
      oprot.writeI64(self.catalog_item_id)
7966 
      oprot.writeFieldEnd()
7967 
    oprot.writeFieldStop()
7968 
    oprot.writeStructEnd()
7969 
 
7970 
  def validate(self):
7971 
    return
7972 
 
7973 
 
7974 
  def __repr__(self):
7975 
    L = ['%s=%r' % (key, value)
7976 
      for key, value in self.__dict__.iteritems()]
7977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7978 
 
7979 
  def __eq__(self, other):
7980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7981 
 
7982 
  def __ne__(self, other):
7983 
    return not (self == other)
7984 
 
7985 
class getItemsByCatalogId_result:
7986 
  """
7987 
  Attributes:
7988 
   - success
7989 
   - cex
7990 
  """
7991 
 
7992 
  thrift_spec = (
7993 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7994 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7995 
  )
7996 
 
7997 
  def __init__(self, success=None, cex=None,):
7998 
    self.success = success
7999 
    self.cex = cex
8000 
 
8001 
  def read(self, iprot):
8002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8004 
      return
8005 
    iprot.readStructBegin()
8006 
    while True:
8007 
      (fname, ftype, fid) = iprot.readFieldBegin()
8008 
      if ftype == TType.STOP:
8009 
        break
8010 
      if fid == 0:
8011 
        if ftype == TType.LIST:
8012 
          self.success = []
8590 kshitij.so 8013 
          (_etype49, _size46) = iprot.readListBegin()
8014 
          for _i50 in xrange(_size46):
8015 
            _elem51 = Item()
8016 
            _elem51.read(iprot)
8017 
            self.success.append(_elem51)
5944 mandeep.dh 8018 
          iprot.readListEnd()
8019 
        else:
8020 
          iprot.skip(ftype)
8021 
      elif fid == 1:
8022 
        if ftype == TType.STRUCT:
8023 
          self.cex = CatalogServiceException()
8024 
          self.cex.read(iprot)
8025 
        else:
8026 
          iprot.skip(ftype)
8027 
      else:
8028 
        iprot.skip(ftype)
8029 
      iprot.readFieldEnd()
8030 
    iprot.readStructEnd()
8031 
 
8032 
  def write(self, oprot):
8033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8035 
      return
8036 
    oprot.writeStructBegin('getItemsByCatalogId_result')
8037 
    if self.success is not None:
8038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8039 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8040 
      for iter52 in self.success:
8041 
        iter52.write(oprot)
5944 mandeep.dh 8042 
      oprot.writeListEnd()
8043 
      oprot.writeFieldEnd()
8044 
    if self.cex is not None:
8045 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8046 
      self.cex.write(oprot)
8047 
      oprot.writeFieldEnd()
8048 
    oprot.writeFieldStop()
8049 
    oprot.writeStructEnd()
8050 
 
8051 
  def validate(self):
8052 
    return
8053 
 
8054 
 
8055 
  def __repr__(self):
8056 
    L = ['%s=%r' % (key, value)
8057 
      for key, value in self.__dict__.iteritems()]
8058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8059 
 
8060 
  def __eq__(self, other):
8061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8062 
 
8063 
  def __ne__(self, other):
8064 
    return not (self == other)
8065 
 
8066 
class getValidItemsByCatalogId_args:
8067 
  """
8068 
  Attributes:
8069 
   - catalog_item_id
8070 
  """
8071 
 
8072 
  thrift_spec = (
8073 
    None, # 0
8074 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
8075 
  )
8076 
 
8077 
  def __init__(self, catalog_item_id=None,):
8078 
    self.catalog_item_id = catalog_item_id
8079 
 
8080 
  def read(self, iprot):
8081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8083 
      return
8084 
    iprot.readStructBegin()
8085 
    while True:
8086 
      (fname, ftype, fid) = iprot.readFieldBegin()
8087 
      if ftype == TType.STOP:
8088 
        break
8089 
      if fid == 1:
8090 
        if ftype == TType.I64:
8091 
          self.catalog_item_id = iprot.readI64();
8092 
        else:
8093 
          iprot.skip(ftype)
8094 
      else:
8095 
        iprot.skip(ftype)
8096 
      iprot.readFieldEnd()
8097 
    iprot.readStructEnd()
8098 
 
8099 
  def write(self, oprot):
8100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8102 
      return
8103 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
8104 
    if self.catalog_item_id is not None:
8105 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
8106 
      oprot.writeI64(self.catalog_item_id)
8107 
      oprot.writeFieldEnd()
8108 
    oprot.writeFieldStop()
8109 
    oprot.writeStructEnd()
8110 
 
8111 
  def validate(self):
8112 
    return
8113 
 
8114 
 
8115 
  def __repr__(self):
8116 
    L = ['%s=%r' % (key, value)
8117 
      for key, value in self.__dict__.iteritems()]
8118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8119 
 
8120 
  def __eq__(self, other):
8121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8122 
 
8123 
  def __ne__(self, other):
8124 
    return not (self == other)
8125 
 
8126 
class getValidItemsByCatalogId_result:
8127 
  """
8128 
  Attributes:
8129 
   - success
8130 
   - cex
8131 
  """
8132 
 
8133 
  thrift_spec = (
8134 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8135 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8136 
  )
8137 
 
8138 
  def __init__(self, success=None, cex=None,):
8139 
    self.success = success
8140 
    self.cex = cex
8141 
 
8142 
  def read(self, iprot):
8143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8145 
      return
8146 
    iprot.readStructBegin()
8147 
    while True:
8148 
      (fname, ftype, fid) = iprot.readFieldBegin()
8149 
      if ftype == TType.STOP:
8150 
        break
8151 
      if fid == 0:
8152 
        if ftype == TType.LIST:
8153 
          self.success = []
8590 kshitij.so 8154 
          (_etype56, _size53) = iprot.readListBegin()
8155 
          for _i57 in xrange(_size53):
8156 
            _elem58 = Item()
8157 
            _elem58.read(iprot)
8158 
            self.success.append(_elem58)
5944 mandeep.dh 8159 
          iprot.readListEnd()
8160 
        else:
8161 
          iprot.skip(ftype)
8162 
      elif fid == 1:
8163 
        if ftype == TType.STRUCT:
8164 
          self.cex = CatalogServiceException()
8165 
          self.cex.read(iprot)
8166 
        else:
8167 
          iprot.skip(ftype)
8168 
      else:
8169 
        iprot.skip(ftype)
8170 
      iprot.readFieldEnd()
8171 
    iprot.readStructEnd()
8172 
 
8173 
  def write(self, oprot):
8174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8176 
      return
8177 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
8178 
    if self.success is not None:
8179 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8180 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8181 
      for iter59 in self.success:
8182 
        iter59.write(oprot)
5944 mandeep.dh 8183 
      oprot.writeListEnd()
8184 
      oprot.writeFieldEnd()
8185 
    if self.cex is not None:
8186 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8187 
      self.cex.write(oprot)
8188 
      oprot.writeFieldEnd()
8189 
    oprot.writeFieldStop()
8190 
    oprot.writeStructEnd()
8191 
 
8192 
  def validate(self):
8193 
    return
8194 
 
8195 
 
8196 
  def __repr__(self):
8197 
    L = ['%s=%r' % (key, value)
8198 
      for key, value in self.__dict__.iteritems()]
8199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8200 
 
8201 
  def __eq__(self, other):
8202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8203 
 
8204 
  def __ne__(self, other):
8205 
    return not (self == other)
8206 
 
8207 
class getAllItems_args:
8208 
  """
8209 
  Attributes:
8210 
   - isActive
8211 
  """
8212 
 
8213 
  thrift_spec = (
8214 
    None, # 0
8215 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
8216 
  )
8217 
 
8218 
  def __init__(self, isActive=None,):
8219 
    self.isActive = isActive
8220 
 
8221 
  def read(self, iprot):
8222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8224 
      return
8225 
    iprot.readStructBegin()
8226 
    while True:
8227 
      (fname, ftype, fid) = iprot.readFieldBegin()
8228 
      if ftype == TType.STOP:
8229 
        break
8230 
      if fid == 1:
8231 
        if ftype == TType.BOOL:
8232 
          self.isActive = iprot.readBool();
8233 
        else:
8234 
          iprot.skip(ftype)
8235 
      else:
8236 
        iprot.skip(ftype)
8237 
      iprot.readFieldEnd()
8238 
    iprot.readStructEnd()
8239 
 
8240 
  def write(self, oprot):
8241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8243 
      return
8244 
    oprot.writeStructBegin('getAllItems_args')
8245 
    if self.isActive is not None:
8246 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
8247 
      oprot.writeBool(self.isActive)
8248 
      oprot.writeFieldEnd()
8249 
    oprot.writeFieldStop()
8250 
    oprot.writeStructEnd()
8251 
 
8252 
  def validate(self):
8253 
    return
8254 
 
8255 
 
8256 
  def __repr__(self):
8257 
    L = ['%s=%r' % (key, value)
8258 
      for key, value in self.__dict__.iteritems()]
8259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8260 
 
8261 
  def __eq__(self, other):
8262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8263 
 
8264 
  def __ne__(self, other):
8265 
    return not (self == other)
8266 
 
8267 
class getAllItems_result:
8268 
  """
8269 
  Attributes:
8270 
   - success
8271 
   - cex
8272 
  """
8273 
 
8274 
  thrift_spec = (
8275 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8276 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8277 
  )
8278 
 
8279 
  def __init__(self, success=None, cex=None,):
8280 
    self.success = success
8281 
    self.cex = cex
8282 
 
8283 
  def read(self, iprot):
8284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8286 
      return
8287 
    iprot.readStructBegin()
8288 
    while True:
8289 
      (fname, ftype, fid) = iprot.readFieldBegin()
8290 
      if ftype == TType.STOP:
8291 
        break
8292 
      if fid == 0:
8293 
        if ftype == TType.LIST:
8294 
          self.success = []
8590 kshitij.so 8295 
          (_etype63, _size60) = iprot.readListBegin()
8296 
          for _i64 in xrange(_size60):
8297 
            _elem65 = Item()
8298 
            _elem65.read(iprot)
8299 
            self.success.append(_elem65)
5944 mandeep.dh 8300 
          iprot.readListEnd()
8301 
        else:
8302 
          iprot.skip(ftype)
8303 
      elif fid == 1:
8304 
        if ftype == TType.STRUCT:
8305 
          self.cex = CatalogServiceException()
8306 
          self.cex.read(iprot)
8307 
        else:
8308 
          iprot.skip(ftype)
8309 
      else:
8310 
        iprot.skip(ftype)
8311 
      iprot.readFieldEnd()
8312 
    iprot.readStructEnd()
8313 
 
8314 
  def write(self, oprot):
8315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8317 
      return
8318 
    oprot.writeStructBegin('getAllItems_result')
8319 
    if self.success is not None:
8320 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8321 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8322 
      for iter66 in self.success:
8323 
        iter66.write(oprot)
5944 mandeep.dh 8324 
      oprot.writeListEnd()
8325 
      oprot.writeFieldEnd()
8326 
    if self.cex is not None:
8327 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8328 
      self.cex.write(oprot)
8329 
      oprot.writeFieldEnd()
8330 
    oprot.writeFieldStop()
8331 
    oprot.writeStructEnd()
8332 
 
8333 
  def validate(self):
8334 
    return
8335 
 
8336 
 
8337 
  def __repr__(self):
8338 
    L = ['%s=%r' % (key, value)
8339 
      for key, value in self.__dict__.iteritems()]
8340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8341 
 
8342 
  def __eq__(self, other):
8343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8344 
 
8345 
  def __ne__(self, other):
8346 
    return not (self == other)
8347 
 
8348 
class getAllItemsByStatus_args:
8349 
  """
8350 
  Attributes:
8351 
   - itemStatus
8352 
  """
8353 
 
8354 
  thrift_spec = (
8355 
    None, # 0
8356 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8357 
  )
8358 
 
8359 
  def __init__(self, itemStatus=None,):
8360 
    self.itemStatus = itemStatus
8361 
 
8362 
  def read(self, iprot):
8363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8365 
      return
8366 
    iprot.readStructBegin()
8367 
    while True:
8368 
      (fname, ftype, fid) = iprot.readFieldBegin()
8369 
      if ftype == TType.STOP:
8370 
        break
8371 
      if fid == 1:
8372 
        if ftype == TType.I32:
8373 
          self.itemStatus = iprot.readI32();
8374 
        else:
8375 
          iprot.skip(ftype)
8376 
      else:
8377 
        iprot.skip(ftype)
8378 
      iprot.readFieldEnd()
8379 
    iprot.readStructEnd()
8380 
 
8381 
  def write(self, oprot):
8382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8384 
      return
8385 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8386 
    if self.itemStatus is not None:
8387 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8388 
      oprot.writeI32(self.itemStatus)
8389 
      oprot.writeFieldEnd()
8390 
    oprot.writeFieldStop()
8391 
    oprot.writeStructEnd()
8392 
 
8393 
  def validate(self):
8394 
    return
8395 
 
8396 
 
8397 
  def __repr__(self):
8398 
    L = ['%s=%r' % (key, value)
8399 
      for key, value in self.__dict__.iteritems()]
8400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8401 
 
8402 
  def __eq__(self, other):
8403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8404 
 
8405 
  def __ne__(self, other):
8406 
    return not (self == other)
8407 
 
8408 
class getAllItemsByStatus_result:
8409 
  """
8410 
  Attributes:
8411 
   - success
8412 
   - cex
8413 
  """
8414 
 
8415 
  thrift_spec = (
8416 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8417 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8418 
  )
8419 
 
8420 
  def __init__(self, success=None, cex=None,):
8421 
    self.success = success
8422 
    self.cex = cex
8423 
 
8424 
  def read(self, iprot):
8425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8427 
      return
8428 
    iprot.readStructBegin()
8429 
    while True:
8430 
      (fname, ftype, fid) = iprot.readFieldBegin()
8431 
      if ftype == TType.STOP:
8432 
        break
8433 
      if fid == 0:
8434 
        if ftype == TType.LIST:
8435 
          self.success = []
8590 kshitij.so 8436 
          (_etype70, _size67) = iprot.readListBegin()
8437 
          for _i71 in xrange(_size67):
8438 
            _elem72 = Item()
8439 
            _elem72.read(iprot)
8440 
            self.success.append(_elem72)
5944 mandeep.dh 8441 
          iprot.readListEnd()
8442 
        else:
8443 
          iprot.skip(ftype)
8444 
      elif fid == 1:
8445 
        if ftype == TType.STRUCT:
8446 
          self.cex = CatalogServiceException()
8447 
          self.cex.read(iprot)
8448 
        else:
8449 
          iprot.skip(ftype)
8450 
      else:
8451 
        iprot.skip(ftype)
8452 
      iprot.readFieldEnd()
8453 
    iprot.readStructEnd()
8454 
 
8455 
  def write(self, oprot):
8456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8458 
      return
8459 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8460 
    if self.success is not None:
8461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8462 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8463 
      for iter73 in self.success:
8464 
        iter73.write(oprot)
5944 mandeep.dh 8465 
      oprot.writeListEnd()
8466 
      oprot.writeFieldEnd()
8467 
    if self.cex is not None:
8468 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8469 
      self.cex.write(oprot)
8470 
      oprot.writeFieldEnd()
8471 
    oprot.writeFieldStop()
8472 
    oprot.writeStructEnd()
8473 
 
8474 
  def validate(self):
8475 
    return
8476 
 
8477 
 
8478 
  def __repr__(self):
8479 
    L = ['%s=%r' % (key, value)
8480 
      for key, value in self.__dict__.iteritems()]
8481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8482 
 
8483 
  def __eq__(self, other):
8484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8485 
 
8486 
  def __ne__(self, other):
8487 
    return not (self == other)
8488 
 
8489 
class markItemAsContentComplete_args:
8490 
  """
8491 
  Attributes:
8492 
   - entityId
8493 
   - category
8494 
   - brand
8495 
   - modelName
8496 
   - modelNumber
9253 rajveer 8497 
   - isAndroid
5944 mandeep.dh 8498 
  """
8499 
 
8500 
  thrift_spec = (
8501 
    None, # 0
8502 
    (1, TType.I64, 'entityId', None, None, ), # 1
8503 
    (2, TType.I64, 'category', None, None, ), # 2
8504 
    (3, TType.STRING, 'brand', None, None, ), # 3
8505 
    (4, TType.STRING, 'modelName', None, None, ), # 4
8506 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
9253 rajveer 8507 
    (6, TType.BOOL, 'isAndroid', None, None, ), # 6
5944 mandeep.dh 8508 
  )
8509 
 
9253 rajveer 8510 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None, isAndroid=None,):
5944 mandeep.dh 8511 
    self.entityId = entityId
8512 
    self.category = category
8513 
    self.brand = brand
8514 
    self.modelName = modelName
8515 
    self.modelNumber = modelNumber
9253 rajveer 8516 
    self.isAndroid = isAndroid
5944 mandeep.dh 8517 
 
8518 
  def read(self, iprot):
8519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8521 
      return
8522 
    iprot.readStructBegin()
8523 
    while True:
8524 
      (fname, ftype, fid) = iprot.readFieldBegin()
8525 
      if ftype == TType.STOP:
8526 
        break
8527 
      if fid == 1:
8528 
        if ftype == TType.I64:
8529 
          self.entityId = iprot.readI64();
8530 
        else:
8531 
          iprot.skip(ftype)
8532 
      elif fid == 2:
8533 
        if ftype == TType.I64:
8534 
          self.category = iprot.readI64();
8535 
        else:
8536 
          iprot.skip(ftype)
8537 
      elif fid == 3:
8538 
        if ftype == TType.STRING:
8539 
          self.brand = iprot.readString();
8540 
        else:
8541 
          iprot.skip(ftype)
8542 
      elif fid == 4:
8543 
        if ftype == TType.STRING:
8544 
          self.modelName = iprot.readString();
8545 
        else:
8546 
          iprot.skip(ftype)
8547 
      elif fid == 5:
8548 
        if ftype == TType.STRING:
8549 
          self.modelNumber = iprot.readString();
8550 
        else:
8551 
          iprot.skip(ftype)
9253 rajveer 8552 
      elif fid == 6:
8553 
        if ftype == TType.BOOL:
8554 
          self.isAndroid = iprot.readBool();
8555 
        else:
8556 
          iprot.skip(ftype)
5944 mandeep.dh 8557 
      else:
8558 
        iprot.skip(ftype)
8559 
      iprot.readFieldEnd()
8560 
    iprot.readStructEnd()
8561 
 
8562 
  def write(self, oprot):
8563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8565 
      return
8566 
    oprot.writeStructBegin('markItemAsContentComplete_args')
8567 
    if self.entityId is not None:
8568 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
8569 
      oprot.writeI64(self.entityId)
8570 
      oprot.writeFieldEnd()
8571 
    if self.category is not None:
8572 
      oprot.writeFieldBegin('category', TType.I64, 2)
8573 
      oprot.writeI64(self.category)
8574 
      oprot.writeFieldEnd()
8575 
    if self.brand is not None:
8576 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8577 
      oprot.writeString(self.brand)
8578 
      oprot.writeFieldEnd()
8579 
    if self.modelName is not None:
8580 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
8581 
      oprot.writeString(self.modelName)
8582 
      oprot.writeFieldEnd()
8583 
    if self.modelNumber is not None:
8584 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
8585 
      oprot.writeString(self.modelNumber)
8586 
      oprot.writeFieldEnd()
9253 rajveer 8587 
    if self.isAndroid is not None:
8588 
      oprot.writeFieldBegin('isAndroid', TType.BOOL, 6)
8589 
      oprot.writeBool(self.isAndroid)
8590 
      oprot.writeFieldEnd()
5944 mandeep.dh 8591 
    oprot.writeFieldStop()
8592 
    oprot.writeStructEnd()
8593 
 
8594 
  def validate(self):
8595 
    return
8596 
 
8597 
 
8598 
  def __repr__(self):
8599 
    L = ['%s=%r' % (key, value)
8600 
      for key, value in self.__dict__.iteritems()]
8601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8602 
 
8603 
  def __eq__(self, other):
8604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8605 
 
8606 
  def __ne__(self, other):
8607 
    return not (self == other)
8608 
 
8609 
class markItemAsContentComplete_result:
8610 
  """
8611 
  Attributes:
8612 
   - success
8613 
   - cex
8614 
  """
8615 
 
8616 
  thrift_spec = (
8617 
    (0, TType.BOOL, 'success', None, None, ), # 0
8618 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8619 
  )
8620 
 
8621 
  def __init__(self, success=None, cex=None,):
8622 
    self.success = success
8623 
    self.cex = cex
8624 
 
8625 
  def read(self, iprot):
8626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8628 
      return
8629 
    iprot.readStructBegin()
8630 
    while True:
8631 
      (fname, ftype, fid) = iprot.readFieldBegin()
8632 
      if ftype == TType.STOP:
8633 
        break
8634 
      if fid == 0:
8635 
        if ftype == TType.BOOL:
8636 
          self.success = iprot.readBool();
8637 
        else:
8638 
          iprot.skip(ftype)
8639 
      elif fid == 1:
8640 
        if ftype == TType.STRUCT:
8641 
          self.cex = CatalogServiceException()
8642 
          self.cex.read(iprot)
8643 
        else:
8644 
          iprot.skip(ftype)
8645 
      else:
8646 
        iprot.skip(ftype)
8647 
      iprot.readFieldEnd()
8648 
    iprot.readStructEnd()
8649 
 
8650 
  def write(self, oprot):
8651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8653 
      return
8654 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8655 
    if self.success is not None:
8656 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8657 
      oprot.writeBool(self.success)
8658 
      oprot.writeFieldEnd()
8659 
    if self.cex is not None:
8660 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8661 
      self.cex.write(oprot)
8662 
      oprot.writeFieldEnd()
8663 
    oprot.writeFieldStop()
8664 
    oprot.writeStructEnd()
8665 
 
8666 
  def validate(self):
8667 
    return
8668 
 
8669 
 
8670 
  def __repr__(self):
8671 
    L = ['%s=%r' % (key, value)
8672 
      for key, value in self.__dict__.iteritems()]
8673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8674 
 
8675 
  def __eq__(self, other):
8676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8677 
 
8678 
  def __ne__(self, other):
8679 
    return not (self == other)
8680 
 
8681 
class getAllItemsInRange_args:
8682 
  """
8683 
  Attributes:
8684 
   - offset
8685 
   - limit
8686 
  """
8687 
 
8688 
  thrift_spec = (
8689 
    None, # 0
8690 
    (1, TType.I64, 'offset', None, None, ), # 1
8691 
    (2, TType.I64, 'limit', None, None, ), # 2
8692 
  )
8693 
 
8694 
  def __init__(self, offset=None, limit=None,):
8695 
    self.offset = offset
8696 
    self.limit = limit
8697 
 
8698 
  def read(self, iprot):
8699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8701 
      return
8702 
    iprot.readStructBegin()
8703 
    while True:
8704 
      (fname, ftype, fid) = iprot.readFieldBegin()
8705 
      if ftype == TType.STOP:
8706 
        break
8707 
      if fid == 1:
8708 
        if ftype == TType.I64:
8709 
          self.offset = iprot.readI64();
8710 
        else:
8711 
          iprot.skip(ftype)
8712 
      elif fid == 2:
8713 
        if ftype == TType.I64:
8714 
          self.limit = iprot.readI64();
8715 
        else:
8716 
          iprot.skip(ftype)
8717 
      else:
8718 
        iprot.skip(ftype)
8719 
      iprot.readFieldEnd()
8720 
    iprot.readStructEnd()
8721 
 
8722 
  def write(self, oprot):
8723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8725 
      return
8726 
    oprot.writeStructBegin('getAllItemsInRange_args')
8727 
    if self.offset is not None:
8728 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8729 
      oprot.writeI64(self.offset)
8730 
      oprot.writeFieldEnd()
8731 
    if self.limit is not None:
8732 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8733 
      oprot.writeI64(self.limit)
8734 
      oprot.writeFieldEnd()
8735 
    oprot.writeFieldStop()
8736 
    oprot.writeStructEnd()
8737 
 
8738 
  def validate(self):
8739 
    return
8740 
 
8741 
 
8742 
  def __repr__(self):
8743 
    L = ['%s=%r' % (key, value)
8744 
      for key, value in self.__dict__.iteritems()]
8745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8746 
 
8747 
  def __eq__(self, other):
8748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8749 
 
8750 
  def __ne__(self, other):
8751 
    return not (self == other)
8752 
 
8753 
class getAllItemsInRange_result:
8754 
  """
8755 
  Attributes:
8756 
   - success
8757 
   - cex
8758 
  """
8759 
 
8760 
  thrift_spec = (
8761 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8762 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8763 
  )
8764 
 
8765 
  def __init__(self, success=None, cex=None,):
8766 
    self.success = success
8767 
    self.cex = cex
8768 
 
8769 
  def read(self, iprot):
8770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8772 
      return
8773 
    iprot.readStructBegin()
8774 
    while True:
8775 
      (fname, ftype, fid) = iprot.readFieldBegin()
8776 
      if ftype == TType.STOP:
8777 
        break
8778 
      if fid == 0:
8779 
        if ftype == TType.LIST:
8780 
          self.success = []
8590 kshitij.so 8781 
          (_etype77, _size74) = iprot.readListBegin()
8782 
          for _i78 in xrange(_size74):
8783 
            _elem79 = Item()
8784 
            _elem79.read(iprot)
8785 
            self.success.append(_elem79)
5944 mandeep.dh 8786 
          iprot.readListEnd()
8787 
        else:
8788 
          iprot.skip(ftype)
8789 
      elif fid == 1:
8790 
        if ftype == TType.STRUCT:
8791 
          self.cex = CatalogServiceException()
8792 
          self.cex.read(iprot)
8793 
        else:
8794 
          iprot.skip(ftype)
8795 
      else:
8796 
        iprot.skip(ftype)
8797 
      iprot.readFieldEnd()
8798 
    iprot.readStructEnd()
8799 
 
8800 
  def write(self, oprot):
8801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8803 
      return
8804 
    oprot.writeStructBegin('getAllItemsInRange_result')
8805 
    if self.success is not None:
8806 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8807 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8808 
      for iter80 in self.success:
8809 
        iter80.write(oprot)
5944 mandeep.dh 8810 
      oprot.writeListEnd()
8811 
      oprot.writeFieldEnd()
8812 
    if self.cex is not None:
8813 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8814 
      self.cex.write(oprot)
8815 
      oprot.writeFieldEnd()
8816 
    oprot.writeFieldStop()
8817 
    oprot.writeStructEnd()
8818 
 
8819 
  def validate(self):
8820 
    return
8821 
 
8822 
 
8823 
  def __repr__(self):
8824 
    L = ['%s=%r' % (key, value)
8825 
      for key, value in self.__dict__.iteritems()]
8826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8827 
 
8828 
  def __eq__(self, other):
8829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8830 
 
8831 
  def __ne__(self, other):
8832 
    return not (self == other)
8833 
 
8834 
class getAllItemsByStatusInRange_args:
8835 
  """
8836 
  Attributes:
8837 
   - itemStatus
8838 
   - offset
8839 
   - limit
8840 
  """
8841 
 
8842 
  thrift_spec = (
8843 
    None, # 0
8844 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8845 
    (2, TType.I64, 'offset', None, None, ), # 2
8846 
    (3, TType.I64, 'limit', None, None, ), # 3
8847 
  )
8848 
 
8849 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8850 
    self.itemStatus = itemStatus
8851 
    self.offset = offset
8852 
    self.limit = limit
8853 
 
8854 
  def read(self, iprot):
8855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8857 
      return
8858 
    iprot.readStructBegin()
8859 
    while True:
8860 
      (fname, ftype, fid) = iprot.readFieldBegin()
8861 
      if ftype == TType.STOP:
8862 
        break
8863 
      if fid == 1:
8864 
        if ftype == TType.I32:
8865 
          self.itemStatus = iprot.readI32();
8866 
        else:
8867 
          iprot.skip(ftype)
8868 
      elif fid == 2:
8869 
        if ftype == TType.I64:
8870 
          self.offset = iprot.readI64();
8871 
        else:
8872 
          iprot.skip(ftype)
8873 
      elif fid == 3:
8874 
        if ftype == TType.I64:
8875 
          self.limit = iprot.readI64();
8876 
        else:
8877 
          iprot.skip(ftype)
8878 
      else:
8879 
        iprot.skip(ftype)
8880 
      iprot.readFieldEnd()
8881 
    iprot.readStructEnd()
8882 
 
8883 
  def write(self, oprot):
8884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8886 
      return
8887 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8888 
    if self.itemStatus is not None:
8889 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8890 
      oprot.writeI32(self.itemStatus)
8891 
      oprot.writeFieldEnd()
8892 
    if self.offset is not None:
8893 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8894 
      oprot.writeI64(self.offset)
8895 
      oprot.writeFieldEnd()
8896 
    if self.limit is not None:
8897 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8898 
      oprot.writeI64(self.limit)
8899 
      oprot.writeFieldEnd()
8900 
    oprot.writeFieldStop()
8901 
    oprot.writeStructEnd()
8902 
 
8903 
  def validate(self):
8904 
    return
8905 
 
8906 
 
8907 
  def __repr__(self):
8908 
    L = ['%s=%r' % (key, value)
8909 
      for key, value in self.__dict__.iteritems()]
8910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8911 
 
8912 
  def __eq__(self, other):
8913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8914 
 
8915 
  def __ne__(self, other):
8916 
    return not (self == other)
8917 
 
8918 
class getAllItemsByStatusInRange_result:
8919 
  """
8920 
  Attributes:
8921 
   - success
8922 
   - cex
8923 
  """
8924 
 
8925 
  thrift_spec = (
8926 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8927 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8928 
  )
8929 
 
8930 
  def __init__(self, success=None, cex=None,):
8931 
    self.success = success
8932 
    self.cex = cex
8933 
 
8934 
  def read(self, iprot):
8935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8937 
      return
8938 
    iprot.readStructBegin()
8939 
    while True:
8940 
      (fname, ftype, fid) = iprot.readFieldBegin()
8941 
      if ftype == TType.STOP:
8942 
        break
8943 
      if fid == 0:
8944 
        if ftype == TType.LIST:
8945 
          self.success = []
8590 kshitij.so 8946 
          (_etype84, _size81) = iprot.readListBegin()
8947 
          for _i85 in xrange(_size81):
8948 
            _elem86 = Item()
8949 
            _elem86.read(iprot)
8950 
            self.success.append(_elem86)
5944 mandeep.dh 8951 
          iprot.readListEnd()
8952 
        else:
8953 
          iprot.skip(ftype)
8954 
      elif fid == 1:
8955 
        if ftype == TType.STRUCT:
8956 
          self.cex = CatalogServiceException()
8957 
          self.cex.read(iprot)
8958 
        else:
8959 
          iprot.skip(ftype)
8960 
      else:
8961 
        iprot.skip(ftype)
8962 
      iprot.readFieldEnd()
8963 
    iprot.readStructEnd()
8964 
 
8965 
  def write(self, oprot):
8966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8968 
      return
8969 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8970 
    if self.success is not None:
8971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8972 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8973 
      for iter87 in self.success:
8974 
        iter87.write(oprot)
5944 mandeep.dh 8975 
      oprot.writeListEnd()
8976 
      oprot.writeFieldEnd()
8977 
    if self.cex is not None:
8978 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8979 
      self.cex.write(oprot)
8980 
      oprot.writeFieldEnd()
8981 
    oprot.writeFieldStop()
8982 
    oprot.writeStructEnd()
8983 
 
8984 
  def validate(self):
8985 
    return
8986 
 
8987 
 
8988 
  def __repr__(self):
8989 
    L = ['%s=%r' % (key, value)
8990 
      for key, value in self.__dict__.iteritems()]
8991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8992 
 
8993 
  def __eq__(self, other):
8994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8995 
 
8996 
  def __ne__(self, other):
8997 
    return not (self == other)
8998 
 
8999 
class getItemCountByStatus_args:
9000 
  """
9001 
  Attributes:
9002 
   - useStatus
9003 
   - itemStatus
9004 
  """
9005 
 
9006 
  thrift_spec = (
9007 
    None, # 0
9008 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
9009 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
9010 
  )
9011 
 
9012 
  def __init__(self, useStatus=None, itemStatus=None,):
9013 
    self.useStatus = useStatus
9014 
    self.itemStatus = itemStatus
9015 
 
9016 
  def read(self, iprot):
9017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9019 
      return
9020 
    iprot.readStructBegin()
9021 
    while True:
9022 
      (fname, ftype, fid) = iprot.readFieldBegin()
9023 
      if ftype == TType.STOP:
9024 
        break
9025 
      if fid == 1:
9026 
        if ftype == TType.BOOL:
9027 
          self.useStatus = iprot.readBool();
9028 
        else:
9029 
          iprot.skip(ftype)
9030 
      elif fid == 2:
9031 
        if ftype == TType.I32:
9032 
          self.itemStatus = iprot.readI32();
9033 
        else:
9034 
          iprot.skip(ftype)
9035 
      else:
9036 
        iprot.skip(ftype)
9037 
      iprot.readFieldEnd()
9038 
    iprot.readStructEnd()
9039 
 
9040 
  def write(self, oprot):
9041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9043 
      return
9044 
    oprot.writeStructBegin('getItemCountByStatus_args')
9045 
    if self.useStatus is not None:
9046 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
9047 
      oprot.writeBool(self.useStatus)
9048 
      oprot.writeFieldEnd()
9049 
    if self.itemStatus is not None:
9050 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
9051 
      oprot.writeI32(self.itemStatus)
9052 
      oprot.writeFieldEnd()
9053 
    oprot.writeFieldStop()
9054 
    oprot.writeStructEnd()
9055 
 
9056 
  def validate(self):
9057 
    return
9058 
 
9059 
 
9060 
  def __repr__(self):
9061 
    L = ['%s=%r' % (key, value)
9062 
      for key, value in self.__dict__.iteritems()]
9063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9064 
 
9065 
  def __eq__(self, other):
9066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9067 
 
9068 
  def __ne__(self, other):
9069 
    return not (self == other)
9070 
 
9071 
class getItemCountByStatus_result:
9072 
  """
9073 
  Attributes:
9074 
   - success
9075 
  """
9076 
 
9077 
  thrift_spec = (
9078 
    (0, TType.I32, 'success', None, None, ), # 0
9079 
  )
9080 
 
9081 
  def __init__(self, success=None,):
9082 
    self.success = success
9083 
 
9084 
  def read(self, iprot):
9085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9087 
      return
9088 
    iprot.readStructBegin()
9089 
    while True:
9090 
      (fname, ftype, fid) = iprot.readFieldBegin()
9091 
      if ftype == TType.STOP:
9092 
        break
9093 
      if fid == 0:
9094 
        if ftype == TType.I32:
9095 
          self.success = iprot.readI32();
9096 
        else:
9097 
          iprot.skip(ftype)
9098 
      else:
9099 
        iprot.skip(ftype)
9100 
      iprot.readFieldEnd()
9101 
    iprot.readStructEnd()
9102 
 
9103 
  def write(self, oprot):
9104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9106 
      return
9107 
    oprot.writeStructBegin('getItemCountByStatus_result')
9108 
    if self.success is not None:
9109 
      oprot.writeFieldBegin('success', TType.I32, 0)
9110 
      oprot.writeI32(self.success)
9111 
      oprot.writeFieldEnd()
9112 
    oprot.writeFieldStop()
9113 
    oprot.writeStructEnd()
9114 
 
9115 
  def validate(self):
9116 
    return
9117 
 
9118 
 
9119 
  def __repr__(self):
9120 
    L = ['%s=%r' % (key, value)
9121 
      for key, value in self.__dict__.iteritems()]
9122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9123 
 
9124 
  def __eq__(self, other):
9125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9126 
 
9127 
  def __ne__(self, other):
9128 
    return not (self == other)
9129 
 
9130 
class getBestSellers_args:
9131 
 
9132 
  thrift_spec = (
9133 
  )
9134 
 
9135 
  def read(self, iprot):
9136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9138 
      return
9139 
    iprot.readStructBegin()
9140 
    while True:
9141 
      (fname, ftype, fid) = iprot.readFieldBegin()
9142 
      if ftype == TType.STOP:
9143 
        break
9144 
      else:
9145 
        iprot.skip(ftype)
9146 
      iprot.readFieldEnd()
9147 
    iprot.readStructEnd()
9148 
 
9149 
  def write(self, oprot):
9150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9152 
      return
9153 
    oprot.writeStructBegin('getBestSellers_args')
9154 
    oprot.writeFieldStop()
9155 
    oprot.writeStructEnd()
9156 
 
9157 
  def validate(self):
9158 
    return
9159 
 
9160 
 
9161 
  def __repr__(self):
9162 
    L = ['%s=%r' % (key, value)
9163 
      for key, value in self.__dict__.iteritems()]
9164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9165 
 
9166 
  def __eq__(self, other):
9167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9168 
 
9169 
  def __ne__(self, other):
9170 
    return not (self == other)
9171 
 
9172 
class getBestSellers_result:
9173 
  """
9174 
  Attributes:
9175 
   - success
9176 
   - isex
9177 
  """
9178 
 
9179 
  thrift_spec = (
9180 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9181 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9182 
  )
9183 
 
9184 
  def __init__(self, success=None, isex=None,):
9185 
    self.success = success
9186 
    self.isex = isex
9187 
 
9188 
  def read(self, iprot):
9189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9191 
      return
9192 
    iprot.readStructBegin()
9193 
    while True:
9194 
      (fname, ftype, fid) = iprot.readFieldBegin()
9195 
      if ftype == TType.STOP:
9196 
        break
9197 
      if fid == 0:
9198 
        if ftype == TType.LIST:
9199 
          self.success = []
8590 kshitij.so 9200 
          (_etype91, _size88) = iprot.readListBegin()
9201 
          for _i92 in xrange(_size88):
9202 
            _elem93 = Item()
9203 
            _elem93.read(iprot)
9204 
            self.success.append(_elem93)
5944 mandeep.dh 9205 
          iprot.readListEnd()
9206 
        else:
9207 
          iprot.skip(ftype)
9208 
      elif fid == 1:
9209 
        if ftype == TType.STRUCT:
9210 
          self.isex = CatalogServiceException()
9211 
          self.isex.read(iprot)
9212 
        else:
9213 
          iprot.skip(ftype)
9214 
      else:
9215 
        iprot.skip(ftype)
9216 
      iprot.readFieldEnd()
9217 
    iprot.readStructEnd()
9218 
 
9219 
  def write(self, oprot):
9220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9222 
      return
9223 
    oprot.writeStructBegin('getBestSellers_result')
9224 
    if self.success is not None:
9225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9227 
      for iter94 in self.success:
9228 
        iter94.write(oprot)
5944 mandeep.dh 9229 
      oprot.writeListEnd()
9230 
      oprot.writeFieldEnd()
9231 
    if self.isex is not None:
9232 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9233 
      self.isex.write(oprot)
9234 
      oprot.writeFieldEnd()
9235 
    oprot.writeFieldStop()
9236 
    oprot.writeStructEnd()
9237 
 
9238 
  def validate(self):
9239 
    return
9240 
 
9241 
 
9242 
  def __repr__(self):
9243 
    L = ['%s=%r' % (key, value)
9244 
      for key, value in self.__dict__.iteritems()]
9245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9246 
 
9247 
  def __eq__(self, other):
9248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9249 
 
9250 
  def __ne__(self, other):
9251 
    return not (self == other)
9252 
 
9253 
class getBestSellersCatalogIds_args:
9254 
  """
9255 
  Attributes:
9256 
   - beginIndex
9257 
   - totalItems
9258 
   - brand
9259 
   - category
9260 
  """
9261 
 
9262 
  thrift_spec = (
9263 
    None, # 0
9264 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9265 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9266 
    (3, TType.STRING, 'brand', None, None, ), # 3
9267 
    (4, TType.I64, 'category', None, None, ), # 4
9268 
  )
9269 
 
9270 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9271 
    self.beginIndex = beginIndex
9272 
    self.totalItems = totalItems
9273 
    self.brand = brand
9274 
    self.category = category
9275 
 
9276 
  def read(self, iprot):
9277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9279 
      return
9280 
    iprot.readStructBegin()
9281 
    while True:
9282 
      (fname, ftype, fid) = iprot.readFieldBegin()
9283 
      if ftype == TType.STOP:
9284 
        break
9285 
      if fid == 1:
9286 
        if ftype == TType.I64:
9287 
          self.beginIndex = iprot.readI64();
9288 
        else:
9289 
          iprot.skip(ftype)
9290 
      elif fid == 2:
9291 
        if ftype == TType.I64:
9292 
          self.totalItems = iprot.readI64();
9293 
        else:
9294 
          iprot.skip(ftype)
9295 
      elif fid == 3:
9296 
        if ftype == TType.STRING:
9297 
          self.brand = iprot.readString();
9298 
        else:
9299 
          iprot.skip(ftype)
9300 
      elif fid == 4:
9301 
        if ftype == TType.I64:
9302 
          self.category = iprot.readI64();
9303 
        else:
9304 
          iprot.skip(ftype)
9305 
      else:
9306 
        iprot.skip(ftype)
9307 
      iprot.readFieldEnd()
9308 
    iprot.readStructEnd()
9309 
 
9310 
  def write(self, oprot):
9311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9313 
      return
9314 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
9315 
    if self.beginIndex is not None:
9316 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9317 
      oprot.writeI64(self.beginIndex)
9318 
      oprot.writeFieldEnd()
9319 
    if self.totalItems is not None:
9320 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9321 
      oprot.writeI64(self.totalItems)
9322 
      oprot.writeFieldEnd()
9323 
    if self.brand is not None:
9324 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9325 
      oprot.writeString(self.brand)
9326 
      oprot.writeFieldEnd()
9327 
    if self.category is not None:
9328 
      oprot.writeFieldBegin('category', TType.I64, 4)
9329 
      oprot.writeI64(self.category)
9330 
      oprot.writeFieldEnd()
9331 
    oprot.writeFieldStop()
9332 
    oprot.writeStructEnd()
9333 
 
9334 
  def validate(self):
9335 
    return
9336 
 
9337 
 
9338 
  def __repr__(self):
9339 
    L = ['%s=%r' % (key, value)
9340 
      for key, value in self.__dict__.iteritems()]
9341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9342 
 
9343 
  def __eq__(self, other):
9344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9345 
 
9346 
  def __ne__(self, other):
9347 
    return not (self == other)
9348 
 
9349 
class getBestSellersCatalogIds_result:
9350 
  """
9351 
  Attributes:
9352 
   - success
9353 
   - cex
9354 
  """
9355 
 
9356 
  thrift_spec = (
9357 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9358 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9359 
  )
9360 
 
9361 
  def __init__(self, success=None, cex=None,):
9362 
    self.success = success
9363 
    self.cex = cex
9364 
 
9365 
  def read(self, iprot):
9366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9368 
      return
9369 
    iprot.readStructBegin()
9370 
    while True:
9371 
      (fname, ftype, fid) = iprot.readFieldBegin()
9372 
      if ftype == TType.STOP:
9373 
        break
9374 
      if fid == 0:
9375 
        if ftype == TType.LIST:
9376 
          self.success = []
8590 kshitij.so 9377 
          (_etype98, _size95) = iprot.readListBegin()
9378 
          for _i99 in xrange(_size95):
9379 
            _elem100 = iprot.readI64();
9380 
            self.success.append(_elem100)
5944 mandeep.dh 9381 
          iprot.readListEnd()
9382 
        else:
9383 
          iprot.skip(ftype)
9384 
      elif fid == 1:
9385 
        if ftype == TType.STRUCT:
9386 
          self.cex = CatalogServiceException()
9387 
          self.cex.read(iprot)
9388 
        else:
9389 
          iprot.skip(ftype)
9390 
      else:
9391 
        iprot.skip(ftype)
9392 
      iprot.readFieldEnd()
9393 
    iprot.readStructEnd()
9394 
 
9395 
  def write(self, oprot):
9396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9398 
      return
9399 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9400 
    if self.success is not None:
9401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9402 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9403 
      for iter101 in self.success:
9404 
        oprot.writeI64(iter101)
5944 mandeep.dh 9405 
      oprot.writeListEnd()
9406 
      oprot.writeFieldEnd()
9407 
    if self.cex is not None:
9408 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9409 
      self.cex.write(oprot)
9410 
      oprot.writeFieldEnd()
9411 
    oprot.writeFieldStop()
9412 
    oprot.writeStructEnd()
9413 
 
9414 
  def validate(self):
9415 
    return
9416 
 
9417 
 
9418 
  def __repr__(self):
9419 
    L = ['%s=%r' % (key, value)
9420 
      for key, value in self.__dict__.iteritems()]
9421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9422 
 
9423 
  def __eq__(self, other):
9424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9425 
 
9426 
  def __ne__(self, other):
9427 
    return not (self == other)
9428 
 
9429 
class getBestSellersCount_args:
9430 
 
9431 
  thrift_spec = (
9432 
  )
9433 
 
9434 
  def read(self, iprot):
9435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9437 
      return
9438 
    iprot.readStructBegin()
9439 
    while True:
9440 
      (fname, ftype, fid) = iprot.readFieldBegin()
9441 
      if ftype == TType.STOP:
9442 
        break
9443 
      else:
9444 
        iprot.skip(ftype)
9445 
      iprot.readFieldEnd()
9446 
    iprot.readStructEnd()
9447 
 
9448 
  def write(self, oprot):
9449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9451 
      return
9452 
    oprot.writeStructBegin('getBestSellersCount_args')
9453 
    oprot.writeFieldStop()
9454 
    oprot.writeStructEnd()
9455 
 
9456 
  def validate(self):
9457 
    return
9458 
 
9459 
 
9460 
  def __repr__(self):
9461 
    L = ['%s=%r' % (key, value)
9462 
      for key, value in self.__dict__.iteritems()]
9463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9464 
 
9465 
  def __eq__(self, other):
9466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9467 
 
9468 
  def __ne__(self, other):
9469 
    return not (self == other)
9470 
 
9471 
class getBestSellersCount_result:
9472 
  """
9473 
  Attributes:
9474 
   - success
9475 
   - cex
9476 
  """
9477 
 
9478 
  thrift_spec = (
9479 
    (0, TType.I64, 'success', None, None, ), # 0
9480 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9481 
  )
9482 
 
9483 
  def __init__(self, success=None, cex=None,):
9484 
    self.success = success
9485 
    self.cex = cex
9486 
 
9487 
  def read(self, iprot):
9488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9490 
      return
9491 
    iprot.readStructBegin()
9492 
    while True:
9493 
      (fname, ftype, fid) = iprot.readFieldBegin()
9494 
      if ftype == TType.STOP:
9495 
        break
9496 
      if fid == 0:
9497 
        if ftype == TType.I64:
9498 
          self.success = iprot.readI64();
9499 
        else:
9500 
          iprot.skip(ftype)
9501 
      elif fid == 1:
9502 
        if ftype == TType.STRUCT:
9503 
          self.cex = CatalogServiceException()
9504 
          self.cex.read(iprot)
9505 
        else:
9506 
          iprot.skip(ftype)
9507 
      else:
9508 
        iprot.skip(ftype)
9509 
      iprot.readFieldEnd()
9510 
    iprot.readStructEnd()
9511 
 
9512 
  def write(self, oprot):
9513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9515 
      return
9516 
    oprot.writeStructBegin('getBestSellersCount_result')
9517 
    if self.success is not None:
9518 
      oprot.writeFieldBegin('success', TType.I64, 0)
9519 
      oprot.writeI64(self.success)
9520 
      oprot.writeFieldEnd()
9521 
    if self.cex is not None:
9522 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9523 
      self.cex.write(oprot)
9524 
      oprot.writeFieldEnd()
9525 
    oprot.writeFieldStop()
9526 
    oprot.writeStructEnd()
9527 
 
9528 
  def validate(self):
9529 
    return
9530 
 
9531 
 
9532 
  def __repr__(self):
9533 
    L = ['%s=%r' % (key, value)
9534 
      for key, value in self.__dict__.iteritems()]
9535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9536 
 
9537 
  def __eq__(self, other):
9538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9539 
 
9540 
  def __ne__(self, other):
9541 
    return not (self == other)
9542 
 
9543 
class getBestDeals_args:
9544 
 
9545 
  thrift_spec = (
9546 
  )
9547 
 
9548 
  def read(self, iprot):
9549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9551 
      return
9552 
    iprot.readStructBegin()
9553 
    while True:
9554 
      (fname, ftype, fid) = iprot.readFieldBegin()
9555 
      if ftype == TType.STOP:
9556 
        break
9557 
      else:
9558 
        iprot.skip(ftype)
9559 
      iprot.readFieldEnd()
9560 
    iprot.readStructEnd()
9561 
 
9562 
  def write(self, oprot):
9563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9565 
      return
9566 
    oprot.writeStructBegin('getBestDeals_args')
9567 
    oprot.writeFieldStop()
9568 
    oprot.writeStructEnd()
9569 
 
9570 
  def validate(self):
9571 
    return
9572 
 
9573 
 
9574 
  def __repr__(self):
9575 
    L = ['%s=%r' % (key, value)
9576 
      for key, value in self.__dict__.iteritems()]
9577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9578 
 
9579 
  def __eq__(self, other):
9580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9581 
 
9582 
  def __ne__(self, other):
9583 
    return not (self == other)
9584 
 
9585 
class getBestDeals_result:
9586 
  """
9587 
  Attributes:
9588 
   - success
9589 
   - isex
9590 
  """
9591 
 
9592 
  thrift_spec = (
9593 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9594 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9595 
  )
9596 
 
9597 
  def __init__(self, success=None, isex=None,):
9598 
    self.success = success
9599 
    self.isex = isex
9600 
 
9601 
  def read(self, iprot):
9602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9604 
      return
9605 
    iprot.readStructBegin()
9606 
    while True:
9607 
      (fname, ftype, fid) = iprot.readFieldBegin()
9608 
      if ftype == TType.STOP:
9609 
        break
9610 
      if fid == 0:
9611 
        if ftype == TType.LIST:
9612 
          self.success = []
8590 kshitij.so 9613 
          (_etype105, _size102) = iprot.readListBegin()
9614 
          for _i106 in xrange(_size102):
9615 
            _elem107 = Item()
9616 
            _elem107.read(iprot)
9617 
            self.success.append(_elem107)
5944 mandeep.dh 9618 
          iprot.readListEnd()
9619 
        else:
9620 
          iprot.skip(ftype)
9621 
      elif fid == 1:
9622 
        if ftype == TType.STRUCT:
9623 
          self.isex = CatalogServiceException()
9624 
          self.isex.read(iprot)
9625 
        else:
9626 
          iprot.skip(ftype)
9627 
      else:
9628 
        iprot.skip(ftype)
9629 
      iprot.readFieldEnd()
9630 
    iprot.readStructEnd()
9631 
 
9632 
  def write(self, oprot):
9633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9635 
      return
9636 
    oprot.writeStructBegin('getBestDeals_result')
9637 
    if self.success is not None:
9638 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9639 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9640 
      for iter108 in self.success:
9641 
        iter108.write(oprot)
5944 mandeep.dh 9642 
      oprot.writeListEnd()
9643 
      oprot.writeFieldEnd()
9644 
    if self.isex is not None:
9645 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9646 
      self.isex.write(oprot)
9647 
      oprot.writeFieldEnd()
9648 
    oprot.writeFieldStop()
9649 
    oprot.writeStructEnd()
9650 
 
9651 
  def validate(self):
9652 
    return
9653 
 
9654 
 
9655 
  def __repr__(self):
9656 
    L = ['%s=%r' % (key, value)
9657 
      for key, value in self.__dict__.iteritems()]
9658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9659 
 
9660 
  def __eq__(self, other):
9661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9662 
 
9663 
  def __ne__(self, other):
9664 
    return not (self == other)
9665 
 
9666 
class getBestDealsCatalogIds_args:
9667 
  """
9668 
  Attributes:
9669 
   - beginIndex
9670 
   - totalItems
9671 
   - brand
9672 
   - category
9673 
  """
9674 
 
9675 
  thrift_spec = (
9676 
    None, # 0
9677 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9678 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9679 
    (3, TType.STRING, 'brand', None, None, ), # 3
9680 
    (4, TType.I64, 'category', None, None, ), # 4
9681 
  )
9682 
 
9683 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9684 
    self.beginIndex = beginIndex
9685 
    self.totalItems = totalItems
9686 
    self.brand = brand
9687 
    self.category = category
9688 
 
9689 
  def read(self, iprot):
9690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9692 
      return
9693 
    iprot.readStructBegin()
9694 
    while True:
9695 
      (fname, ftype, fid) = iprot.readFieldBegin()
9696 
      if ftype == TType.STOP:
9697 
        break
9698 
      if fid == 1:
9699 
        if ftype == TType.I64:
9700 
          self.beginIndex = iprot.readI64();
9701 
        else:
9702 
          iprot.skip(ftype)
9703 
      elif fid == 2:
9704 
        if ftype == TType.I64:
9705 
          self.totalItems = iprot.readI64();
9706 
        else:
9707 
          iprot.skip(ftype)
9708 
      elif fid == 3:
9709 
        if ftype == TType.STRING:
9710 
          self.brand = iprot.readString();
9711 
        else:
9712 
          iprot.skip(ftype)
9713 
      elif fid == 4:
9714 
        if ftype == TType.I64:
9715 
          self.category = iprot.readI64();
9716 
        else:
9717 
          iprot.skip(ftype)
9718 
      else:
9719 
        iprot.skip(ftype)
9720 
      iprot.readFieldEnd()
9721 
    iprot.readStructEnd()
9722 
 
9723 
  def write(self, oprot):
9724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9726 
      return
9727 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9728 
    if self.beginIndex is not None:
9729 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9730 
      oprot.writeI64(self.beginIndex)
9731 
      oprot.writeFieldEnd()
9732 
    if self.totalItems is not None:
9733 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9734 
      oprot.writeI64(self.totalItems)
9735 
      oprot.writeFieldEnd()
9736 
    if self.brand is not None:
9737 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9738 
      oprot.writeString(self.brand)
9739 
      oprot.writeFieldEnd()
9740 
    if self.category is not None:
9741 
      oprot.writeFieldBegin('category', TType.I64, 4)
9742 
      oprot.writeI64(self.category)
9743 
      oprot.writeFieldEnd()
9744 
    oprot.writeFieldStop()
9745 
    oprot.writeStructEnd()
9746 
 
9747 
  def validate(self):
9748 
    return
9749 
 
9750 
 
9751 
  def __repr__(self):
9752 
    L = ['%s=%r' % (key, value)
9753 
      for key, value in self.__dict__.iteritems()]
9754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9755 
 
9756 
  def __eq__(self, other):
9757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9758 
 
9759 
  def __ne__(self, other):
9760 
    return not (self == other)
9761 
 
9762 
class getBestDealsCatalogIds_result:
9763 
  """
9764 
  Attributes:
9765 
   - success
9766 
   - cex
9767 
  """
9768 
 
9769 
  thrift_spec = (
9770 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9771 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9772 
  )
9773 
 
9774 
  def __init__(self, success=None, cex=None,):
9775 
    self.success = success
9776 
    self.cex = cex
9777 
 
9778 
  def read(self, iprot):
9779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9781 
      return
9782 
    iprot.readStructBegin()
9783 
    while True:
9784 
      (fname, ftype, fid) = iprot.readFieldBegin()
9785 
      if ftype == TType.STOP:
9786 
        break
9787 
      if fid == 0:
9788 
        if ftype == TType.LIST:
9789 
          self.success = []
8590 kshitij.so 9790 
          (_etype112, _size109) = iprot.readListBegin()
9791 
          for _i113 in xrange(_size109):
9792 
            _elem114 = iprot.readI64();
9793 
            self.success.append(_elem114)
5944 mandeep.dh 9794 
          iprot.readListEnd()
9795 
        else:
9796 
          iprot.skip(ftype)
9797 
      elif fid == 1:
9798 
        if ftype == TType.STRUCT:
9799 
          self.cex = CatalogServiceException()
9800 
          self.cex.read(iprot)
9801 
        else:
9802 
          iprot.skip(ftype)
9803 
      else:
9804 
        iprot.skip(ftype)
9805 
      iprot.readFieldEnd()
9806 
    iprot.readStructEnd()
9807 
 
9808 
  def write(self, oprot):
9809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9811 
      return
9812 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9813 
    if self.success is not None:
9814 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9815 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9816 
      for iter115 in self.success:
9817 
        oprot.writeI64(iter115)
5944 mandeep.dh 9818 
      oprot.writeListEnd()
9819 
      oprot.writeFieldEnd()
9820 
    if self.cex is not None:
9821 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9822 
      self.cex.write(oprot)
9823 
      oprot.writeFieldEnd()
9824 
    oprot.writeFieldStop()
9825 
    oprot.writeStructEnd()
9826 
 
9827 
  def validate(self):
9828 
    return
9829 
 
9830 
 
9831 
  def __repr__(self):
9832 
    L = ['%s=%r' % (key, value)
9833 
      for key, value in self.__dict__.iteritems()]
9834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9835 
 
9836 
  def __eq__(self, other):
9837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9838 
 
9839 
  def __ne__(self, other):
9840 
    return not (self == other)
9841 
 
9842 
class getBestDealsCount_args:
9843 
 
9844 
  thrift_spec = (
9845 
  )
9846 
 
9847 
  def read(self, iprot):
9848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9850 
      return
9851 
    iprot.readStructBegin()
9852 
    while True:
9853 
      (fname, ftype, fid) = iprot.readFieldBegin()
9854 
      if ftype == TType.STOP:
9855 
        break
9856 
      else:
9857 
        iprot.skip(ftype)
9858 
      iprot.readFieldEnd()
9859 
    iprot.readStructEnd()
9860 
 
9861 
  def write(self, oprot):
9862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9864 
      return
9865 
    oprot.writeStructBegin('getBestDealsCount_args')
9866 
    oprot.writeFieldStop()
9867 
    oprot.writeStructEnd()
9868 
 
9869 
  def validate(self):
9870 
    return
9871 
 
9872 
 
9873 
  def __repr__(self):
9874 
    L = ['%s=%r' % (key, value)
9875 
      for key, value in self.__dict__.iteritems()]
9876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9877 
 
9878 
  def __eq__(self, other):
9879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9880 
 
9881 
  def __ne__(self, other):
9882 
    return not (self == other)
9883 
 
9884 
class getBestDealsCount_result:
9885 
  """
9886 
  Attributes:
9887 
   - success
9888 
   - cex
9889 
  """
9890 
 
9891 
  thrift_spec = (
9892 
    (0, TType.I64, 'success', None, None, ), # 0
9893 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9894 
  )
9895 
 
9896 
  def __init__(self, success=None, cex=None,):
9897 
    self.success = success
9898 
    self.cex = cex
9899 
 
9900 
  def read(self, iprot):
9901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9903 
      return
9904 
    iprot.readStructBegin()
9905 
    while True:
9906 
      (fname, ftype, fid) = iprot.readFieldBegin()
9907 
      if ftype == TType.STOP:
9908 
        break
9909 
      if fid == 0:
9910 
        if ftype == TType.I64:
9911 
          self.success = iprot.readI64();
9912 
        else:
9913 
          iprot.skip(ftype)
9914 
      elif fid == 1:
9915 
        if ftype == TType.STRUCT:
9916 
          self.cex = CatalogServiceException()
9917 
          self.cex.read(iprot)
9918 
        else:
9919 
          iprot.skip(ftype)
9920 
      else:
9921 
        iprot.skip(ftype)
9922 
      iprot.readFieldEnd()
9923 
    iprot.readStructEnd()
9924 
 
9925 
  def write(self, oprot):
9926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9928 
      return
9929 
    oprot.writeStructBegin('getBestDealsCount_result')
9930 
    if self.success is not None:
9931 
      oprot.writeFieldBegin('success', TType.I64, 0)
9932 
      oprot.writeI64(self.success)
9933 
      oprot.writeFieldEnd()
9934 
    if self.cex is not None:
9935 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9936 
      self.cex.write(oprot)
9937 
      oprot.writeFieldEnd()
9938 
    oprot.writeFieldStop()
9939 
    oprot.writeStructEnd()
9940 
 
9941 
  def validate(self):
9942 
    return
9943 
 
9944 
 
9945 
  def __repr__(self):
9946 
    L = ['%s=%r' % (key, value)
9947 
      for key, value in self.__dict__.iteritems()]
9948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9949 
 
9950 
  def __eq__(self, other):
9951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9952 
 
9953 
  def __ne__(self, other):
9954 
    return not (self == other)
9955 
 
9956 
class getComingSoon_args:
9957 
 
9958 
  thrift_spec = (
9959 
  )
9960 
 
9961 
  def read(self, iprot):
9962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9964 
      return
9965 
    iprot.readStructBegin()
9966 
    while True:
9967 
      (fname, ftype, fid) = iprot.readFieldBegin()
9968 
      if ftype == TType.STOP:
9969 
        break
9970 
      else:
9971 
        iprot.skip(ftype)
9972 
      iprot.readFieldEnd()
9973 
    iprot.readStructEnd()
9974 
 
9975 
  def write(self, oprot):
9976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9978 
      return
9979 
    oprot.writeStructBegin('getComingSoon_args')
9980 
    oprot.writeFieldStop()
9981 
    oprot.writeStructEnd()
9982 
 
9983 
  def validate(self):
9984 
    return
9985 
 
9986 
 
9987 
  def __repr__(self):
9988 
    L = ['%s=%r' % (key, value)
9989 
      for key, value in self.__dict__.iteritems()]
9990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9991 
 
9992 
  def __eq__(self, other):
9993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9994 
 
9995 
  def __ne__(self, other):
9996 
    return not (self == other)
9997 
 
9998 
class getComingSoon_result:
9999 
  """
10000 
  Attributes:
10001 
   - success
10002 
   - isex
10003 
  """
10004 
 
10005 
  thrift_spec = (
10006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10007 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10008 
  )
10009 
 
10010 
  def __init__(self, success=None, isex=None,):
10011 
    self.success = success
10012 
    self.isex = isex
10013 
 
10014 
  def read(self, iprot):
10015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10017 
      return
10018 
    iprot.readStructBegin()
10019 
    while True:
10020 
      (fname, ftype, fid) = iprot.readFieldBegin()
10021 
      if ftype == TType.STOP:
10022 
        break
10023 
      if fid == 0:
10024 
        if ftype == TType.LIST:
10025 
          self.success = []
8590 kshitij.so 10026 
          (_etype119, _size116) = iprot.readListBegin()
10027 
          for _i120 in xrange(_size116):
10028 
            _elem121 = Item()
10029 
            _elem121.read(iprot)
10030 
            self.success.append(_elem121)
5944 mandeep.dh 10031 
          iprot.readListEnd()
10032 
        else:
10033 
          iprot.skip(ftype)
10034 
      elif fid == 1:
10035 
        if ftype == TType.STRUCT:
10036 
          self.isex = CatalogServiceException()
10037 
          self.isex.read(iprot)
10038 
        else:
10039 
          iprot.skip(ftype)
10040 
      else:
10041 
        iprot.skip(ftype)
10042 
      iprot.readFieldEnd()
10043 
    iprot.readStructEnd()
10044 
 
10045 
  def write(self, oprot):
10046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10048 
      return
10049 
    oprot.writeStructBegin('getComingSoon_result')
10050 
    if self.success is not None:
10051 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10052 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10053 
      for iter122 in self.success:
10054 
        iter122.write(oprot)
5944 mandeep.dh 10055 
      oprot.writeListEnd()
10056 
      oprot.writeFieldEnd()
10057 
    if self.isex is not None:
10058 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10059 
      self.isex.write(oprot)
10060 
      oprot.writeFieldEnd()
10061 
    oprot.writeFieldStop()
10062 
    oprot.writeStructEnd()
10063 
 
10064 
  def validate(self):
10065 
    return
10066 
 
10067 
 
10068 
  def __repr__(self):
10069 
    L = ['%s=%r' % (key, value)
10070 
      for key, value in self.__dict__.iteritems()]
10071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10072 
 
10073 
  def __eq__(self, other):
10074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10075 
 
10076 
  def __ne__(self, other):
10077 
    return not (self == other)
10078 
 
10079 
class getComingSoonCatalogIds_args:
10080 
  """
10081 
  Attributes:
10082 
   - beginIndex
10083 
   - totalItems
10084 
   - brand
10085 
   - category
10086 
  """
10087 
 
10088 
  thrift_spec = (
10089 
    None, # 0
10090 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10091 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10092 
    (3, TType.STRING, 'brand', None, None, ), # 3
10093 
    (4, TType.I64, 'category', None, None, ), # 4
10094 
  )
10095 
 
10096 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
10097 
    self.beginIndex = beginIndex
10098 
    self.totalItems = totalItems
10099 
    self.brand = brand
10100 
    self.category = category
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      if fid == 1:
10112 
        if ftype == TType.I64:
10113 
          self.beginIndex = iprot.readI64();
10114 
        else:
10115 
          iprot.skip(ftype)
10116 
      elif fid == 2:
10117 
        if ftype == TType.I64:
10118 
          self.totalItems = iprot.readI64();
10119 
        else:
10120 
          iprot.skip(ftype)
10121 
      elif fid == 3:
10122 
        if ftype == TType.STRING:
10123 
          self.brand = iprot.readString();
10124 
        else:
10125 
          iprot.skip(ftype)
10126 
      elif fid == 4:
10127 
        if ftype == TType.I64:
10128 
          self.category = iprot.readI64();
10129 
        else:
10130 
          iprot.skip(ftype)
10131 
      else:
10132 
        iprot.skip(ftype)
10133 
      iprot.readFieldEnd()
10134 
    iprot.readStructEnd()
10135 
 
10136 
  def write(self, oprot):
10137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10139 
      return
10140 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
10141 
    if self.beginIndex is not None:
10142 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10143 
      oprot.writeI64(self.beginIndex)
10144 
      oprot.writeFieldEnd()
10145 
    if self.totalItems is not None:
10146 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10147 
      oprot.writeI64(self.totalItems)
10148 
      oprot.writeFieldEnd()
10149 
    if self.brand is not None:
10150 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10151 
      oprot.writeString(self.brand)
10152 
      oprot.writeFieldEnd()
10153 
    if self.category is not None:
10154 
      oprot.writeFieldBegin('category', TType.I64, 4)
10155 
      oprot.writeI64(self.category)
10156 
      oprot.writeFieldEnd()
10157 
    oprot.writeFieldStop()
10158 
    oprot.writeStructEnd()
10159 
 
10160 
  def validate(self):
10161 
    return
10162 
 
10163 
 
10164 
  def __repr__(self):
10165 
    L = ['%s=%r' % (key, value)
10166 
      for key, value in self.__dict__.iteritems()]
10167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10168 
 
10169 
  def __eq__(self, other):
10170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10171 
 
10172 
  def __ne__(self, other):
10173 
    return not (self == other)
10174 
 
10175 
class getComingSoonCatalogIds_result:
10176 
  """
10177 
  Attributes:
10178 
   - success
10179 
   - cex
10180 
  """
10181 
 
10182 
  thrift_spec = (
10183 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10184 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10185 
  )
10186 
 
10187 
  def __init__(self, success=None, cex=None,):
10188 
    self.success = success
10189 
    self.cex = cex
10190 
 
10191 
  def read(self, iprot):
10192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10194 
      return
10195 
    iprot.readStructBegin()
10196 
    while True:
10197 
      (fname, ftype, fid) = iprot.readFieldBegin()
10198 
      if ftype == TType.STOP:
10199 
        break
10200 
      if fid == 0:
10201 
        if ftype == TType.LIST:
10202 
          self.success = []
8590 kshitij.so 10203 
          (_etype126, _size123) = iprot.readListBegin()
10204 
          for _i127 in xrange(_size123):
10205 
            _elem128 = iprot.readI64();
10206 
            self.success.append(_elem128)
5944 mandeep.dh 10207 
          iprot.readListEnd()
10208 
        else:
10209 
          iprot.skip(ftype)
10210 
      elif fid == 1:
10211 
        if ftype == TType.STRUCT:
10212 
          self.cex = CatalogServiceException()
10213 
          self.cex.read(iprot)
10214 
        else:
10215 
          iprot.skip(ftype)
10216 
      else:
10217 
        iprot.skip(ftype)
10218 
      iprot.readFieldEnd()
10219 
    iprot.readStructEnd()
10220 
 
10221 
  def write(self, oprot):
10222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10224 
      return
10225 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
10226 
    if self.success is not None:
10227 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10228 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10229 
      for iter129 in self.success:
10230 
        oprot.writeI64(iter129)
5944 mandeep.dh 10231 
      oprot.writeListEnd()
10232 
      oprot.writeFieldEnd()
10233 
    if self.cex is not None:
10234 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10235 
      self.cex.write(oprot)
10236 
      oprot.writeFieldEnd()
10237 
    oprot.writeFieldStop()
10238 
    oprot.writeStructEnd()
10239 
 
10240 
  def validate(self):
10241 
    return
10242 
 
10243 
 
10244 
  def __repr__(self):
10245 
    L = ['%s=%r' % (key, value)
10246 
      for key, value in self.__dict__.iteritems()]
10247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10248 
 
10249 
  def __eq__(self, other):
10250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10251 
 
10252 
  def __ne__(self, other):
10253 
    return not (self == other)
10254 
 
10255 
class getComingSoonCount_args:
10256 
 
10257 
  thrift_spec = (
10258 
  )
10259 
 
10260 
  def read(self, iprot):
10261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10263 
      return
10264 
    iprot.readStructBegin()
10265 
    while True:
10266 
      (fname, ftype, fid) = iprot.readFieldBegin()
10267 
      if ftype == TType.STOP:
10268 
        break
10269 
      else:
10270 
        iprot.skip(ftype)
10271 
      iprot.readFieldEnd()
10272 
    iprot.readStructEnd()
10273 
 
10274 
  def write(self, oprot):
10275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10277 
      return
10278 
    oprot.writeStructBegin('getComingSoonCount_args')
10279 
    oprot.writeFieldStop()
10280 
    oprot.writeStructEnd()
10281 
 
10282 
  def validate(self):
10283 
    return
10284 
 
10285 
 
10286 
  def __repr__(self):
10287 
    L = ['%s=%r' % (key, value)
10288 
      for key, value in self.__dict__.iteritems()]
10289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10290 
 
10291 
  def __eq__(self, other):
10292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10293 
 
10294 
  def __ne__(self, other):
10295 
    return not (self == other)
10296 
 
10297 
class getComingSoonCount_result:
10298 
  """
10299 
  Attributes:
10300 
   - success
10301 
   - cex
10302 
  """
10303 
 
10304 
  thrift_spec = (
10305 
    (0, TType.I64, 'success', None, None, ), # 0
10306 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10307 
  )
10308 
 
10309 
  def __init__(self, success=None, cex=None,):
10310 
    self.success = success
10311 
    self.cex = cex
10312 
 
10313 
  def read(self, iprot):
10314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10316 
      return
10317 
    iprot.readStructBegin()
10318 
    while True:
10319 
      (fname, ftype, fid) = iprot.readFieldBegin()
10320 
      if ftype == TType.STOP:
10321 
        break
10322 
      if fid == 0:
10323 
        if ftype == TType.I64:
10324 
          self.success = iprot.readI64();
10325 
        else:
10326 
          iprot.skip(ftype)
10327 
      elif fid == 1:
10328 
        if ftype == TType.STRUCT:
10329 
          self.cex = CatalogServiceException()
10330 
          self.cex.read(iprot)
10331 
        else:
10332 
          iprot.skip(ftype)
10333 
      else:
10334 
        iprot.skip(ftype)
10335 
      iprot.readFieldEnd()
10336 
    iprot.readStructEnd()
10337 
 
10338 
  def write(self, oprot):
10339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10341 
      return
10342 
    oprot.writeStructBegin('getComingSoonCount_result')
10343 
    if self.success is not None:
10344 
      oprot.writeFieldBegin('success', TType.I64, 0)
10345 
      oprot.writeI64(self.success)
10346 
      oprot.writeFieldEnd()
10347 
    if self.cex is not None:
10348 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10349 
      self.cex.write(oprot)
10350 
      oprot.writeFieldEnd()
10351 
    oprot.writeFieldStop()
10352 
    oprot.writeStructEnd()
10353 
 
10354 
  def validate(self):
10355 
    return
10356 
 
10357 
 
10358 
  def __repr__(self):
10359 
    L = ['%s=%r' % (key, value)
10360 
      for key, value in self.__dict__.iteritems()]
10361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10362 
 
10363 
  def __eq__(self, other):
10364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10365 
 
10366 
  def __ne__(self, other):
10367 
    return not (self == other)
10368 
 
10369 
class getLatestArrivals_args:
10370 
 
10371 
  thrift_spec = (
10372 
  )
10373 
 
10374 
  def read(self, iprot):
10375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10377 
      return
10378 
    iprot.readStructBegin()
10379 
    while True:
10380 
      (fname, ftype, fid) = iprot.readFieldBegin()
10381 
      if ftype == TType.STOP:
10382 
        break
10383 
      else:
10384 
        iprot.skip(ftype)
10385 
      iprot.readFieldEnd()
10386 
    iprot.readStructEnd()
10387 
 
10388 
  def write(self, oprot):
10389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10391 
      return
10392 
    oprot.writeStructBegin('getLatestArrivals_args')
10393 
    oprot.writeFieldStop()
10394 
    oprot.writeStructEnd()
10395 
 
10396 
  def validate(self):
10397 
    return
10398 
 
10399 
 
10400 
  def __repr__(self):
10401 
    L = ['%s=%r' % (key, value)
10402 
      for key, value in self.__dict__.iteritems()]
10403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10404 
 
10405 
  def __eq__(self, other):
10406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10407 
 
10408 
  def __ne__(self, other):
10409 
    return not (self == other)
10410 
 
10411 
class getLatestArrivals_result:
10412 
  """
10413 
  Attributes:
10414 
   - success
10415 
   - isex
10416 
  """
10417 
 
10418 
  thrift_spec = (
10419 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10420 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10421 
  )
10422 
 
10423 
  def __init__(self, success=None, isex=None,):
10424 
    self.success = success
10425 
    self.isex = isex
10426 
 
10427 
  def read(self, iprot):
10428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10430 
      return
10431 
    iprot.readStructBegin()
10432 
    while True:
10433 
      (fname, ftype, fid) = iprot.readFieldBegin()
10434 
      if ftype == TType.STOP:
10435 
        break
10436 
      if fid == 0:
10437 
        if ftype == TType.LIST:
10438 
          self.success = []
8590 kshitij.so 10439 
          (_etype133, _size130) = iprot.readListBegin()
10440 
          for _i134 in xrange(_size130):
10441 
            _elem135 = Item()
10442 
            _elem135.read(iprot)
10443 
            self.success.append(_elem135)
5944 mandeep.dh 10444 
          iprot.readListEnd()
10445 
        else:
10446 
          iprot.skip(ftype)
10447 
      elif fid == 1:
10448 
        if ftype == TType.STRUCT:
10449 
          self.isex = CatalogServiceException()
10450 
          self.isex.read(iprot)
10451 
        else:
10452 
          iprot.skip(ftype)
10453 
      else:
10454 
        iprot.skip(ftype)
10455 
      iprot.readFieldEnd()
10456 
    iprot.readStructEnd()
10457 
 
10458 
  def write(self, oprot):
10459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10461 
      return
10462 
    oprot.writeStructBegin('getLatestArrivals_result')
10463 
    if self.success is not None:
10464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10465 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10466 
      for iter136 in self.success:
10467 
        iter136.write(oprot)
5944 mandeep.dh 10468 
      oprot.writeListEnd()
10469 
      oprot.writeFieldEnd()
10470 
    if self.isex is not None:
10471 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10472 
      self.isex.write(oprot)
10473 
      oprot.writeFieldEnd()
10474 
    oprot.writeFieldStop()
10475 
    oprot.writeStructEnd()
10476 
 
10477 
  def validate(self):
10478 
    return
10479 
 
10480 
 
10481 
  def __repr__(self):
10482 
    L = ['%s=%r' % (key, value)
10483 
      for key, value in self.__dict__.iteritems()]
10484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10485 
 
10486 
  def __eq__(self, other):
10487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10488 
 
10489 
  def __ne__(self, other):
10490 
    return not (self == other)
10491 
 
10492 
class getLatestArrivalsCatalogIds_args:
10493 
  """
10494 
  Attributes:
10495 
   - beginIndex
10496 
   - totalItems
10497 
   - brand
10498 
   - categories
10499 
  """
10500 
 
10501 
  thrift_spec = (
10502 
    None, # 0
10503 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10504 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10505 
    (3, TType.STRING, 'brand', None, None, ), # 3
10506 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
10507 
  )
10508 
 
10509 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
10510 
    self.beginIndex = beginIndex
10511 
    self.totalItems = totalItems
10512 
    self.brand = brand
10513 
    self.categories = categories
10514 
 
10515 
  def read(self, iprot):
10516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10518 
      return
10519 
    iprot.readStructBegin()
10520 
    while True:
10521 
      (fname, ftype, fid) = iprot.readFieldBegin()
10522 
      if ftype == TType.STOP:
10523 
        break
10524 
      if fid == 1:
10525 
        if ftype == TType.I64:
10526 
          self.beginIndex = iprot.readI64();
10527 
        else:
10528 
          iprot.skip(ftype)
10529 
      elif fid == 2:
10530 
        if ftype == TType.I64:
10531 
          self.totalItems = iprot.readI64();
10532 
        else:
10533 
          iprot.skip(ftype)
10534 
      elif fid == 3:
10535 
        if ftype == TType.STRING:
10536 
          self.brand = iprot.readString();
10537 
        else:
10538 
          iprot.skip(ftype)
10539 
      elif fid == 4:
10540 
        if ftype == TType.LIST:
10541 
          self.categories = []
8590 kshitij.so 10542 
          (_etype140, _size137) = iprot.readListBegin()
10543 
          for _i141 in xrange(_size137):
10544 
            _elem142 = iprot.readI64();
10545 
            self.categories.append(_elem142)
5944 mandeep.dh 10546 
          iprot.readListEnd()
10547 
        else:
10548 
          iprot.skip(ftype)
10549 
      else:
10550 
        iprot.skip(ftype)
10551 
      iprot.readFieldEnd()
10552 
    iprot.readStructEnd()
10553 
 
10554 
  def write(self, oprot):
10555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10557 
      return
10558 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
10559 
    if self.beginIndex is not None:
10560 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10561 
      oprot.writeI64(self.beginIndex)
10562 
      oprot.writeFieldEnd()
10563 
    if self.totalItems is not None:
10564 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10565 
      oprot.writeI64(self.totalItems)
10566 
      oprot.writeFieldEnd()
10567 
    if self.brand is not None:
10568 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10569 
      oprot.writeString(self.brand)
10570 
      oprot.writeFieldEnd()
10571 
    if self.categories is not None:
10572 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
10573 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 10574 
      for iter143 in self.categories:
10575 
        oprot.writeI64(iter143)
5944 mandeep.dh 10576 
      oprot.writeListEnd()
10577 
      oprot.writeFieldEnd()
10578 
    oprot.writeFieldStop()
10579 
    oprot.writeStructEnd()
10580 
 
10581 
  def validate(self):
10582 
    return
10583 
 
10584 
 
10585 
  def __repr__(self):
10586 
    L = ['%s=%r' % (key, value)
10587 
      for key, value in self.__dict__.iteritems()]
10588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10589 
 
10590 
  def __eq__(self, other):
10591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10592 
 
10593 
  def __ne__(self, other):
10594 
    return not (self == other)
10595 
 
10596 
class getLatestArrivalsCatalogIds_result:
10597 
  """
10598 
  Attributes:
10599 
   - success
10600 
   - cex
10601 
  """
10602 
 
10603 
  thrift_spec = (
10604 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10605 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10606 
  )
10607 
 
10608 
  def __init__(self, success=None, cex=None,):
10609 
    self.success = success
10610 
    self.cex = cex
10611 
 
10612 
  def read(self, iprot):
10613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10615 
      return
10616 
    iprot.readStructBegin()
10617 
    while True:
10618 
      (fname, ftype, fid) = iprot.readFieldBegin()
10619 
      if ftype == TType.STOP:
10620 
        break
10621 
      if fid == 0:
10622 
        if ftype == TType.LIST:
10623 
          self.success = []
8590 kshitij.so 10624 
          (_etype147, _size144) = iprot.readListBegin()
10625 
          for _i148 in xrange(_size144):
10626 
            _elem149 = iprot.readI64();
10627 
            self.success.append(_elem149)
5944 mandeep.dh 10628 
          iprot.readListEnd()
10629 
        else:
10630 
          iprot.skip(ftype)
10631 
      elif fid == 1:
10632 
        if ftype == TType.STRUCT:
10633 
          self.cex = CatalogServiceException()
10634 
          self.cex.read(iprot)
10635 
        else:
10636 
          iprot.skip(ftype)
10637 
      else:
10638 
        iprot.skip(ftype)
10639 
      iprot.readFieldEnd()
10640 
    iprot.readStructEnd()
10641 
 
10642 
  def write(self, oprot):
10643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10645 
      return
10646 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
10647 
    if self.success is not None:
10648 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10649 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10650 
      for iter150 in self.success:
10651 
        oprot.writeI64(iter150)
5944 mandeep.dh 10652 
      oprot.writeListEnd()
10653 
      oprot.writeFieldEnd()
10654 
    if self.cex is not None:
10655 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10656 
      self.cex.write(oprot)
10657 
      oprot.writeFieldEnd()
10658 
    oprot.writeFieldStop()
10659 
    oprot.writeStructEnd()
10660 
 
10661 
  def validate(self):
10662 
    return
10663 
 
10664 
 
10665 
  def __repr__(self):
10666 
    L = ['%s=%r' % (key, value)
10667 
      for key, value in self.__dict__.iteritems()]
10668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10669 
 
10670 
  def __eq__(self, other):
10671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10672 
 
10673 
  def __ne__(self, other):
10674 
    return not (self == other)
10675 
 
10676 
class getLatestArrivalsCount_args:
10677 
 
10678 
  thrift_spec = (
10679 
  )
10680 
 
10681 
  def read(self, iprot):
10682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10684 
      return
10685 
    iprot.readStructBegin()
10686 
    while True:
10687 
      (fname, ftype, fid) = iprot.readFieldBegin()
10688 
      if ftype == TType.STOP:
10689 
        break
10690 
      else:
10691 
        iprot.skip(ftype)
10692 
      iprot.readFieldEnd()
10693 
    iprot.readStructEnd()
10694 
 
10695 
  def write(self, oprot):
10696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10698 
      return
10699 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10700 
    oprot.writeFieldStop()
10701 
    oprot.writeStructEnd()
10702 
 
10703 
  def validate(self):
10704 
    return
10705 
 
10706 
 
10707 
  def __repr__(self):
10708 
    L = ['%s=%r' % (key, value)
10709 
      for key, value in self.__dict__.iteritems()]
10710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10711 
 
10712 
  def __eq__(self, other):
10713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10714 
 
10715 
  def __ne__(self, other):
10716 
    return not (self == other)
10717 
 
10718 
class getLatestArrivalsCount_result:
10719 
  """
10720 
  Attributes:
10721 
   - success
10722 
   - cex
10723 
  """
10724 
 
10725 
  thrift_spec = (
10726 
    (0, TType.I64, 'success', None, None, ), # 0
10727 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10728 
  )
10729 
 
10730 
  def __init__(self, success=None, cex=None,):
10731 
    self.success = success
10732 
    self.cex = cex
10733 
 
10734 
  def read(self, iprot):
10735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10737 
      return
10738 
    iprot.readStructBegin()
10739 
    while True:
10740 
      (fname, ftype, fid) = iprot.readFieldBegin()
10741 
      if ftype == TType.STOP:
10742 
        break
10743 
      if fid == 0:
10744 
        if ftype == TType.I64:
10745 
          self.success = iprot.readI64();
10746 
        else:
10747 
          iprot.skip(ftype)
10748 
      elif fid == 1:
10749 
        if ftype == TType.STRUCT:
10750 
          self.cex = CatalogServiceException()
10751 
          self.cex.read(iprot)
10752 
        else:
10753 
          iprot.skip(ftype)
10754 
      else:
10755 
        iprot.skip(ftype)
10756 
      iprot.readFieldEnd()
10757 
    iprot.readStructEnd()
10758 
 
10759 
  def write(self, oprot):
10760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10762 
      return
10763 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10764 
    if self.success is not None:
10765 
      oprot.writeFieldBegin('success', TType.I64, 0)
10766 
      oprot.writeI64(self.success)
10767 
      oprot.writeFieldEnd()
10768 
    if self.cex is not None:
10769 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10770 
      self.cex.write(oprot)
10771 
      oprot.writeFieldEnd()
10772 
    oprot.writeFieldStop()
10773 
    oprot.writeStructEnd()
10774 
 
10775 
  def validate(self):
10776 
    return
10777 
 
10778 
 
10779 
  def __repr__(self):
10780 
    L = ['%s=%r' % (key, value)
10781 
      for key, value in self.__dict__.iteritems()]
10782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10783 
 
10784 
  def __eq__(self, other):
10785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10786 
 
10787 
  def __ne__(self, other):
10788 
    return not (self == other)
10789 
 
10790 
class generateNewEntityID_args:
10791 
 
10792 
  thrift_spec = (
10793 
  )
10794 
 
10795 
  def read(self, iprot):
10796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10798 
      return
10799 
    iprot.readStructBegin()
10800 
    while True:
10801 
      (fname, ftype, fid) = iprot.readFieldBegin()
10802 
      if ftype == TType.STOP:
10803 
        break
10804 
      else:
10805 
        iprot.skip(ftype)
10806 
      iprot.readFieldEnd()
10807 
    iprot.readStructEnd()
10808 
 
10809 
  def write(self, oprot):
10810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10812 
      return
10813 
    oprot.writeStructBegin('generateNewEntityID_args')
10814 
    oprot.writeFieldStop()
10815 
    oprot.writeStructEnd()
10816 
 
10817 
  def validate(self):
10818 
    return
10819 
 
10820 
 
10821 
  def __repr__(self):
10822 
    L = ['%s=%r' % (key, value)
10823 
      for key, value in self.__dict__.iteritems()]
10824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10825 
 
10826 
  def __eq__(self, other):
10827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10828 
 
10829 
  def __ne__(self, other):
10830 
    return not (self == other)
10831 
 
10832 
class generateNewEntityID_result:
10833 
  """
10834 
  Attributes:
10835 
   - success
10836 
  """
10837 
 
10838 
  thrift_spec = (
10839 
    (0, TType.I64, 'success', None, None, ), # 0
10840 
  )
10841 
 
10842 
  def __init__(self, success=None,):
10843 
    self.success = success
10844 
 
10845 
  def read(self, iprot):
10846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10848 
      return
10849 
    iprot.readStructBegin()
10850 
    while True:
10851 
      (fname, ftype, fid) = iprot.readFieldBegin()
10852 
      if ftype == TType.STOP:
10853 
        break
10854 
      if fid == 0:
10855 
        if ftype == TType.I64:
10856 
          self.success = iprot.readI64();
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('generateNewEntityID_result')
10869 
    if self.success is not None:
10870 
      oprot.writeFieldBegin('success', TType.I64, 0)
10871 
      oprot.writeI64(self.success)
10872 
      oprot.writeFieldEnd()
10873 
    oprot.writeFieldStop()
10874 
    oprot.writeStructEnd()
10875 
 
10876 
  def validate(self):
10877 
    return
10878 
 
10879 
 
10880 
  def __repr__(self):
10881 
    L = ['%s=%r' % (key, value)
10882 
      for key, value in self.__dict__.iteritems()]
10883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10884 
 
10885 
  def __eq__(self, other):
10886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10887 
 
10888 
  def __ne__(self, other):
10889 
    return not (self == other)
10890 
 
10891 
class addCategory_args:
10892 
  """
10893 
  Attributes:
10894 
   - category
10895 
  """
10896 
 
10897 
  thrift_spec = (
10898 
    None, # 0
10899 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10900 
  )
10901 
 
10902 
  def __init__(self, category=None,):
10903 
    self.category = category
10904 
 
10905 
  def read(self, iprot):
10906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10908 
      return
10909 
    iprot.readStructBegin()
10910 
    while True:
10911 
      (fname, ftype, fid) = iprot.readFieldBegin()
10912 
      if ftype == TType.STOP:
10913 
        break
10914 
      if fid == 1:
10915 
        if ftype == TType.STRUCT:
10916 
          self.category = Category()
10917 
          self.category.read(iprot)
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
10929 
    oprot.writeStructBegin('addCategory_args')
10930 
    if self.category is not None:
10931 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10932 
      self.category.write(oprot)
10933 
      oprot.writeFieldEnd()
10934 
    oprot.writeFieldStop()
10935 
    oprot.writeStructEnd()
10936 
 
10937 
  def validate(self):
10938 
    return
10939 
 
10940 
 
10941 
  def __repr__(self):
10942 
    L = ['%s=%r' % (key, value)
10943 
      for key, value in self.__dict__.iteritems()]
10944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10945 
 
10946 
  def __eq__(self, other):
10947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10948 
 
10949 
  def __ne__(self, other):
10950 
    return not (self == other)
10951 
 
10952 
class addCategory_result:
10953 
  """
10954 
  Attributes:
10955 
   - success
10956 
  """
10957 
 
10958 
  thrift_spec = (
10959 
    (0, TType.BOOL, 'success', None, None, ), # 0
10960 
  )
10961 
 
10962 
  def __init__(self, success=None,):
10963 
    self.success = success
10964 
 
10965 
  def read(self, iprot):
10966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10968 
      return
10969 
    iprot.readStructBegin()
10970 
    while True:
10971 
      (fname, ftype, fid) = iprot.readFieldBegin()
10972 
      if ftype == TType.STOP:
10973 
        break
10974 
      if fid == 0:
10975 
        if ftype == TType.BOOL:
10976 
          self.success = iprot.readBool();
10977 
        else:
10978 
          iprot.skip(ftype)
10979 
      else:
10980 
        iprot.skip(ftype)
10981 
      iprot.readFieldEnd()
10982 
    iprot.readStructEnd()
10983 
 
10984 
  def write(self, oprot):
10985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10987 
      return
10988 
    oprot.writeStructBegin('addCategory_result')
10989 
    if self.success is not None:
10990 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10991 
      oprot.writeBool(self.success)
10992 
      oprot.writeFieldEnd()
10993 
    oprot.writeFieldStop()
10994 
    oprot.writeStructEnd()
10995 
 
10996 
  def validate(self):
10997 
    return
10998 
 
10999 
 
11000 
  def __repr__(self):
11001 
    L = ['%s=%r' % (key, value)
11002 
      for key, value in self.__dict__.iteritems()]
11003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11004 
 
11005 
  def __eq__(self, other):
11006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11007 
 
11008 
  def __ne__(self, other):
11009 
    return not (self == other)
11010 
 
11011 
class getCategory_args:
11012 
  """
11013 
  Attributes:
11014 
   - id
11015 
  """
11016 
 
11017 
  thrift_spec = (
11018 
    None, # 0
11019 
    (1, TType.I64, 'id', None, None, ), # 1
11020 
  )
11021 
 
11022 
  def __init__(self, id=None,):
11023 
    self.id = id
11024 
 
11025 
  def read(self, iprot):
11026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11028 
      return
11029 
    iprot.readStructBegin()
11030 
    while True:
11031 
      (fname, ftype, fid) = iprot.readFieldBegin()
11032 
      if ftype == TType.STOP:
11033 
        break
11034 
      if fid == 1:
11035 
        if ftype == TType.I64:
11036 
          self.id = iprot.readI64();
11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      else:
11040 
        iprot.skip(ftype)
11041 
      iprot.readFieldEnd()
11042 
    iprot.readStructEnd()
11043 
 
11044 
  def write(self, oprot):
11045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11047 
      return
11048 
    oprot.writeStructBegin('getCategory_args')
11049 
    if self.id is not None:
11050 
      oprot.writeFieldBegin('id', TType.I64, 1)
11051 
      oprot.writeI64(self.id)
11052 
      oprot.writeFieldEnd()
11053 
    oprot.writeFieldStop()
11054 
    oprot.writeStructEnd()
11055 
 
11056 
  def validate(self):
11057 
    return
11058 
 
11059 
 
11060 
  def __repr__(self):
11061 
    L = ['%s=%r' % (key, value)
11062 
      for key, value in self.__dict__.iteritems()]
11063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11064 
 
11065 
  def __eq__(self, other):
11066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11067 
 
11068 
  def __ne__(self, other):
11069 
    return not (self == other)
11070 
 
11071 
class getCategory_result:
11072 
  """
11073 
  Attributes:
11074 
   - success
11075 
  """
11076 
 
11077 
  thrift_spec = (
11078 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
11079 
  )
11080 
 
11081 
  def __init__(self, success=None,):
11082 
    self.success = success
11083 
 
11084 
  def read(self, iprot):
11085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11087 
      return
11088 
    iprot.readStructBegin()
11089 
    while True:
11090 
      (fname, ftype, fid) = iprot.readFieldBegin()
11091 
      if ftype == TType.STOP:
11092 
        break
11093 
      if fid == 0:
11094 
        if ftype == TType.STRUCT:
11095 
          self.success = Category()
11096 
          self.success.read(iprot)
11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      else:
11100 
        iprot.skip(ftype)
11101 
      iprot.readFieldEnd()
11102 
    iprot.readStructEnd()
11103 
 
11104 
  def write(self, oprot):
11105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11107 
      return
11108 
    oprot.writeStructBegin('getCategory_result')
11109 
    if self.success is not None:
11110 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11111 
      self.success.write(oprot)
11112 
      oprot.writeFieldEnd()
11113 
    oprot.writeFieldStop()
11114 
    oprot.writeStructEnd()
11115 
 
11116 
  def validate(self):
11117 
    return
11118 
 
11119 
 
11120 
  def __repr__(self):
11121 
    L = ['%s=%r' % (key, value)
11122 
      for key, value in self.__dict__.iteritems()]
11123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11124 
 
11125 
  def __eq__(self, other):
11126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11127 
 
11128 
  def __ne__(self, other):
11129 
    return not (self == other)
11130 
 
11131 
class getAllCategories_args:
11132 
 
11133 
  thrift_spec = (
11134 
  )
11135 
 
11136 
  def read(self, iprot):
11137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11139 
      return
11140 
    iprot.readStructBegin()
11141 
    while True:
11142 
      (fname, ftype, fid) = iprot.readFieldBegin()
11143 
      if ftype == TType.STOP:
11144 
        break
11145 
      else:
11146 
        iprot.skip(ftype)
11147 
      iprot.readFieldEnd()
11148 
    iprot.readStructEnd()
11149 
 
11150 
  def write(self, oprot):
11151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11153 
      return
11154 
    oprot.writeStructBegin('getAllCategories_args')
11155 
    oprot.writeFieldStop()
11156 
    oprot.writeStructEnd()
11157 
 
11158 
  def validate(self):
11159 
    return
11160 
 
11161 
 
11162 
  def __repr__(self):
11163 
    L = ['%s=%r' % (key, value)
11164 
      for key, value in self.__dict__.iteritems()]
11165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11166 
 
11167 
  def __eq__(self, other):
11168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11169 
 
11170 
  def __ne__(self, other):
11171 
    return not (self == other)
11172 
 
11173 
class getAllCategories_result:
11174 
  """
11175 
  Attributes:
11176 
   - success
11177 
  """
11178 
 
11179 
  thrift_spec = (
11180 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
11181 
  )
11182 
 
11183 
  def __init__(self, success=None,):
11184 
    self.success = success
11185 
 
11186 
  def read(self, iprot):
11187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11189 
      return
11190 
    iprot.readStructBegin()
11191 
    while True:
11192 
      (fname, ftype, fid) = iprot.readFieldBegin()
11193 
      if ftype == TType.STOP:
11194 
        break
11195 
      if fid == 0:
11196 
        if ftype == TType.LIST:
11197 
          self.success = []
8590 kshitij.so 11198 
          (_etype154, _size151) = iprot.readListBegin()
11199 
          for _i155 in xrange(_size151):
11200 
            _elem156 = Category()
11201 
            _elem156.read(iprot)
11202 
            self.success.append(_elem156)
5944 mandeep.dh 11203 
          iprot.readListEnd()
11204 
        else:
11205 
          iprot.skip(ftype)
11206 
      else:
11207 
        iprot.skip(ftype)
11208 
      iprot.readFieldEnd()
11209 
    iprot.readStructEnd()
11210 
 
11211 
  def write(self, oprot):
11212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11214 
      return
11215 
    oprot.writeStructBegin('getAllCategories_result')
11216 
    if self.success is not None:
11217 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11218 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11219 
      for iter157 in self.success:
11220 
        iter157.write(oprot)
5944 mandeep.dh 11221 
      oprot.writeListEnd()
11222 
      oprot.writeFieldEnd()
11223 
    oprot.writeFieldStop()
11224 
    oprot.writeStructEnd()
11225 
 
11226 
  def validate(self):
11227 
    return
11228 
 
11229 
 
11230 
  def __repr__(self):
11231 
    L = ['%s=%r' % (key, value)
11232 
      for key, value in self.__dict__.iteritems()]
11233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11234 
 
11235 
  def __eq__(self, other):
11236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11237 
 
11238 
  def __ne__(self, other):
11239 
    return not (self == other)
11240 
 
11241 
class getAllSimilarItems_args:
11242 
  """
11243 
  Attributes:
11244 
   - itemId
11245 
  """
11246 
 
11247 
  thrift_spec = (
11248 
    None, # 0
11249 
    (1, TType.I64, 'itemId', None, None, ), # 1
11250 
  )
11251 
 
11252 
  def __init__(self, itemId=None,):
11253 
    self.itemId = itemId
11254 
 
11255 
  def read(self, iprot):
11256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11258 
      return
11259 
    iprot.readStructBegin()
11260 
    while True:
11261 
      (fname, ftype, fid) = iprot.readFieldBegin()
11262 
      if ftype == TType.STOP:
11263 
        break
11264 
      if fid == 1:
11265 
        if ftype == TType.I64:
11266 
          self.itemId = iprot.readI64();
11267 
        else:
11268 
          iprot.skip(ftype)
11269 
      else:
11270 
        iprot.skip(ftype)
11271 
      iprot.readFieldEnd()
11272 
    iprot.readStructEnd()
11273 
 
11274 
  def write(self, oprot):
11275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11277 
      return
11278 
    oprot.writeStructBegin('getAllSimilarItems_args')
11279 
    if self.itemId is not None:
11280 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11281 
      oprot.writeI64(self.itemId)
11282 
      oprot.writeFieldEnd()
11283 
    oprot.writeFieldStop()
11284 
    oprot.writeStructEnd()
11285 
 
11286 
  def validate(self):
11287 
    return
11288 
 
11289 
 
11290 
  def __repr__(self):
11291 
    L = ['%s=%r' % (key, value)
11292 
      for key, value in self.__dict__.iteritems()]
11293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11294 
 
11295 
  def __eq__(self, other):
11296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11297 
 
11298 
  def __ne__(self, other):
11299 
    return not (self == other)
11300 
 
11301 
class getAllSimilarItems_result:
11302 
  """
11303 
  Attributes:
11304 
   - success
11305 
  """
11306 
 
11307 
  thrift_spec = (
11308 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11309 
  )
11310 
 
11311 
  def __init__(self, success=None,):
11312 
    self.success = success
11313 
 
11314 
  def read(self, iprot):
11315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11317 
      return
11318 
    iprot.readStructBegin()
11319 
    while True:
11320 
      (fname, ftype, fid) = iprot.readFieldBegin()
11321 
      if ftype == TType.STOP:
11322 
        break
11323 
      if fid == 0:
11324 
        if ftype == TType.LIST:
11325 
          self.success = []
8590 kshitij.so 11326 
          (_etype161, _size158) = iprot.readListBegin()
11327 
          for _i162 in xrange(_size158):
11328 
            _elem163 = Item()
11329 
            _elem163.read(iprot)
11330 
            self.success.append(_elem163)
5944 mandeep.dh 11331 
          iprot.readListEnd()
11332 
        else:
11333 
          iprot.skip(ftype)
11334 
      else:
11335 
        iprot.skip(ftype)
11336 
      iprot.readFieldEnd()
11337 
    iprot.readStructEnd()
11338 
 
11339 
  def write(self, oprot):
11340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11342 
      return
11343 
    oprot.writeStructBegin('getAllSimilarItems_result')
11344 
    if self.success is not None:
11345 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11346 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11347 
      for iter164 in self.success:
11348 
        iter164.write(oprot)
5944 mandeep.dh 11349 
      oprot.writeListEnd()
11350 
      oprot.writeFieldEnd()
11351 
    oprot.writeFieldStop()
11352 
    oprot.writeStructEnd()
11353 
 
11354 
  def validate(self):
11355 
    return
11356 
 
11357 
 
11358 
  def __repr__(self):
11359 
    L = ['%s=%r' % (key, value)
11360 
      for key, value in self.__dict__.iteritems()]
11361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11362 
 
11363 
  def __eq__(self, other):
11364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11365 
 
11366 
  def __ne__(self, other):
11367 
    return not (self == other)
11368 
 
11369 
class addSimilarItem_args:
11370 
  """
11371 
  Attributes:
11372 
   - itemId
11373 
   - catalogItemId
11374 
  """
11375 
 
11376 
  thrift_spec = (
11377 
    None, # 0
11378 
    (1, TType.I64, 'itemId', None, None, ), # 1
11379 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11380 
  )
11381 
 
11382 
  def __init__(self, itemId=None, catalogItemId=None,):
11383 
    self.itemId = itemId
11384 
    self.catalogItemId = catalogItemId
11385 
 
11386 
  def read(self, iprot):
11387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11389 
      return
11390 
    iprot.readStructBegin()
11391 
    while True:
11392 
      (fname, ftype, fid) = iprot.readFieldBegin()
11393 
      if ftype == TType.STOP:
11394 
        break
11395 
      if fid == 1:
11396 
        if ftype == TType.I64:
11397 
          self.itemId = iprot.readI64();
11398 
        else:
11399 
          iprot.skip(ftype)
11400 
      elif fid == 2:
11401 
        if ftype == TType.I64:
11402 
          self.catalogItemId = iprot.readI64();
11403 
        else:
11404 
          iprot.skip(ftype)
11405 
      else:
11406 
        iprot.skip(ftype)
11407 
      iprot.readFieldEnd()
11408 
    iprot.readStructEnd()
11409 
 
11410 
  def write(self, oprot):
11411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11413 
      return
11414 
    oprot.writeStructBegin('addSimilarItem_args')
11415 
    if self.itemId is not None:
11416 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11417 
      oprot.writeI64(self.itemId)
11418 
      oprot.writeFieldEnd()
11419 
    if self.catalogItemId is not None:
11420 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11421 
      oprot.writeI64(self.catalogItemId)
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 addSimilarItem_result:
11442 
  """
11443 
  Attributes:
11444 
   - success
11445 
   - cex
11446 
  """
11447 
 
11448 
  thrift_spec = (
11449 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11450 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11451 
  )
11452 
 
11453 
  def __init__(self, success=None, cex=None,):
11454 
    self.success = success
11455 
    self.cex = cex
11456 
 
11457 
  def read(self, iprot):
11458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11460 
      return
11461 
    iprot.readStructBegin()
11462 
    while True:
11463 
      (fname, ftype, fid) = iprot.readFieldBegin()
11464 
      if ftype == TType.STOP:
11465 
        break
11466 
      if fid == 0:
11467 
        if ftype == TType.STRUCT:
11468 
          self.success = Item()
11469 
          self.success.read(iprot)
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      elif fid == 1:
11473 
        if ftype == TType.STRUCT:
11474 
          self.cex = CatalogServiceException()
11475 
          self.cex.read(iprot)
11476 
        else:
11477 
          iprot.skip(ftype)
11478 
      else:
11479 
        iprot.skip(ftype)
11480 
      iprot.readFieldEnd()
11481 
    iprot.readStructEnd()
11482 
 
11483 
  def write(self, oprot):
11484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11486 
      return
11487 
    oprot.writeStructBegin('addSimilarItem_result')
11488 
    if self.success is not None:
11489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11490 
      self.success.write(oprot)
11491 
      oprot.writeFieldEnd()
11492 
    if self.cex is not None:
11493 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11494 
      self.cex.write(oprot)
11495 
      oprot.writeFieldEnd()
11496 
    oprot.writeFieldStop()
11497 
    oprot.writeStructEnd()
11498 
 
11499 
  def validate(self):
11500 
    return
11501 
 
11502 
 
11503 
  def __repr__(self):
11504 
    L = ['%s=%r' % (key, value)
11505 
      for key, value in self.__dict__.iteritems()]
11506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11507 
 
11508 
  def __eq__(self, other):
11509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11510 
 
11511 
  def __ne__(self, other):
11512 
    return not (self == other)
11513 
 
6512 kshitij.so 11514 
class addTag_args:
11515 
  """
11516 
  Attributes:
11517 
   - displayName
11518 
   - itemId
11519 
  """
11520 
 
11521 
  thrift_spec = (
11522 
    None, # 0
11523 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11524 
    (2, TType.I64, 'itemId', None, None, ), # 2
11525 
  )
11526 
 
11527 
  def __init__(self, displayName=None, itemId=None,):
11528 
    self.displayName = displayName
11529 
    self.itemId = itemId
11530 
 
11531 
  def read(self, iprot):
11532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11534 
      return
11535 
    iprot.readStructBegin()
11536 
    while True:
11537 
      (fname, ftype, fid) = iprot.readFieldBegin()
11538 
      if ftype == TType.STOP:
11539 
        break
11540 
      if fid == 1:
11541 
        if ftype == TType.STRING:
11542 
          self.displayName = iprot.readString();
11543 
        else:
11544 
          iprot.skip(ftype)
11545 
      elif fid == 2:
11546 
        if ftype == TType.I64:
11547 
          self.itemId = iprot.readI64();
11548 
        else:
11549 
          iprot.skip(ftype)
11550 
      else:
11551 
        iprot.skip(ftype)
11552 
      iprot.readFieldEnd()
11553 
    iprot.readStructEnd()
11554 
 
11555 
  def write(self, oprot):
11556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11558 
      return
11559 
    oprot.writeStructBegin('addTag_args')
11560 
    if self.displayName is not None:
11561 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11562 
      oprot.writeString(self.displayName)
11563 
      oprot.writeFieldEnd()
11564 
    if self.itemId is not None:
11565 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11566 
      oprot.writeI64(self.itemId)
11567 
      oprot.writeFieldEnd()
11568 
    oprot.writeFieldStop()
11569 
    oprot.writeStructEnd()
11570 
 
11571 
  def validate(self):
11572 
    return
11573 
 
11574 
 
11575 
  def __repr__(self):
11576 
    L = ['%s=%r' % (key, value)
11577 
      for key, value in self.__dict__.iteritems()]
11578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11579 
 
11580 
  def __eq__(self, other):
11581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11582 
 
11583 
  def __ne__(self, other):
11584 
    return not (self == other)
11585 
 
11586 
class addTag_result:
11587 
  """
11588 
  Attributes:
11589 
   - success
11590 
  """
11591 
 
11592 
  thrift_spec = (
11593 
    (0, TType.BOOL, 'success', None, None, ), # 0
11594 
  )
11595 
 
11596 
  def __init__(self, success=None,):
11597 
    self.success = success
11598 
 
11599 
  def read(self, iprot):
11600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11602 
      return
11603 
    iprot.readStructBegin()
11604 
    while True:
11605 
      (fname, ftype, fid) = iprot.readFieldBegin()
11606 
      if ftype == TType.STOP:
11607 
        break
11608 
      if fid == 0:
11609 
        if ftype == TType.BOOL:
11610 
          self.success = iprot.readBool();
11611 
        else:
11612 
          iprot.skip(ftype)
11613 
      else:
11614 
        iprot.skip(ftype)
11615 
      iprot.readFieldEnd()
11616 
    iprot.readStructEnd()
11617 
 
11618 
  def write(self, oprot):
11619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11621 
      return
11622 
    oprot.writeStructBegin('addTag_result')
11623 
    if self.success is not None:
11624 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11625 
      oprot.writeBool(self.success)
11626 
      oprot.writeFieldEnd()
11627 
    oprot.writeFieldStop()
11628 
    oprot.writeStructEnd()
11629 
 
11630 
  def validate(self):
11631 
    return
11632 
 
11633 
 
11634 
  def __repr__(self):
11635 
    L = ['%s=%r' % (key, value)
11636 
      for key, value in self.__dict__.iteritems()]
11637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11638 
 
11639 
  def __eq__(self, other):
11640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11641 
 
11642 
  def __ne__(self, other):
11643 
    return not (self == other)
11644 
 
11645 
class deleteEntityTag_args:
11646 
  """
11647 
  Attributes:
11648 
   - displayName
11649 
   - itemId
11650 
  """
11651 
 
11652 
  thrift_spec = (
11653 
    None, # 0
11654 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11655 
    (2, TType.I64, 'itemId', None, None, ), # 2
11656 
  )
11657 
 
11658 
  def __init__(self, displayName=None, itemId=None,):
11659 
    self.displayName = displayName
11660 
    self.itemId = itemId
11661 
 
11662 
  def read(self, iprot):
11663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11665 
      return
11666 
    iprot.readStructBegin()
11667 
    while True:
11668 
      (fname, ftype, fid) = iprot.readFieldBegin()
11669 
      if ftype == TType.STOP:
11670 
        break
11671 
      if fid == 1:
11672 
        if ftype == TType.STRING:
11673 
          self.displayName = iprot.readString();
11674 
        else:
11675 
          iprot.skip(ftype)
11676 
      elif fid == 2:
11677 
        if ftype == TType.I64:
11678 
          self.itemId = iprot.readI64();
11679 
        else:
11680 
          iprot.skip(ftype)
11681 
      else:
11682 
        iprot.skip(ftype)
11683 
      iprot.readFieldEnd()
11684 
    iprot.readStructEnd()
11685 
 
11686 
  def write(self, oprot):
11687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11689 
      return
11690 
    oprot.writeStructBegin('deleteEntityTag_args')
11691 
    if self.displayName is not None:
11692 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11693 
      oprot.writeString(self.displayName)
11694 
      oprot.writeFieldEnd()
11695 
    if self.itemId is not None:
11696 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11697 
      oprot.writeI64(self.itemId)
11698 
      oprot.writeFieldEnd()
11699 
    oprot.writeFieldStop()
11700 
    oprot.writeStructEnd()
11701 
 
11702 
  def validate(self):
11703 
    return
11704 
 
11705 
 
11706 
  def __repr__(self):
11707 
    L = ['%s=%r' % (key, value)
11708 
      for key, value in self.__dict__.iteritems()]
11709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11710 
 
11711 
  def __eq__(self, other):
11712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11713 
 
11714 
  def __ne__(self, other):
11715 
    return not (self == other)
11716 
 
11717 
class deleteEntityTag_result:
11718 
  """
11719 
  Attributes:
11720 
   - success
11721 
  """
11722 
 
11723 
  thrift_spec = (
11724 
    (0, TType.BOOL, 'success', None, None, ), # 0
11725 
  )
11726 
 
11727 
  def __init__(self, success=None,):
11728 
    self.success = success
11729 
 
11730 
  def read(self, iprot):
11731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11733 
      return
11734 
    iprot.readStructBegin()
11735 
    while True:
11736 
      (fname, ftype, fid) = iprot.readFieldBegin()
11737 
      if ftype == TType.STOP:
11738 
        break
11739 
      if fid == 0:
11740 
        if ftype == TType.BOOL:
11741 
          self.success = iprot.readBool();
11742 
        else:
11743 
          iprot.skip(ftype)
11744 
      else:
11745 
        iprot.skip(ftype)
11746 
      iprot.readFieldEnd()
11747 
    iprot.readStructEnd()
11748 
 
11749 
  def write(self, oprot):
11750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11752 
      return
11753 
    oprot.writeStructBegin('deleteEntityTag_result')
11754 
    if self.success is not None:
11755 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11756 
      oprot.writeBool(self.success)
11757 
      oprot.writeFieldEnd()
11758 
    oprot.writeFieldStop()
11759 
    oprot.writeStructEnd()
11760 
 
11761 
  def validate(self):
11762 
    return
11763 
 
11764 
 
11765 
  def __repr__(self):
11766 
    L = ['%s=%r' % (key, value)
11767 
      for key, value in self.__dict__.iteritems()]
11768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11769 
 
11770 
  def __eq__(self, other):
11771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11772 
 
11773 
  def __ne__(self, other):
11774 
    return not (self == other)
11775 
 
11776 
class deleteTag_args:
11777 
  """
11778 
  Attributes:
11779 
   - displayName
11780 
  """
11781 
 
11782 
  thrift_spec = (
11783 
    None, # 0
11784 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11785 
  )
11786 
 
11787 
  def __init__(self, displayName=None,):
11788 
    self.displayName = displayName
11789 
 
11790 
  def read(self, iprot):
11791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11793 
      return
11794 
    iprot.readStructBegin()
11795 
    while True:
11796 
      (fname, ftype, fid) = iprot.readFieldBegin()
11797 
      if ftype == TType.STOP:
11798 
        break
11799 
      if fid == 1:
11800 
        if ftype == TType.STRING:
11801 
          self.displayName = iprot.readString();
11802 
        else:
11803 
          iprot.skip(ftype)
11804 
      else:
11805 
        iprot.skip(ftype)
11806 
      iprot.readFieldEnd()
11807 
    iprot.readStructEnd()
11808 
 
11809 
  def write(self, oprot):
11810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11812 
      return
11813 
    oprot.writeStructBegin('deleteTag_args')
11814 
    if self.displayName is not None:
11815 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11816 
      oprot.writeString(self.displayName)
11817 
      oprot.writeFieldEnd()
11818 
    oprot.writeFieldStop()
11819 
    oprot.writeStructEnd()
11820 
 
11821 
  def validate(self):
11822 
    return
11823 
 
11824 
 
11825 
  def __repr__(self):
11826 
    L = ['%s=%r' % (key, value)
11827 
      for key, value in self.__dict__.iteritems()]
11828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11829 
 
11830 
  def __eq__(self, other):
11831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11832 
 
11833 
  def __ne__(self, other):
11834 
    return not (self == other)
11835 
 
11836 
class deleteTag_result:
11837 
  """
11838 
  Attributes:
11839 
   - success
11840 
  """
11841 
 
11842 
  thrift_spec = (
11843 
    (0, TType.BOOL, 'success', None, None, ), # 0
11844 
  )
11845 
 
11846 
  def __init__(self, success=None,):
11847 
    self.success = success
11848 
 
11849 
  def read(self, iprot):
11850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11852 
      return
11853 
    iprot.readStructBegin()
11854 
    while True:
11855 
      (fname, ftype, fid) = iprot.readFieldBegin()
11856 
      if ftype == TType.STOP:
11857 
        break
11858 
      if fid == 0:
11859 
        if ftype == TType.BOOL:
11860 
          self.success = iprot.readBool();
11861 
        else:
11862 
          iprot.skip(ftype)
11863 
      else:
11864 
        iprot.skip(ftype)
11865 
      iprot.readFieldEnd()
11866 
    iprot.readStructEnd()
11867 
 
11868 
  def write(self, oprot):
11869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11871 
      return
11872 
    oprot.writeStructBegin('deleteTag_result')
11873 
    if self.success is not None:
11874 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11875 
      oprot.writeBool(self.success)
11876 
      oprot.writeFieldEnd()
11877 
    oprot.writeFieldStop()
11878 
    oprot.writeStructEnd()
11879 
 
11880 
  def validate(self):
11881 
    return
11882 
 
11883 
 
11884 
  def __repr__(self):
11885 
    L = ['%s=%r' % (key, value)
11886 
      for key, value in self.__dict__.iteritems()]
11887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11888 
 
11889 
  def __eq__(self, other):
11890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11891 
 
11892 
  def __ne__(self, other):
11893 
    return not (self == other)
11894 
 
11895 
class getAllTags_args:
11896 
 
11897 
  thrift_spec = (
11898 
  )
11899 
 
11900 
  def read(self, iprot):
11901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11903 
      return
11904 
    iprot.readStructBegin()
11905 
    while True:
11906 
      (fname, ftype, fid) = iprot.readFieldBegin()
11907 
      if ftype == TType.STOP:
11908 
        break
11909 
      else:
11910 
        iprot.skip(ftype)
11911 
      iprot.readFieldEnd()
11912 
    iprot.readStructEnd()
11913 
 
11914 
  def write(self, oprot):
11915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11917 
      return
11918 
    oprot.writeStructBegin('getAllTags_args')
11919 
    oprot.writeFieldStop()
11920 
    oprot.writeStructEnd()
11921 
 
11922 
  def validate(self):
11923 
    return
11924 
 
11925 
 
11926 
  def __repr__(self):
11927 
    L = ['%s=%r' % (key, value)
11928 
      for key, value in self.__dict__.iteritems()]
11929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11930 
 
11931 
  def __eq__(self, other):
11932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11933 
 
11934 
  def __ne__(self, other):
11935 
    return not (self == other)
11936 
 
11937 
class getAllTags_result:
11938 
  """
11939 
  Attributes:
11940 
   - success
11941 
  """
11942 
 
11943 
  thrift_spec = (
11944 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11945 
  )
11946 
 
11947 
  def __init__(self, success=None,):
11948 
    self.success = success
11949 
 
11950 
  def read(self, iprot):
11951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11953 
      return
11954 
    iprot.readStructBegin()
11955 
    while True:
11956 
      (fname, ftype, fid) = iprot.readFieldBegin()
11957 
      if ftype == TType.STOP:
11958 
        break
11959 
      if fid == 0:
11960 
        if ftype == TType.LIST:
11961 
          self.success = []
8590 kshitij.so 11962 
          (_etype168, _size165) = iprot.readListBegin()
11963 
          for _i169 in xrange(_size165):
11964 
            _elem170 = iprot.readString();
11965 
            self.success.append(_elem170)
6512 kshitij.so 11966 
          iprot.readListEnd()
11967 
        else:
11968 
          iprot.skip(ftype)
11969 
      else:
11970 
        iprot.skip(ftype)
11971 
      iprot.readFieldEnd()
11972 
    iprot.readStructEnd()
11973 
 
11974 
  def write(self, oprot):
11975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11977 
      return
11978 
    oprot.writeStructBegin('getAllTags_result')
11979 
    if self.success is not None:
11980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11981 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11982 
      for iter171 in self.success:
11983 
        oprot.writeString(iter171)
6512 kshitij.so 11984 
      oprot.writeListEnd()
11985 
      oprot.writeFieldEnd()
11986 
    oprot.writeFieldStop()
11987 
    oprot.writeStructEnd()
11988 
 
11989 
  def validate(self):
11990 
    return
11991 
 
11992 
 
11993 
  def __repr__(self):
11994 
    L = ['%s=%r' % (key, value)
11995 
      for key, value in self.__dict__.iteritems()]
11996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11997 
 
11998 
  def __eq__(self, other):
11999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12000 
 
12001 
  def __ne__(self, other):
12002 
    return not (self == other)
12003 
 
12004 
class getAllEntitiesByTagName_args:
12005 
  """
12006 
  Attributes:
12007 
   - displayName
12008 
  """
12009 
 
12010 
  thrift_spec = (
12011 
    None, # 0
12012 
    (1, TType.STRING, 'displayName', None, None, ), # 1
12013 
  )
12014 
 
12015 
  def __init__(self, displayName=None,):
12016 
    self.displayName = displayName
12017 
 
12018 
  def read(self, iprot):
12019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12021 
      return
12022 
    iprot.readStructBegin()
12023 
    while True:
12024 
      (fname, ftype, fid) = iprot.readFieldBegin()
12025 
      if ftype == TType.STOP:
12026 
        break
12027 
      if fid == 1:
12028 
        if ftype == TType.STRING:
12029 
          self.displayName = iprot.readString();
12030 
        else:
12031 
          iprot.skip(ftype)
12032 
      else:
12033 
        iprot.skip(ftype)
12034 
      iprot.readFieldEnd()
12035 
    iprot.readStructEnd()
12036 
 
12037 
  def write(self, oprot):
12038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12040 
      return
12041 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
12042 
    if self.displayName is not None:
12043 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
12044 
      oprot.writeString(self.displayName)
12045 
      oprot.writeFieldEnd()
12046 
    oprot.writeFieldStop()
12047 
    oprot.writeStructEnd()
12048 
 
12049 
  def validate(self):
12050 
    return
12051 
 
12052 
 
12053 
  def __repr__(self):
12054 
    L = ['%s=%r' % (key, value)
12055 
      for key, value in self.__dict__.iteritems()]
12056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12057 
 
12058 
  def __eq__(self, other):
12059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12060 
 
12061 
  def __ne__(self, other):
12062 
    return not (self == other)
12063 
 
12064 
class getAllEntitiesByTagName_result:
12065 
  """
12066 
  Attributes:
12067 
   - success
12068 
  """
12069 
 
12070 
  thrift_spec = (
12071 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12072 
  )
12073 
 
12074 
  def __init__(self, success=None,):
12075 
    self.success = success
12076 
 
12077 
  def read(self, iprot):
12078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12080 
      return
12081 
    iprot.readStructBegin()
12082 
    while True:
12083 
      (fname, ftype, fid) = iprot.readFieldBegin()
12084 
      if ftype == TType.STOP:
12085 
        break
12086 
      if fid == 0:
12087 
        if ftype == TType.LIST:
12088 
          self.success = []
8590 kshitij.so 12089 
          (_etype175, _size172) = iprot.readListBegin()
12090 
          for _i176 in xrange(_size172):
12091 
            _elem177 = iprot.readI64();
12092 
            self.success.append(_elem177)
6512 kshitij.so 12093 
          iprot.readListEnd()
12094 
        else:
12095 
          iprot.skip(ftype)
12096 
      else:
12097 
        iprot.skip(ftype)
12098 
      iprot.readFieldEnd()
12099 
    iprot.readStructEnd()
12100 
 
12101 
  def write(self, oprot):
12102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12104 
      return
12105 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
12106 
    if self.success is not None:
12107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12108 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 12109 
      for iter178 in self.success:
12110 
        oprot.writeI64(iter178)
6512 kshitij.so 12111 
      oprot.writeListEnd()
12112 
      oprot.writeFieldEnd()
12113 
    oprot.writeFieldStop()
12114 
    oprot.writeStructEnd()
12115 
 
12116 
  def validate(self):
12117 
    return
12118 
 
12119 
 
12120 
  def __repr__(self):
12121 
    L = ['%s=%r' % (key, value)
12122 
      for key, value in self.__dict__.iteritems()]
12123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12124 
 
12125 
  def __eq__(self, other):
12126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12127 
 
12128 
  def __ne__(self, other):
12129 
    return not (self == other)
12130 
 
6845 amit.gupta 12131 
class getAllEntityTags_args:
12132 
 
12133 
  thrift_spec = (
12134 
  )
12135 
 
12136 
  def read(self, iprot):
12137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12139 
      return
12140 
    iprot.readStructBegin()
12141 
    while True:
12142 
      (fname, ftype, fid) = iprot.readFieldBegin()
12143 
      if ftype == TType.STOP:
12144 
        break
12145 
      else:
12146 
        iprot.skip(ftype)
12147 
      iprot.readFieldEnd()
12148 
    iprot.readStructEnd()
12149 
 
12150 
  def write(self, oprot):
12151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12153 
      return
12154 
    oprot.writeStructBegin('getAllEntityTags_args')
12155 
    oprot.writeFieldStop()
12156 
    oprot.writeStructEnd()
12157 
 
12158 
  def validate(self):
12159 
    return
12160 
 
12161 
 
12162 
  def __repr__(self):
12163 
    L = ['%s=%r' % (key, value)
12164 
      for key, value in self.__dict__.iteritems()]
12165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12166 
 
12167 
  def __eq__(self, other):
12168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12169 
 
12170 
  def __ne__(self, other):
12171 
    return not (self == other)
12172 
 
12173 
class getAllEntityTags_result:
12174 
  """
12175 
  Attributes:
12176 
   - success
12177 
  """
12178 
 
12179 
  thrift_spec = (
12180 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
12181 
  )
12182 
 
12183 
  def __init__(self, success=None,):
12184 
    self.success = success
12185 
 
12186 
  def read(self, iprot):
12187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12189 
      return
12190 
    iprot.readStructBegin()
12191 
    while True:
12192 
      (fname, ftype, fid) = iprot.readFieldBegin()
12193 
      if ftype == TType.STOP:
12194 
        break
12195 
      if fid == 0:
12196 
        if ftype == TType.MAP:
12197 
          self.success = {}
8590 kshitij.so 12198 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
12199 
          for _i183 in xrange(_size179):
12200 
            _key184 = iprot.readI64();
12201 
            _val185 = []
12202 
            (_etype189, _size186) = iprot.readListBegin()
12203 
            for _i190 in xrange(_size186):
12204 
              _elem191 = iprot.readString();
12205 
              _val185.append(_elem191)
6845 amit.gupta 12206 
            iprot.readListEnd()
8590 kshitij.so 12207 
            self.success[_key184] = _val185
6845 amit.gupta 12208 
          iprot.readMapEnd()
12209 
        else:
12210 
          iprot.skip(ftype)
12211 
      else:
12212 
        iprot.skip(ftype)
12213 
      iprot.readFieldEnd()
12214 
    iprot.readStructEnd()
12215 
 
12216 
  def write(self, oprot):
12217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12219 
      return
12220 
    oprot.writeStructBegin('getAllEntityTags_result')
12221 
    if self.success is not None:
12222 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12223 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 12224 
      for kiter192,viter193 in self.success.items():
12225 
        oprot.writeI64(kiter192)
12226 
        oprot.writeListBegin(TType.STRING, len(viter193))
12227 
        for iter194 in viter193:
12228 
          oprot.writeString(iter194)
6845 amit.gupta 12229 
        oprot.writeListEnd()
12230 
      oprot.writeMapEnd()
12231 
      oprot.writeFieldEnd()
12232 
    oprot.writeFieldStop()
12233 
    oprot.writeStructEnd()
12234 
 
12235 
  def validate(self):
12236 
    return
12237 
 
12238 
 
12239 
  def __repr__(self):
12240 
    L = ['%s=%r' % (key, value)
12241 
      for key, value in self.__dict__.iteritems()]
12242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12243 
 
12244 
  def __eq__(self, other):
12245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12246 
 
12247 
  def __ne__(self, other):
12248 
    return not (self == other)
12249 
 
6850 kshitij.so 12250 
class addBanner_args:
12251 
  """
12252 
  Attributes:
8590 kshitij.so 12253 
   - bannerCongregate
6850 kshitij.so 12254 
  """
12255 
 
12256 
  thrift_spec = (
12257 
    None, # 0
8590 kshitij.so 12258 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 12259 
  )
12260 
 
8590 kshitij.so 12261 
  def __init__(self, bannerCongregate=None,):
12262 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 12263 
 
12264 
  def read(self, iprot):
12265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12267 
      return
12268 
    iprot.readStructBegin()
12269 
    while True:
12270 
      (fname, ftype, fid) = iprot.readFieldBegin()
12271 
      if ftype == TType.STOP:
12272 
        break
12273 
      if fid == 1:
8579 kshitij.so 12274 
        if ftype == TType.STRUCT:
8590 kshitij.so 12275 
          self.bannerCongregate = BannerCongregate()
12276 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 12277 
        else:
12278 
          iprot.skip(ftype)
8579 kshitij.so 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('addBanner_args')
8590 kshitij.so 12289 
    if self.bannerCongregate is not None:
12290 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
12291 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 12292 
      oprot.writeFieldEnd()
12293 
    oprot.writeFieldStop()
12294 
    oprot.writeStructEnd()
12295 
 
12296 
  def validate(self):
12297 
    return
12298 
 
12299 
 
12300 
  def __repr__(self):
12301 
    L = ['%s=%r' % (key, value)
12302 
      for key, value in self.__dict__.iteritems()]
12303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12304 
 
12305 
  def __eq__(self, other):
12306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12307 
 
12308 
  def __ne__(self, other):
12309 
    return not (self == other)
12310 
 
12311 
class addBanner_result:
12312 
 
12313 
  thrift_spec = (
12314 
  )
12315 
 
12316 
  def read(self, iprot):
12317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12319 
      return
12320 
    iprot.readStructBegin()
12321 
    while True:
12322 
      (fname, ftype, fid) = iprot.readFieldBegin()
12323 
      if ftype == TType.STOP:
12324 
        break
12325 
      else:
12326 
        iprot.skip(ftype)
12327 
      iprot.readFieldEnd()
12328 
    iprot.readStructEnd()
12329 
 
12330 
  def write(self, oprot):
12331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12333 
      return
12334 
    oprot.writeStructBegin('addBanner_result')
12335 
    oprot.writeFieldStop()
12336 
    oprot.writeStructEnd()
12337 
 
12338 
  def validate(self):
12339 
    return
12340 
 
12341 
 
12342 
  def __repr__(self):
12343 
    L = ['%s=%r' % (key, value)
12344 
      for key, value in self.__dict__.iteritems()]
12345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12346 
 
12347 
  def __eq__(self, other):
12348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12349 
 
12350 
  def __ne__(self, other):
12351 
    return not (self == other)
12352 
 
12353 
class updateBanner_args:
12354 
  """
12355 
  Attributes:
12356 
   - banner
12357 
  """
12358 
 
12359 
  thrift_spec = (
12360 
    None, # 0
12361 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12362 
  )
12363 
 
12364 
  def __init__(self, banner=None,):
12365 
    self.banner = banner
12366 
 
12367 
  def read(self, iprot):
12368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12370 
      return
12371 
    iprot.readStructBegin()
12372 
    while True:
12373 
      (fname, ftype, fid) = iprot.readFieldBegin()
12374 
      if ftype == TType.STOP:
12375 
        break
12376 
      if fid == 1:
12377 
        if ftype == TType.STRUCT:
12378 
          self.banner = Banner()
12379 
          self.banner.read(iprot)
6850 kshitij.so 12380 
        else:
12381 
          iprot.skip(ftype)
12382 
      else:
12383 
        iprot.skip(ftype)
12384 
      iprot.readFieldEnd()
12385 
    iprot.readStructEnd()
12386 
 
12387 
  def write(self, oprot):
12388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12390 
      return
8579 kshitij.so 12391 
    oprot.writeStructBegin('updateBanner_args')
12392 
    if self.banner is not None:
12393 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12394 
      self.banner.write(oprot)
6850 kshitij.so 12395 
      oprot.writeFieldEnd()
12396 
    oprot.writeFieldStop()
12397 
    oprot.writeStructEnd()
12398 
 
12399 
  def validate(self):
12400 
    return
12401 
 
12402 
 
12403 
  def __repr__(self):
12404 
    L = ['%s=%r' % (key, value)
12405 
      for key, value in self.__dict__.iteritems()]
12406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12407 
 
12408 
  def __eq__(self, other):
12409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12410 
 
12411 
  def __ne__(self, other):
12412 
    return not (self == other)
12413 
 
8579 kshitij.so 12414 
class updateBanner_result:
6850 kshitij.so 12415 
  """
12416 
  Attributes:
12417 
   - success
12418 
  """
12419 
 
12420 
  thrift_spec = (
12421 
    (0, TType.BOOL, 'success', None, None, ), # 0
12422 
  )
12423 
 
12424 
  def __init__(self, success=None,):
12425 
    self.success = success
12426 
 
12427 
  def read(self, iprot):
12428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12430 
      return
12431 
    iprot.readStructBegin()
12432 
    while True:
12433 
      (fname, ftype, fid) = iprot.readFieldBegin()
12434 
      if ftype == TType.STOP:
12435 
        break
12436 
      if fid == 0:
12437 
        if ftype == TType.BOOL:
12438 
          self.success = iprot.readBool();
12439 
        else:
12440 
          iprot.skip(ftype)
12441 
      else:
12442 
        iprot.skip(ftype)
12443 
      iprot.readFieldEnd()
12444 
    iprot.readStructEnd()
12445 
 
12446 
  def write(self, oprot):
12447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12449 
      return
8579 kshitij.so 12450 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 12451 
    if self.success is not None:
12452 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12453 
      oprot.writeBool(self.success)
12454 
      oprot.writeFieldEnd()
12455 
    oprot.writeFieldStop()
12456 
    oprot.writeStructEnd()
12457 
 
12458 
  def validate(self):
12459 
    return
12460 
 
12461 
 
12462 
  def __repr__(self):
12463 
    L = ['%s=%r' % (key, value)
12464 
      for key, value in self.__dict__.iteritems()]
12465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12466 
 
12467 
  def __eq__(self, other):
12468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12469 
 
12470 
  def __ne__(self, other):
12471 
    return not (self == other)
12472 
 
12473 
class getAllBanners_args:
12474 
 
12475 
  thrift_spec = (
12476 
  )
12477 
 
12478 
  def read(self, iprot):
12479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12481 
      return
12482 
    iprot.readStructBegin()
12483 
    while True:
12484 
      (fname, ftype, fid) = iprot.readFieldBegin()
12485 
      if ftype == TType.STOP:
12486 
        break
12487 
      else:
12488 
        iprot.skip(ftype)
12489 
      iprot.readFieldEnd()
12490 
    iprot.readStructEnd()
12491 
 
12492 
  def write(self, oprot):
12493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12495 
      return
12496 
    oprot.writeStructBegin('getAllBanners_args')
12497 
    oprot.writeFieldStop()
12498 
    oprot.writeStructEnd()
12499 
 
12500 
  def validate(self):
12501 
    return
12502 
 
12503 
 
12504 
  def __repr__(self):
12505 
    L = ['%s=%r' % (key, value)
12506 
      for key, value in self.__dict__.iteritems()]
12507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12508 
 
12509 
  def __eq__(self, other):
12510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12511 
 
12512 
  def __ne__(self, other):
12513 
    return not (self == other)
12514 
 
12515 
class getAllBanners_result:
12516 
  """
12517 
  Attributes:
12518 
   - success
12519 
  """
12520 
 
12521 
  thrift_spec = (
8579 kshitij.so 12522 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 12523 
  )
12524 
 
12525 
  def __init__(self, success=None,):
12526 
    self.success = success
12527 
 
12528 
  def read(self, iprot):
12529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12531 
      return
12532 
    iprot.readStructBegin()
12533 
    while True:
12534 
      (fname, ftype, fid) = iprot.readFieldBegin()
12535 
      if ftype == TType.STOP:
12536 
        break
12537 
      if fid == 0:
12538 
        if ftype == TType.LIST:
12539 
          self.success = []
8590 kshitij.so 12540 
          (_etype198, _size195) = iprot.readListBegin()
12541 
          for _i199 in xrange(_size195):
12542 
            _elem200 = Banner()
12543 
            _elem200.read(iprot)
12544 
            self.success.append(_elem200)
6850 kshitij.so 12545 
          iprot.readListEnd()
12546 
        else:
12547 
          iprot.skip(ftype)
12548 
      else:
12549 
        iprot.skip(ftype)
12550 
      iprot.readFieldEnd()
12551 
    iprot.readStructEnd()
12552 
 
12553 
  def write(self, oprot):
12554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12556 
      return
12557 
    oprot.writeStructBegin('getAllBanners_result')
12558 
    if self.success is not None:
12559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 12560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12561 
      for iter201 in self.success:
12562 
        iter201.write(oprot)
6850 kshitij.so 12563 
      oprot.writeListEnd()
12564 
      oprot.writeFieldEnd()
12565 
    oprot.writeFieldStop()
12566 
    oprot.writeStructEnd()
12567 
 
12568 
  def validate(self):
12569 
    return
12570 
 
12571 
 
12572 
  def __repr__(self):
12573 
    L = ['%s=%r' % (key, value)
12574 
      for key, value in self.__dict__.iteritems()]
12575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12576 
 
12577 
  def __eq__(self, other):
12578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12579 
 
12580 
  def __ne__(self, other):
12581 
    return not (self == other)
12582 
 
12583 
class deleteBanner_args:
12584 
  """
12585 
  Attributes:
12586 
   - bannerName
9155 kshitij.so 12587 
   - bannerType
6850 kshitij.so 12588 
  """
12589 
 
12590 
  thrift_spec = (
12591 
    None, # 0
12592 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12593 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12594 
  )
12595 
 
9155 kshitij.so 12596 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12597 
    self.bannerName = bannerName
9155 kshitij.so 12598 
    self.bannerType = bannerType
6850 kshitij.so 12599 
 
12600 
  def read(self, iprot):
12601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12603 
      return
12604 
    iprot.readStructBegin()
12605 
    while True:
12606 
      (fname, ftype, fid) = iprot.readFieldBegin()
12607 
      if ftype == TType.STOP:
12608 
        break
12609 
      if fid == 1:
12610 
        if ftype == TType.STRING:
12611 
          self.bannerName = iprot.readString();
12612 
        else:
12613 
          iprot.skip(ftype)
9155 kshitij.so 12614 
      elif fid == 2:
12615 
        if ftype == TType.I32:
12616 
          self.bannerType = iprot.readI32();
12617 
        else:
12618 
          iprot.skip(ftype)
6850 kshitij.so 12619 
      else:
12620 
        iprot.skip(ftype)
12621 
      iprot.readFieldEnd()
12622 
    iprot.readStructEnd()
12623 
 
12624 
  def write(self, oprot):
12625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12627 
      return
12628 
    oprot.writeStructBegin('deleteBanner_args')
12629 
    if self.bannerName is not None:
12630 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12631 
      oprot.writeString(self.bannerName)
12632 
      oprot.writeFieldEnd()
9155 kshitij.so 12633 
    if self.bannerType is not None:
12634 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12635 
      oprot.writeI32(self.bannerType)
12636 
      oprot.writeFieldEnd()
6850 kshitij.so 12637 
    oprot.writeFieldStop()
12638 
    oprot.writeStructEnd()
12639 
 
12640 
  def validate(self):
12641 
    return
12642 
 
12643 
 
12644 
  def __repr__(self):
12645 
    L = ['%s=%r' % (key, value)
12646 
      for key, value in self.__dict__.iteritems()]
12647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12648 
 
12649 
  def __eq__(self, other):
12650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12651 
 
12652 
  def __ne__(self, other):
12653 
    return not (self == other)
12654 
 
12655 
class deleteBanner_result:
12656 
  """
12657 
  Attributes:
12658 
   - success
12659 
  """
12660 
 
12661 
  thrift_spec = (
12662 
    (0, TType.BOOL, 'success', None, None, ), # 0
12663 
  )
12664 
 
12665 
  def __init__(self, success=None,):
12666 
    self.success = success
12667 
 
12668 
  def read(self, iprot):
12669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12671 
      return
12672 
    iprot.readStructBegin()
12673 
    while True:
12674 
      (fname, ftype, fid) = iprot.readFieldBegin()
12675 
      if ftype == TType.STOP:
12676 
        break
12677 
      if fid == 0:
12678 
        if ftype == TType.BOOL:
12679 
          self.success = iprot.readBool();
12680 
        else:
12681 
          iprot.skip(ftype)
12682 
      else:
12683 
        iprot.skip(ftype)
12684 
      iprot.readFieldEnd()
12685 
    iprot.readStructEnd()
12686 
 
12687 
  def write(self, oprot):
12688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12690 
      return
12691 
    oprot.writeStructBegin('deleteBanner_result')
12692 
    if self.success is not None:
12693 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12694 
      oprot.writeBool(self.success)
12695 
      oprot.writeFieldEnd()
12696 
    oprot.writeFieldStop()
12697 
    oprot.writeStructEnd()
12698 
 
12699 
  def validate(self):
12700 
    return
12701 
 
12702 
 
12703 
  def __repr__(self):
12704 
    L = ['%s=%r' % (key, value)
12705 
      for key, value in self.__dict__.iteritems()]
12706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12707 
 
12708 
  def __eq__(self, other):
12709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12710 
 
12711 
  def __ne__(self, other):
12712 
    return not (self == other)
12713 
 
12714 
class getBannerDetails_args:
12715 
  """
12716 
  Attributes:
12717 
   - bannerName
9155 kshitij.so 12718 
   - bannerType
6850 kshitij.so 12719 
  """
12720 
 
12721 
  thrift_spec = (
12722 
    None, # 0
12723 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 12724 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6850 kshitij.so 12725 
  )
12726 
 
9155 kshitij.so 12727 
  def __init__(self, bannerName=None, bannerType=None,):
6850 kshitij.so 12728 
    self.bannerName = bannerName
9155 kshitij.so 12729 
    self.bannerType = bannerType
6850 kshitij.so 12730 
 
12731 
  def read(self, iprot):
12732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12734 
      return
12735 
    iprot.readStructBegin()
12736 
    while True:
12737 
      (fname, ftype, fid) = iprot.readFieldBegin()
12738 
      if ftype == TType.STOP:
12739 
        break
12740 
      if fid == 1:
12741 
        if ftype == TType.STRING:
12742 
          self.bannerName = iprot.readString();
12743 
        else:
12744 
          iprot.skip(ftype)
9155 kshitij.so 12745 
      elif fid == 2:
12746 
        if ftype == TType.I32:
12747 
          self.bannerType = iprot.readI32();
12748 
        else:
12749 
          iprot.skip(ftype)
6850 kshitij.so 12750 
      else:
12751 
        iprot.skip(ftype)
12752 
      iprot.readFieldEnd()
12753 
    iprot.readStructEnd()
12754 
 
12755 
  def write(self, oprot):
12756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12758 
      return
12759 
    oprot.writeStructBegin('getBannerDetails_args')
12760 
    if self.bannerName is not None:
12761 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12762 
      oprot.writeString(self.bannerName)
12763 
      oprot.writeFieldEnd()
9155 kshitij.so 12764 
    if self.bannerType is not None:
12765 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
12766 
      oprot.writeI32(self.bannerType)
12767 
      oprot.writeFieldEnd()
6850 kshitij.so 12768 
    oprot.writeFieldStop()
12769 
    oprot.writeStructEnd()
12770 
 
12771 
  def validate(self):
12772 
    return
12773 
 
12774 
 
12775 
  def __repr__(self):
12776 
    L = ['%s=%r' % (key, value)
12777 
      for key, value in self.__dict__.iteritems()]
12778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12779 
 
12780 
  def __eq__(self, other):
12781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12782 
 
12783 
  def __ne__(self, other):
12784 
    return not (self == other)
12785 
 
12786 
class getBannerDetails_result:
12787 
  """
12788 
  Attributes:
12789 
   - success
12790 
  """
12791 
 
12792 
  thrift_spec = (
12793 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12794 
  )
12795 
 
12796 
  def __init__(self, success=None,):
12797 
    self.success = success
12798 
 
12799 
  def read(self, iprot):
12800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12802 
      return
12803 
    iprot.readStructBegin()
12804 
    while True:
12805 
      (fname, ftype, fid) = iprot.readFieldBegin()
12806 
      if ftype == TType.STOP:
12807 
        break
12808 
      if fid == 0:
12809 
        if ftype == TType.STRUCT:
12810 
          self.success = Banner()
12811 
          self.success.read(iprot)
12812 
        else:
12813 
          iprot.skip(ftype)
12814 
      else:
12815 
        iprot.skip(ftype)
12816 
      iprot.readFieldEnd()
12817 
    iprot.readStructEnd()
12818 
 
12819 
  def write(self, oprot):
12820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12822 
      return
12823 
    oprot.writeStructBegin('getBannerDetails_result')
12824 
    if self.success is not None:
12825 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12826 
      self.success.write(oprot)
12827 
      oprot.writeFieldEnd()
12828 
    oprot.writeFieldStop()
12829 
    oprot.writeStructEnd()
12830 
 
12831 
  def validate(self):
12832 
    return
12833 
 
12834 
 
12835 
  def __repr__(self):
12836 
    L = ['%s=%r' % (key, value)
12837 
      for key, value in self.__dict__.iteritems()]
12838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12839 
 
12840 
  def __eq__(self, other):
12841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12842 
 
12843 
  def __ne__(self, other):
12844 
    return not (self == other)
12845 
 
12846 
class getActiveBanners_args:
12847 
 
12848 
  thrift_spec = (
12849 
  )
12850 
 
12851 
  def read(self, iprot):
12852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12854 
      return
12855 
    iprot.readStructBegin()
12856 
    while True:
12857 
      (fname, ftype, fid) = iprot.readFieldBegin()
12858 
      if ftype == TType.STOP:
12859 
        break
12860 
      else:
12861 
        iprot.skip(ftype)
12862 
      iprot.readFieldEnd()
12863 
    iprot.readStructEnd()
12864 
 
12865 
  def write(self, oprot):
12866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12868 
      return
12869 
    oprot.writeStructBegin('getActiveBanners_args')
12870 
    oprot.writeFieldStop()
12871 
    oprot.writeStructEnd()
12872 
 
12873 
  def validate(self):
12874 
    return
12875 
 
12876 
 
12877 
  def __repr__(self):
12878 
    L = ['%s=%r' % (key, value)
12879 
      for key, value in self.__dict__.iteritems()]
12880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12881 
 
12882 
  def __eq__(self, other):
12883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12884 
 
12885 
  def __ne__(self, other):
12886 
    return not (self == other)
12887 
 
12888 
class getActiveBanners_result:
12889 
  """
12890 
  Attributes:
12891 
   - success
12892 
  """
12893 
 
12894 
  thrift_spec = (
8579 kshitij.so 12895 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12896 
  )
12897 
 
12898 
  def __init__(self, success=None,):
12899 
    self.success = success
12900 
 
12901 
  def read(self, iprot):
12902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12904 
      return
12905 
    iprot.readStructBegin()
12906 
    while True:
12907 
      (fname, ftype, fid) = iprot.readFieldBegin()
12908 
      if ftype == TType.STOP:
12909 
        break
12910 
      if fid == 0:
8579 kshitij.so 12911 
        if ftype == TType.MAP:
12912 
          self.success = {}
8590 kshitij.so 12913 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12914 
          for _i206 in xrange(_size202):
12915 
            _key207 = iprot.readString();
12916 
            _val208 = []
12917 
            (_etype212, _size209) = iprot.readListBegin()
12918 
            for _i213 in xrange(_size209):
12919 
              _elem214 = Banner()
12920 
              _elem214.read(iprot)
12921 
              _val208.append(_elem214)
8579 kshitij.so 12922 
            iprot.readListEnd()
8590 kshitij.so 12923 
            self.success[_key207] = _val208
8579 kshitij.so 12924 
          iprot.readMapEnd()
6850 kshitij.so 12925 
        else:
12926 
          iprot.skip(ftype)
12927 
      else:
12928 
        iprot.skip(ftype)
12929 
      iprot.readFieldEnd()
12930 
    iprot.readStructEnd()
12931 
 
12932 
  def write(self, oprot):
12933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12935 
      return
12936 
    oprot.writeStructBegin('getActiveBanners_result')
12937 
    if self.success is not None:
8579 kshitij.so 12938 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12939 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12940 
      for kiter215,viter216 in self.success.items():
12941 
        oprot.writeString(kiter215)
12942 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12943 
        for iter217 in viter216:
12944 
          iter217.write(oprot)
8579 kshitij.so 12945 
        oprot.writeListEnd()
12946 
      oprot.writeMapEnd()
6850 kshitij.so 12947 
      oprot.writeFieldEnd()
12948 
    oprot.writeFieldStop()
12949 
    oprot.writeStructEnd()
12950 
 
12951 
  def validate(self):
12952 
    return
12953 
 
12954 
 
12955 
  def __repr__(self):
12956 
    L = ['%s=%r' % (key, value)
12957 
      for key, value in self.__dict__.iteritems()]
12958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12959 
 
12960 
  def __eq__(self, other):
12961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12962 
 
12963 
  def __ne__(self, other):
12964 
    return not (self == other)
12965 
 
6849 kshitij.so 12966 
class addBannerMap_args:
12967 
  """
12968 
  Attributes:
8579 kshitij.so 12969 
   - bannerMaps
6849 kshitij.so 12970 
  """
12971 
 
12972 
  thrift_spec = (
12973 
    None, # 0
8579 kshitij.so 12974 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12975 
  )
12976 
 
8579 kshitij.so 12977 
  def __init__(self, bannerMaps=None,):
12978 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12979 
 
12980 
  def read(self, iprot):
12981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12983 
      return
12984 
    iprot.readStructBegin()
12985 
    while True:
12986 
      (fname, ftype, fid) = iprot.readFieldBegin()
12987 
      if ftype == TType.STOP:
12988 
        break
12989 
      if fid == 1:
8579 kshitij.so 12990 
        if ftype == TType.LIST:
12991 
          self.bannerMaps = []
8590 kshitij.so 12992 
          (_etype221, _size218) = iprot.readListBegin()
12993 
          for _i222 in xrange(_size218):
12994 
            _elem223 = BannerMap()
12995 
            _elem223.read(iprot)
12996 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12997 
          iprot.readListEnd()
6849 kshitij.so 12998 
        else:
12999 
          iprot.skip(ftype)
8579 kshitij.so 13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
13009 
    oprot.writeStructBegin('addBannerMap_args')
13010 
    if self.bannerMaps is not None:
13011 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
13012 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 13013 
      for iter224 in self.bannerMaps:
13014 
        iter224.write(oprot)
8579 kshitij.so 13015 
      oprot.writeListEnd()
13016 
      oprot.writeFieldEnd()
13017 
    oprot.writeFieldStop()
13018 
    oprot.writeStructEnd()
13019 
 
13020 
  def validate(self):
13021 
    return
13022 
 
13023 
 
13024 
  def __repr__(self):
13025 
    L = ['%s=%r' % (key, value)
13026 
      for key, value in self.__dict__.iteritems()]
13027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13028 
 
13029 
  def __eq__(self, other):
13030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13031 
 
13032 
  def __ne__(self, other):
13033 
    return not (self == other)
13034 
 
13035 
class addBannerMap_result:
13036 
  """
13037 
  Attributes:
13038 
   - success
13039 
  """
13040 
 
13041 
  thrift_spec = (
13042 
    (0, TType.BOOL, 'success', None, None, ), # 0
13043 
  )
13044 
 
13045 
  def __init__(self, success=None,):
13046 
    self.success = success
13047 
 
13048 
  def read(self, iprot):
13049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13051 
      return
13052 
    iprot.readStructBegin()
13053 
    while True:
13054 
      (fname, ftype, fid) = iprot.readFieldBegin()
13055 
      if ftype == TType.STOP:
13056 
        break
13057 
      if fid == 0:
13058 
        if ftype == TType.BOOL:
13059 
          self.success = iprot.readBool();
6849 kshitij.so 13060 
        else:
13061 
          iprot.skip(ftype)
8579 kshitij.so 13062 
      else:
13063 
        iprot.skip(ftype)
13064 
      iprot.readFieldEnd()
13065 
    iprot.readStructEnd()
13066 
 
13067 
  def write(self, oprot):
13068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13070 
      return
13071 
    oprot.writeStructBegin('addBannerMap_result')
13072 
    if self.success is not None:
13073 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13074 
      oprot.writeBool(self.success)
13075 
      oprot.writeFieldEnd()
13076 
    oprot.writeFieldStop()
13077 
    oprot.writeStructEnd()
13078 
 
13079 
  def validate(self):
13080 
    return
13081 
 
13082 
 
13083 
  def __repr__(self):
13084 
    L = ['%s=%r' % (key, value)
13085 
      for key, value in self.__dict__.iteritems()]
13086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13087 
 
13088 
  def __eq__(self, other):
13089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13090 
 
13091 
  def __ne__(self, other):
13092 
    return not (self == other)
13093 
 
13094 
class updateBannerMap_args:
13095 
  """
13096 
  Attributes:
13097 
   - bannerMap
13098 
  """
13099 
 
13100 
  thrift_spec = (
13101 
    None, # 0
13102 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
13103 
  )
13104 
 
13105 
  def __init__(self, bannerMap=None,):
13106 
    self.bannerMap = bannerMap
13107 
 
13108 
  def read(self, iprot):
13109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13111 
      return
13112 
    iprot.readStructBegin()
13113 
    while True:
13114 
      (fname, ftype, fid) = iprot.readFieldBegin()
13115 
      if ftype == TType.STOP:
13116 
        break
13117 
      if fid == 1:
13118 
        if ftype == TType.STRUCT:
13119 
          self.bannerMap = BannerMap()
13120 
          self.bannerMap.read(iprot)
6849 kshitij.so 13121 
        else:
13122 
          iprot.skip(ftype)
13123 
      else:
13124 
        iprot.skip(ftype)
13125 
      iprot.readFieldEnd()
13126 
    iprot.readStructEnd()
13127 
 
13128 
  def write(self, oprot):
13129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13131 
      return
8579 kshitij.so 13132 
    oprot.writeStructBegin('updateBannerMap_args')
13133 
    if self.bannerMap is not None:
13134 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
13135 
      self.bannerMap.write(oprot)
6849 kshitij.so 13136 
      oprot.writeFieldEnd()
13137 
    oprot.writeFieldStop()
13138 
    oprot.writeStructEnd()
13139 
 
13140 
  def validate(self):
13141 
    return
13142 
 
13143 
 
13144 
  def __repr__(self):
13145 
    L = ['%s=%r' % (key, value)
13146 
      for key, value in self.__dict__.iteritems()]
13147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13148 
 
13149 
  def __eq__(self, other):
13150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13151 
 
13152 
  def __ne__(self, other):
13153 
    return not (self == other)
13154 
 
8579 kshitij.so 13155 
class updateBannerMap_result:
6849 kshitij.so 13156 
  """
13157 
  Attributes:
13158 
   - success
13159 
  """
13160 
 
13161 
  thrift_spec = (
13162 
    (0, TType.BOOL, 'success', None, None, ), # 0
13163 
  )
13164 
 
13165 
  def __init__(self, success=None,):
13166 
    self.success = success
13167 
 
13168 
  def read(self, iprot):
13169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13171 
      return
13172 
    iprot.readStructBegin()
13173 
    while True:
13174 
      (fname, ftype, fid) = iprot.readFieldBegin()
13175 
      if ftype == TType.STOP:
13176 
        break
13177 
      if fid == 0:
13178 
        if ftype == TType.BOOL:
13179 
          self.success = iprot.readBool();
13180 
        else:
13181 
          iprot.skip(ftype)
13182 
      else:
13183 
        iprot.skip(ftype)
13184 
      iprot.readFieldEnd()
13185 
    iprot.readStructEnd()
13186 
 
13187 
  def write(self, oprot):
13188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13190 
      return
8579 kshitij.so 13191 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 13192 
    if self.success is not None:
13193 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13194 
      oprot.writeBool(self.success)
13195 
      oprot.writeFieldEnd()
13196 
    oprot.writeFieldStop()
13197 
    oprot.writeStructEnd()
13198 
 
13199 
  def validate(self):
13200 
    return
13201 
 
13202 
 
13203 
  def __repr__(self):
13204 
    L = ['%s=%r' % (key, value)
13205 
      for key, value in self.__dict__.iteritems()]
13206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13207 
 
13208 
  def __eq__(self, other):
13209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13210 
 
13211 
  def __ne__(self, other):
13212 
    return not (self == other)
13213 
 
13214 
class deleteBannerMap_args:
13215 
  """
13216 
  Attributes:
13217 
   - bannerName
13218 
  """
13219 
 
13220 
  thrift_spec = (
13221 
    None, # 0
13222 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13223 
  )
13224 
 
13225 
  def __init__(self, bannerName=None,):
13226 
    self.bannerName = bannerName
13227 
 
13228 
  def read(self, iprot):
13229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13231 
      return
13232 
    iprot.readStructBegin()
13233 
    while True:
13234 
      (fname, ftype, fid) = iprot.readFieldBegin()
13235 
      if ftype == TType.STOP:
13236 
        break
13237 
      if fid == 1:
13238 
        if ftype == TType.STRING:
13239 
          self.bannerName = iprot.readString();
13240 
        else:
13241 
          iprot.skip(ftype)
13242 
      else:
13243 
        iprot.skip(ftype)
13244 
      iprot.readFieldEnd()
13245 
    iprot.readStructEnd()
13246 
 
13247 
  def write(self, oprot):
13248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13250 
      return
13251 
    oprot.writeStructBegin('deleteBannerMap_args')
13252 
    if self.bannerName is not None:
13253 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13254 
      oprot.writeString(self.bannerName)
13255 
      oprot.writeFieldEnd()
13256 
    oprot.writeFieldStop()
13257 
    oprot.writeStructEnd()
13258 
 
13259 
  def validate(self):
13260 
    return
13261 
 
13262 
 
13263 
  def __repr__(self):
13264 
    L = ['%s=%r' % (key, value)
13265 
      for key, value in self.__dict__.iteritems()]
13266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13267 
 
13268 
  def __eq__(self, other):
13269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13270 
 
13271 
  def __ne__(self, other):
13272 
    return not (self == other)
13273 
 
13274 
class deleteBannerMap_result:
13275 
  """
13276 
  Attributes:
13277 
   - success
13278 
  """
13279 
 
13280 
  thrift_spec = (
13281 
    (0, TType.BOOL, 'success', None, None, ), # 0
13282 
  )
13283 
 
13284 
  def __init__(self, success=None,):
13285 
    self.success = success
13286 
 
13287 
  def read(self, iprot):
13288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13290 
      return
13291 
    iprot.readStructBegin()
13292 
    while True:
13293 
      (fname, ftype, fid) = iprot.readFieldBegin()
13294 
      if ftype == TType.STOP:
13295 
        break
13296 
      if fid == 0:
13297 
        if ftype == TType.BOOL:
13298 
          self.success = iprot.readBool();
13299 
        else:
13300 
          iprot.skip(ftype)
13301 
      else:
13302 
        iprot.skip(ftype)
13303 
      iprot.readFieldEnd()
13304 
    iprot.readStructEnd()
13305 
 
13306 
  def write(self, oprot):
13307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13309 
      return
13310 
    oprot.writeStructBegin('deleteBannerMap_result')
13311 
    if self.success is not None:
13312 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13313 
      oprot.writeBool(self.success)
13314 
      oprot.writeFieldEnd()
13315 
    oprot.writeFieldStop()
13316 
    oprot.writeStructEnd()
13317 
 
13318 
  def validate(self):
13319 
    return
13320 
 
13321 
 
13322 
  def __repr__(self):
13323 
    L = ['%s=%r' % (key, value)
13324 
      for key, value in self.__dict__.iteritems()]
13325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13326 
 
13327 
  def __eq__(self, other):
13328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13329 
 
13330 
  def __ne__(self, other):
13331 
    return not (self == other)
13332 
 
13333 
class getBannerMapDetails_args:
13334 
  """
13335 
  Attributes:
13336 
   - bannerName
9155 kshitij.so 13337 
   - bannerType
6849 kshitij.so 13338 
  """
13339 
 
13340 
  thrift_spec = (
13341 
    None, # 0
13342 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13343 
    (2, TType.I32, 'bannerType', None, None, ), # 2
6849 kshitij.so 13344 
  )
13345 
 
9155 kshitij.so 13346 
  def __init__(self, bannerName=None, bannerType=None,):
6849 kshitij.so 13347 
    self.bannerName = bannerName
9155 kshitij.so 13348 
    self.bannerType = bannerType
6849 kshitij.so 13349 
 
13350 
  def read(self, iprot):
13351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13353 
      return
13354 
    iprot.readStructBegin()
13355 
    while True:
13356 
      (fname, ftype, fid) = iprot.readFieldBegin()
13357 
      if ftype == TType.STOP:
13358 
        break
13359 
      if fid == 1:
13360 
        if ftype == TType.STRING:
13361 
          self.bannerName = iprot.readString();
13362 
        else:
13363 
          iprot.skip(ftype)
9155 kshitij.so 13364 
      elif fid == 2:
13365 
        if ftype == TType.I32:
13366 
          self.bannerType = iprot.readI32();
13367 
        else:
13368 
          iprot.skip(ftype)
6849 kshitij.so 13369 
      else:
13370 
        iprot.skip(ftype)
13371 
      iprot.readFieldEnd()
13372 
    iprot.readStructEnd()
13373 
 
13374 
  def write(self, oprot):
13375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13377 
      return
13378 
    oprot.writeStructBegin('getBannerMapDetails_args')
13379 
    if self.bannerName is not None:
13380 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13381 
      oprot.writeString(self.bannerName)
13382 
      oprot.writeFieldEnd()
9155 kshitij.so 13383 
    if self.bannerType is not None:
13384 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13385 
      oprot.writeI32(self.bannerType)
13386 
      oprot.writeFieldEnd()
6849 kshitij.so 13387 
    oprot.writeFieldStop()
13388 
    oprot.writeStructEnd()
13389 
 
13390 
  def validate(self):
13391 
    return
13392 
 
13393 
 
13394 
  def __repr__(self):
13395 
    L = ['%s=%r' % (key, value)
13396 
      for key, value in self.__dict__.iteritems()]
13397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13398 
 
13399 
  def __eq__(self, other):
13400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13401 
 
13402 
  def __ne__(self, other):
13403 
    return not (self == other)
13404 
 
13405 
class getBannerMapDetails_result:
13406 
  """
13407 
  Attributes:
13408 
   - success
13409 
  """
13410 
 
13411 
  thrift_spec = (
13412 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13413 
  )
13414 
 
13415 
  def __init__(self, success=None,):
13416 
    self.success = success
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 == 0:
13428 
        if ftype == TType.LIST:
13429 
          self.success = []
8590 kshitij.so 13430 
          (_etype228, _size225) = iprot.readListBegin()
13431 
          for _i229 in xrange(_size225):
13432 
            _elem230 = BannerMap()
13433 
            _elem230.read(iprot)
13434 
            self.success.append(_elem230)
6849 kshitij.so 13435 
          iprot.readListEnd()
13436 
        else:
13437 
          iprot.skip(ftype)
13438 
      else:
13439 
        iprot.skip(ftype)
13440 
      iprot.readFieldEnd()
13441 
    iprot.readStructEnd()
13442 
 
13443 
  def write(self, oprot):
13444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13446 
      return
13447 
    oprot.writeStructBegin('getBannerMapDetails_result')
13448 
    if self.success is not None:
13449 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13450 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13451 
      for iter231 in self.success:
13452 
        iter231.write(oprot)
6849 kshitij.so 13453 
      oprot.writeListEnd()
13454 
      oprot.writeFieldEnd()
13455 
    oprot.writeFieldStop()
13456 
    oprot.writeStructEnd()
13457 
 
13458 
  def validate(self):
13459 
    return
13460 
 
13461 
 
13462 
  def __repr__(self):
13463 
    L = ['%s=%r' % (key, value)
13464 
      for key, value in self.__dict__.iteritems()]
13465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13466 
 
13467 
  def __eq__(self, other):
13468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13469 
 
13470 
  def __ne__(self, other):
13471 
    return not (self == other)
13472 
 
8579 kshitij.so 13473 
class addBannerUri_args:
13474 
  """
13475 
  Attributes:
13476 
   - bannerUriMappings
13477 
  """
13478 
 
13479 
  thrift_spec = (
13480 
    None, # 0
13481 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
13482 
  )
13483 
 
13484 
  def __init__(self, bannerUriMappings=None,):
13485 
    self.bannerUriMappings = bannerUriMappings
13486 
 
13487 
  def read(self, iprot):
13488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13490 
      return
13491 
    iprot.readStructBegin()
13492 
    while True:
13493 
      (fname, ftype, fid) = iprot.readFieldBegin()
13494 
      if ftype == TType.STOP:
13495 
        break
13496 
      if fid == 1:
13497 
        if ftype == TType.LIST:
13498 
          self.bannerUriMappings = []
8590 kshitij.so 13499 
          (_etype235, _size232) = iprot.readListBegin()
13500 
          for _i236 in xrange(_size232):
13501 
            _elem237 = BannerUriMapping()
13502 
            _elem237.read(iprot)
13503 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 13504 
          iprot.readListEnd()
13505 
        else:
13506 
          iprot.skip(ftype)
13507 
      else:
13508 
        iprot.skip(ftype)
13509 
      iprot.readFieldEnd()
13510 
    iprot.readStructEnd()
13511 
 
13512 
  def write(self, oprot):
13513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13515 
      return
13516 
    oprot.writeStructBegin('addBannerUri_args')
13517 
    if self.bannerUriMappings is not None:
13518 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
13519 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 13520 
      for iter238 in self.bannerUriMappings:
13521 
        iter238.write(oprot)
8579 kshitij.so 13522 
      oprot.writeListEnd()
13523 
      oprot.writeFieldEnd()
13524 
    oprot.writeFieldStop()
13525 
    oprot.writeStructEnd()
13526 
 
13527 
  def validate(self):
13528 
    return
13529 
 
13530 
 
13531 
  def __repr__(self):
13532 
    L = ['%s=%r' % (key, value)
13533 
      for key, value in self.__dict__.iteritems()]
13534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13535 
 
13536 
  def __eq__(self, other):
13537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13538 
 
13539 
  def __ne__(self, other):
13540 
    return not (self == other)
13541 
 
13542 
class addBannerUri_result:
13543 
 
13544 
  thrift_spec = (
13545 
  )
13546 
 
13547 
  def read(self, iprot):
13548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13550 
      return
13551 
    iprot.readStructBegin()
13552 
    while True:
13553 
      (fname, ftype, fid) = iprot.readFieldBegin()
13554 
      if ftype == TType.STOP:
13555 
        break
13556 
      else:
13557 
        iprot.skip(ftype)
13558 
      iprot.readFieldEnd()
13559 
    iprot.readStructEnd()
13560 
 
13561 
  def write(self, oprot):
13562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13564 
      return
13565 
    oprot.writeStructBegin('addBannerUri_result')
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 getUriMapping_args:
13585 
  """
13586 
  Attributes:
13587 
   - bannerName
9155 kshitij.so 13588 
   - bannerType
8579 kshitij.so 13589 
  """
13590 
 
13591 
  thrift_spec = (
13592 
    None, # 0
13593 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
9155 kshitij.so 13594 
    (2, TType.I32, 'bannerType', None, None, ), # 2
8579 kshitij.so 13595 
  )
13596 
 
9155 kshitij.so 13597 
  def __init__(self, bannerName=None, bannerType=None,):
8579 kshitij.so 13598 
    self.bannerName = bannerName
9155 kshitij.so 13599 
    self.bannerType = bannerType
8579 kshitij.so 13600 
 
13601 
  def read(self, iprot):
13602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13604 
      return
13605 
    iprot.readStructBegin()
13606 
    while True:
13607 
      (fname, ftype, fid) = iprot.readFieldBegin()
13608 
      if ftype == TType.STOP:
13609 
        break
13610 
      if fid == 1:
13611 
        if ftype == TType.STRING:
13612 
          self.bannerName = iprot.readString();
13613 
        else:
13614 
          iprot.skip(ftype)
9155 kshitij.so 13615 
      elif fid == 2:
13616 
        if ftype == TType.I32:
13617 
          self.bannerType = iprot.readI32();
13618 
        else:
13619 
          iprot.skip(ftype)
8579 kshitij.so 13620 
      else:
13621 
        iprot.skip(ftype)
13622 
      iprot.readFieldEnd()
13623 
    iprot.readStructEnd()
13624 
 
13625 
  def write(self, oprot):
13626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13628 
      return
13629 
    oprot.writeStructBegin('getUriMapping_args')
13630 
    if self.bannerName is not None:
13631 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13632 
      oprot.writeString(self.bannerName)
13633 
      oprot.writeFieldEnd()
9155 kshitij.so 13634 
    if self.bannerType is not None:
13635 
      oprot.writeFieldBegin('bannerType', TType.I32, 2)
13636 
      oprot.writeI32(self.bannerType)
13637 
      oprot.writeFieldEnd()
8579 kshitij.so 13638 
    oprot.writeFieldStop()
13639 
    oprot.writeStructEnd()
13640 
 
13641 
  def validate(self):
13642 
    return
13643 
 
13644 
 
13645 
  def __repr__(self):
13646 
    L = ['%s=%r' % (key, value)
13647 
      for key, value in self.__dict__.iteritems()]
13648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13649 
 
13650 
  def __eq__(self, other):
13651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13652 
 
13653 
  def __ne__(self, other):
13654 
    return not (self == other)
13655 
 
13656 
class getUriMapping_result:
13657 
  """
13658 
  Attributes:
13659 
   - success
13660 
  """
13661 
 
13662 
  thrift_spec = (
13663 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
13664 
  )
13665 
 
13666 
  def __init__(self, success=None,):
13667 
    self.success = success
13668 
 
13669 
  def read(self, iprot):
13670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13672 
      return
13673 
    iprot.readStructBegin()
13674 
    while True:
13675 
      (fname, ftype, fid) = iprot.readFieldBegin()
13676 
      if ftype == TType.STOP:
13677 
        break
13678 
      if fid == 0:
13679 
        if ftype == TType.LIST:
13680 
          self.success = []
8590 kshitij.so 13681 
          (_etype242, _size239) = iprot.readListBegin()
13682 
          for _i243 in xrange(_size239):
13683 
            _elem244 = BannerUriMapping()
13684 
            _elem244.read(iprot)
13685 
            self.success.append(_elem244)
8579 kshitij.so 13686 
          iprot.readListEnd()
13687 
        else:
13688 
          iprot.skip(ftype)
13689 
      else:
13690 
        iprot.skip(ftype)
13691 
      iprot.readFieldEnd()
13692 
    iprot.readStructEnd()
13693 
 
13694 
  def write(self, oprot):
13695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13697 
      return
13698 
    oprot.writeStructBegin('getUriMapping_result')
13699 
    if self.success is not None:
13700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13702 
      for iter245 in self.success:
13703 
        iter245.write(oprot)
8579 kshitij.so 13704 
      oprot.writeListEnd()
13705 
      oprot.writeFieldEnd()
13706 
    oprot.writeFieldStop()
13707 
    oprot.writeStructEnd()
13708 
 
13709 
  def validate(self):
13710 
    return
13711 
 
13712 
 
13713 
  def __repr__(self):
13714 
    L = ['%s=%r' % (key, value)
13715 
      for key, value in self.__dict__.iteritems()]
13716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13717 
 
13718 
  def __eq__(self, other):
13719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13720 
 
13721 
  def __ne__(self, other):
13722 
    return not (self == other)
13723 
 
13724 
class addCampaign_args:
13725 
  """
13726 
  Attributes:
13727 
   - campaign
13728 
  """
13729 
 
13730 
  thrift_spec = (
13731 
    None, # 0
13732 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13733 
  )
13734 
 
13735 
  def __init__(self, campaign=None,):
13736 
    self.campaign = campaign
13737 
 
13738 
  def read(self, iprot):
13739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13741 
      return
13742 
    iprot.readStructBegin()
13743 
    while True:
13744 
      (fname, ftype, fid) = iprot.readFieldBegin()
13745 
      if ftype == TType.STOP:
13746 
        break
13747 
      if fid == 1:
13748 
        if ftype == TType.STRUCT:
13749 
          self.campaign = Campaign()
13750 
          self.campaign.read(iprot)
13751 
        else:
13752 
          iprot.skip(ftype)
13753 
      else:
13754 
        iprot.skip(ftype)
13755 
      iprot.readFieldEnd()
13756 
    iprot.readStructEnd()
13757 
 
13758 
  def write(self, oprot):
13759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13761 
      return
13762 
    oprot.writeStructBegin('addCampaign_args')
13763 
    if self.campaign is not None:
13764 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13765 
      self.campaign.write(oprot)
13766 
      oprot.writeFieldEnd()
13767 
    oprot.writeFieldStop()
13768 
    oprot.writeStructEnd()
13769 
 
13770 
  def validate(self):
13771 
    return
13772 
 
13773 
 
13774 
  def __repr__(self):
13775 
    L = ['%s=%r' % (key, value)
13776 
      for key, value in self.__dict__.iteritems()]
13777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13778 
 
13779 
  def __eq__(self, other):
13780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13781 
 
13782 
  def __ne__(self, other):
13783 
    return not (self == other)
13784 
 
13785 
class addCampaign_result:
13786 
 
13787 
  thrift_spec = (
13788 
  )
13789 
 
13790 
  def read(self, iprot):
13791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13793 
      return
13794 
    iprot.readStructBegin()
13795 
    while True:
13796 
      (fname, ftype, fid) = iprot.readFieldBegin()
13797 
      if ftype == TType.STOP:
13798 
        break
13799 
      else:
13800 
        iprot.skip(ftype)
13801 
      iprot.readFieldEnd()
13802 
    iprot.readStructEnd()
13803 
 
13804 
  def write(self, oprot):
13805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13807 
      return
13808 
    oprot.writeStructBegin('addCampaign_result')
13809 
    oprot.writeFieldStop()
13810 
    oprot.writeStructEnd()
13811 
 
13812 
  def validate(self):
13813 
    return
13814 
 
13815 
 
13816 
  def __repr__(self):
13817 
    L = ['%s=%r' % (key, value)
13818 
      for key, value in self.__dict__.iteritems()]
13819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13820 
 
13821 
  def __eq__(self, other):
13822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13823 
 
13824 
  def __ne__(self, other):
13825 
    return not (self == other)
13826 
 
13827 
class getCampaigns_args:
13828 
  """
13829 
  Attributes:
13830 
   - campaignName
13831 
  """
13832 
 
13833 
  thrift_spec = (
13834 
    None, # 0
13835 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13836 
  )
13837 
 
13838 
  def __init__(self, campaignName=None,):
13839 
    self.campaignName = campaignName
13840 
 
13841 
  def read(self, iprot):
13842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13844 
      return
13845 
    iprot.readStructBegin()
13846 
    while True:
13847 
      (fname, ftype, fid) = iprot.readFieldBegin()
13848 
      if ftype == TType.STOP:
13849 
        break
13850 
      if fid == 1:
13851 
        if ftype == TType.STRING:
13852 
          self.campaignName = iprot.readString();
13853 
        else:
13854 
          iprot.skip(ftype)
13855 
      else:
13856 
        iprot.skip(ftype)
13857 
      iprot.readFieldEnd()
13858 
    iprot.readStructEnd()
13859 
 
13860 
  def write(self, oprot):
13861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13863 
      return
13864 
    oprot.writeStructBegin('getCampaigns_args')
13865 
    if self.campaignName is not None:
13866 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13867 
      oprot.writeString(self.campaignName)
13868 
      oprot.writeFieldEnd()
13869 
    oprot.writeFieldStop()
13870 
    oprot.writeStructEnd()
13871 
 
13872 
  def validate(self):
13873 
    return
13874 
 
13875 
 
13876 
  def __repr__(self):
13877 
    L = ['%s=%r' % (key, value)
13878 
      for key, value in self.__dict__.iteritems()]
13879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13880 
 
13881 
  def __eq__(self, other):
13882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13883 
 
13884 
  def __ne__(self, other):
13885 
    return not (self == other)
13886 
 
13887 
class getCampaigns_result:
13888 
  """
13889 
  Attributes:
13890 
   - success
13891 
  """
13892 
 
13893 
  thrift_spec = (
13894 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13895 
  )
13896 
 
13897 
  def __init__(self, success=None,):
13898 
    self.success = success
13899 
 
13900 
  def read(self, iprot):
13901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13903 
      return
13904 
    iprot.readStructBegin()
13905 
    while True:
13906 
      (fname, ftype, fid) = iprot.readFieldBegin()
13907 
      if ftype == TType.STOP:
13908 
        break
13909 
      if fid == 0:
13910 
        if ftype == TType.LIST:
13911 
          self.success = []
8590 kshitij.so 13912 
          (_etype249, _size246) = iprot.readListBegin()
13913 
          for _i250 in xrange(_size246):
13914 
            _elem251 = Campaign()
13915 
            _elem251.read(iprot)
13916 
            self.success.append(_elem251)
8579 kshitij.so 13917 
          iprot.readListEnd()
13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      else:
13921 
        iprot.skip(ftype)
13922 
      iprot.readFieldEnd()
13923 
    iprot.readStructEnd()
13924 
 
13925 
  def write(self, oprot):
13926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13928 
      return
13929 
    oprot.writeStructBegin('getCampaigns_result')
13930 
    if self.success is not None:
13931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13933 
      for iter252 in self.success:
13934 
        iter252.write(oprot)
8579 kshitij.so 13935 
      oprot.writeListEnd()
13936 
      oprot.writeFieldEnd()
13937 
    oprot.writeFieldStop()
13938 
    oprot.writeStructEnd()
13939 
 
13940 
  def validate(self):
13941 
    return
13942 
 
13943 
 
13944 
  def __repr__(self):
13945 
    L = ['%s=%r' % (key, value)
13946 
      for key, value in self.__dict__.iteritems()]
13947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13948 
 
13949 
  def __eq__(self, other):
13950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13951 
 
13952 
  def __ne__(self, other):
13953 
    return not (self == other)
13954 
 
13955 
class deleteCampaign_args:
13956 
  """
13957 
  Attributes:
13958 
   - campaignId
13959 
  """
13960 
 
13961 
  thrift_spec = (
13962 
    None, # 0
13963 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13964 
  )
13965 
 
13966 
  def __init__(self, campaignId=None,):
13967 
    self.campaignId = campaignId
13968 
 
13969 
  def read(self, iprot):
13970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13972 
      return
13973 
    iprot.readStructBegin()
13974 
    while True:
13975 
      (fname, ftype, fid) = iprot.readFieldBegin()
13976 
      if ftype == TType.STOP:
13977 
        break
13978 
      if fid == 1:
13979 
        if ftype == TType.I64:
13980 
          self.campaignId = iprot.readI64();
13981 
        else:
13982 
          iprot.skip(ftype)
13983 
      else:
13984 
        iprot.skip(ftype)
13985 
      iprot.readFieldEnd()
13986 
    iprot.readStructEnd()
13987 
 
13988 
  def write(self, oprot):
13989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13991 
      return
13992 
    oprot.writeStructBegin('deleteCampaign_args')
13993 
    if self.campaignId is not None:
13994 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13995 
      oprot.writeI64(self.campaignId)
13996 
      oprot.writeFieldEnd()
13997 
    oprot.writeFieldStop()
13998 
    oprot.writeStructEnd()
13999 
 
14000 
  def validate(self):
14001 
    return
14002 
 
14003 
 
14004 
  def __repr__(self):
14005 
    L = ['%s=%r' % (key, value)
14006 
      for key, value in self.__dict__.iteritems()]
14007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14008 
 
14009 
  def __eq__(self, other):
14010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14011 
 
14012 
  def __ne__(self, other):
14013 
    return not (self == other)
14014 
 
14015 
class deleteCampaign_result:
14016 
 
14017 
  thrift_spec = (
14018 
  )
14019 
 
14020 
  def read(self, iprot):
14021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14023 
      return
14024 
    iprot.readStructBegin()
14025 
    while True:
14026 
      (fname, ftype, fid) = iprot.readFieldBegin()
14027 
      if ftype == TType.STOP:
14028 
        break
14029 
      else:
14030 
        iprot.skip(ftype)
14031 
      iprot.readFieldEnd()
14032 
    iprot.readStructEnd()
14033 
 
14034 
  def write(self, oprot):
14035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14037 
      return
14038 
    oprot.writeStructBegin('deleteCampaign_result')
14039 
    oprot.writeFieldStop()
14040 
    oprot.writeStructEnd()
14041 
 
14042 
  def validate(self):
14043 
    return
14044 
 
14045 
 
14046 
  def __repr__(self):
14047 
    L = ['%s=%r' % (key, value)
14048 
      for key, value in self.__dict__.iteritems()]
14049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14050 
 
14051 
  def __eq__(self, other):
14052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14053 
 
14054 
  def __ne__(self, other):
14055 
    return not (self == other)
14056 
 
14057 
class getAllCampaigns_args:
14058 
 
14059 
  thrift_spec = (
14060 
  )
14061 
 
14062 
  def read(self, iprot):
14063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14065 
      return
14066 
    iprot.readStructBegin()
14067 
    while True:
14068 
      (fname, ftype, fid) = iprot.readFieldBegin()
14069 
      if ftype == TType.STOP:
14070 
        break
14071 
      else:
14072 
        iprot.skip(ftype)
14073 
      iprot.readFieldEnd()
14074 
    iprot.readStructEnd()
14075 
 
14076 
  def write(self, oprot):
14077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14079 
      return
14080 
    oprot.writeStructBegin('getAllCampaigns_args')
14081 
    oprot.writeFieldStop()
14082 
    oprot.writeStructEnd()
14083 
 
14084 
  def validate(self):
14085 
    return
14086 
 
14087 
 
14088 
  def __repr__(self):
14089 
    L = ['%s=%r' % (key, value)
14090 
      for key, value in self.__dict__.iteritems()]
14091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14092 
 
14093 
  def __eq__(self, other):
14094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14095 
 
14096 
  def __ne__(self, other):
14097 
    return not (self == other)
14098 
 
14099 
class getAllCampaigns_result:
14100 
  """
14101 
  Attributes:
14102 
   - success
14103 
  """
14104 
 
14105 
  thrift_spec = (
14106 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14107 
  )
14108 
 
14109 
  def __init__(self, success=None,):
14110 
    self.success = success
14111 
 
14112 
  def read(self, iprot):
14113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14115 
      return
14116 
    iprot.readStructBegin()
14117 
    while True:
14118 
      (fname, ftype, fid) = iprot.readFieldBegin()
14119 
      if ftype == TType.STOP:
14120 
        break
14121 
      if fid == 0:
14122 
        if ftype == TType.LIST:
14123 
          self.success = []
8590 kshitij.so 14124 
          (_etype256, _size253) = iprot.readListBegin()
14125 
          for _i257 in xrange(_size253):
14126 
            _elem258 = iprot.readString();
14127 
            self.success.append(_elem258)
8579 kshitij.so 14128 
          iprot.readListEnd()
14129 
        else:
14130 
          iprot.skip(ftype)
14131 
      else:
14132 
        iprot.skip(ftype)
14133 
      iprot.readFieldEnd()
14134 
    iprot.readStructEnd()
14135 
 
14136 
  def write(self, oprot):
14137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14139 
      return
14140 
    oprot.writeStructBegin('getAllCampaigns_result')
14141 
    if self.success is not None:
14142 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14143 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14144 
      for iter259 in self.success:
14145 
        oprot.writeString(iter259)
8579 kshitij.so 14146 
      oprot.writeListEnd()
14147 
      oprot.writeFieldEnd()
14148 
    oprot.writeFieldStop()
14149 
    oprot.writeStructEnd()
14150 
 
14151 
  def validate(self):
14152 
    return
14153 
 
14154 
 
14155 
  def __repr__(self):
14156 
    L = ['%s=%r' % (key, value)
14157 
      for key, value in self.__dict__.iteritems()]
14158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14159 
 
14160 
  def __eq__(self, other):
14161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14162 
 
14163 
  def __ne__(self, other):
14164 
    return not (self == other)
14165 
 
9155 kshitij.so 14166 
class getActiveBannersForMobileSite_args:
14167 
 
14168 
  thrift_spec = (
14169 
  )
14170 
 
14171 
  def read(self, iprot):
14172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14174 
      return
14175 
    iprot.readStructBegin()
14176 
    while True:
14177 
      (fname, ftype, fid) = iprot.readFieldBegin()
14178 
      if ftype == TType.STOP:
14179 
        break
14180 
      else:
14181 
        iprot.skip(ftype)
14182 
      iprot.readFieldEnd()
14183 
    iprot.readStructEnd()
14184 
 
14185 
  def write(self, oprot):
14186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14188 
      return
14189 
    oprot.writeStructBegin('getActiveBannersForMobileSite_args')
14190 
    oprot.writeFieldStop()
14191 
    oprot.writeStructEnd()
14192 
 
14193 
  def validate(self):
14194 
    return
14195 
 
14196 
 
14197 
  def __repr__(self):
14198 
    L = ['%s=%r' % (key, value)
14199 
      for key, value in self.__dict__.iteritems()]
14200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14201 
 
14202 
  def __eq__(self, other):
14203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14204 
 
14205 
  def __ne__(self, other):
14206 
    return not (self == other)
14207 
 
14208 
class getActiveBannersForMobileSite_result:
14209 
  """
14210 
  Attributes:
14211 
   - success
14212 
  """
14213 
 
14214 
  thrift_spec = (
14215 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
14216 
  )
14217 
 
14218 
  def __init__(self, success=None,):
14219 
    self.success = success
14220 
 
14221 
  def read(self, iprot):
14222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14224 
      return
14225 
    iprot.readStructBegin()
14226 
    while True:
14227 
      (fname, ftype, fid) = iprot.readFieldBegin()
14228 
      if ftype == TType.STOP:
14229 
        break
14230 
      if fid == 0:
14231 
        if ftype == TType.MAP:
14232 
          self.success = {}
14233 
          (_ktype261, _vtype262, _size260 ) = iprot.readMapBegin()
14234 
          for _i264 in xrange(_size260):
14235 
            _key265 = iprot.readString();
14236 
            _val266 = []
14237 
            (_etype270, _size267) = iprot.readListBegin()
14238 
            for _i271 in xrange(_size267):
14239 
              _elem272 = Banner()
14240 
              _elem272.read(iprot)
14241 
              _val266.append(_elem272)
14242 
            iprot.readListEnd()
14243 
            self.success[_key265] = _val266
14244 
          iprot.readMapEnd()
14245 
        else:
14246 
          iprot.skip(ftype)
14247 
      else:
14248 
        iprot.skip(ftype)
14249 
      iprot.readFieldEnd()
14250 
    iprot.readStructEnd()
14251 
 
14252 
  def write(self, oprot):
14253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14255 
      return
14256 
    oprot.writeStructBegin('getActiveBannersForMobileSite_result')
14257 
    if self.success is not None:
14258 
      oprot.writeFieldBegin('success', TType.MAP, 0)
14259 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
14260 
      for kiter273,viter274 in self.success.items():
14261 
        oprot.writeString(kiter273)
14262 
        oprot.writeListBegin(TType.STRUCT, len(viter274))
14263 
        for iter275 in viter274:
14264 
          iter275.write(oprot)
14265 
        oprot.writeListEnd()
14266 
      oprot.writeMapEnd()
14267 
      oprot.writeFieldEnd()
14268 
    oprot.writeFieldStop()
14269 
    oprot.writeStructEnd()
14270 
 
14271 
  def validate(self):
14272 
    return
14273 
 
14274 
 
14275 
  def __repr__(self):
14276 
    L = ['%s=%r' % (key, value)
14277 
      for key, value in self.__dict__.iteritems()]
14278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14279 
 
14280 
  def __eq__(self, other):
14281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14282 
 
14283 
  def __ne__(self, other):
14284 
    return not (self == other)
14285 
 
5944 mandeep.dh 14286 
class deleteSimilarItem_args:
14287 
  """
14288 
  Attributes:
14289 
   - itemId
14290 
   - catalogItemId
14291 
  """
14292 
 
14293 
  thrift_spec = (
14294 
    None, # 0
14295 
    (1, TType.I64, 'itemId', None, None, ), # 1
14296 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
14297 
  )
14298 
 
14299 
  def __init__(self, itemId=None, catalogItemId=None,):
14300 
    self.itemId = itemId
14301 
    self.catalogItemId = catalogItemId
14302 
 
14303 
  def read(self, iprot):
14304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14306 
      return
14307 
    iprot.readStructBegin()
14308 
    while True:
14309 
      (fname, ftype, fid) = iprot.readFieldBegin()
14310 
      if ftype == TType.STOP:
14311 
        break
14312 
      if fid == 1:
14313 
        if ftype == TType.I64:
14314 
          self.itemId = iprot.readI64();
14315 
        else:
14316 
          iprot.skip(ftype)
14317 
      elif fid == 2:
14318 
        if ftype == TType.I64:
14319 
          self.catalogItemId = iprot.readI64();
14320 
        else:
14321 
          iprot.skip(ftype)
14322 
      else:
14323 
        iprot.skip(ftype)
14324 
      iprot.readFieldEnd()
14325 
    iprot.readStructEnd()
14326 
 
14327 
  def write(self, oprot):
14328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14330 
      return
14331 
    oprot.writeStructBegin('deleteSimilarItem_args')
14332 
    if self.itemId is not None:
14333 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14334 
      oprot.writeI64(self.itemId)
14335 
      oprot.writeFieldEnd()
14336 
    if self.catalogItemId is not None:
14337 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
14338 
      oprot.writeI64(self.catalogItemId)
14339 
      oprot.writeFieldEnd()
14340 
    oprot.writeFieldStop()
14341 
    oprot.writeStructEnd()
14342 
 
14343 
  def validate(self):
14344 
    return
14345 
 
14346 
 
14347 
  def __repr__(self):
14348 
    L = ['%s=%r' % (key, value)
14349 
      for key, value in self.__dict__.iteritems()]
14350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14351 
 
14352 
  def __eq__(self, other):
14353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14354 
 
14355 
  def __ne__(self, other):
14356 
    return not (self == other)
14357 
 
14358 
class deleteSimilarItem_result:
14359 
  """
14360 
  Attributes:
14361 
   - success
14362 
   - cex
14363 
  """
14364 
 
14365 
  thrift_spec = (
14366 
    (0, TType.BOOL, 'success', None, None, ), # 0
14367 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14368 
  )
14369 
 
14370 
  def __init__(self, success=None, cex=None,):
14371 
    self.success = success
14372 
    self.cex = cex
14373 
 
14374 
  def read(self, iprot):
14375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14377 
      return
14378 
    iprot.readStructBegin()
14379 
    while True:
14380 
      (fname, ftype, fid) = iprot.readFieldBegin()
14381 
      if ftype == TType.STOP:
14382 
        break
14383 
      if fid == 0:
14384 
        if ftype == TType.BOOL:
14385 
          self.success = iprot.readBool();
14386 
        else:
14387 
          iprot.skip(ftype)
14388 
      elif fid == 1:
14389 
        if ftype == TType.STRUCT:
14390 
          self.cex = CatalogServiceException()
14391 
          self.cex.read(iprot)
14392 
        else:
14393 
          iprot.skip(ftype)
14394 
      else:
14395 
        iprot.skip(ftype)
14396 
      iprot.readFieldEnd()
14397 
    iprot.readStructEnd()
14398 
 
14399 
  def write(self, oprot):
14400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14402 
      return
14403 
    oprot.writeStructBegin('deleteSimilarItem_result')
14404 
    if self.success is not None:
14405 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14406 
      oprot.writeBool(self.success)
14407 
      oprot.writeFieldEnd()
14408 
    if self.cex is not None:
14409 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14410 
      self.cex.write(oprot)
14411 
      oprot.writeFieldEnd()
14412 
    oprot.writeFieldStop()
14413 
    oprot.writeStructEnd()
14414 
 
14415 
  def validate(self):
14416 
    return
14417 
 
14418 
 
14419 
  def __repr__(self):
14420 
    L = ['%s=%r' % (key, value)
14421 
      for key, value in self.__dict__.iteritems()]
14422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14423 
 
14424 
  def __eq__(self, other):
14425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14426 
 
14427 
  def __ne__(self, other):
14428 
    return not (self == other)
14429 
 
14430 
class checkSimilarItem_args:
14431 
  """
14432 
  Attributes:
14433 
   - brand
14434 
   - modelNumber
14435 
   - modelName
14436 
   - color
14437 
  """
14438 
 
14439 
  thrift_spec = (
14440 
    None, # 0
14441 
    (1, TType.STRING, 'brand', None, None, ), # 1
14442 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
14443 
    (3, TType.STRING, 'modelName', None, None, ), # 3
14444 
    (4, TType.STRING, 'color', None, None, ), # 4
14445 
  )
14446 
 
14447 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
14448 
    self.brand = brand
14449 
    self.modelNumber = modelNumber
14450 
    self.modelName = modelName
14451 
    self.color = color
14452 
 
14453 
  def read(self, iprot):
14454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14456 
      return
14457 
    iprot.readStructBegin()
14458 
    while True:
14459 
      (fname, ftype, fid) = iprot.readFieldBegin()
14460 
      if ftype == TType.STOP:
14461 
        break
14462 
      if fid == 1:
14463 
        if ftype == TType.STRING:
14464 
          self.brand = iprot.readString();
14465 
        else:
14466 
          iprot.skip(ftype)
14467 
      elif fid == 2:
14468 
        if ftype == TType.STRING:
14469 
          self.modelNumber = iprot.readString();
14470 
        else:
14471 
          iprot.skip(ftype)
14472 
      elif fid == 3:
14473 
        if ftype == TType.STRING:
14474 
          self.modelName = iprot.readString();
14475 
        else:
14476 
          iprot.skip(ftype)
14477 
      elif fid == 4:
14478 
        if ftype == TType.STRING:
14479 
          self.color = iprot.readString();
14480 
        else:
14481 
          iprot.skip(ftype)
14482 
      else:
14483 
        iprot.skip(ftype)
14484 
      iprot.readFieldEnd()
14485 
    iprot.readStructEnd()
14486 
 
14487 
  def write(self, oprot):
14488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14490 
      return
14491 
    oprot.writeStructBegin('checkSimilarItem_args')
14492 
    if self.brand is not None:
14493 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
14494 
      oprot.writeString(self.brand)
14495 
      oprot.writeFieldEnd()
14496 
    if self.modelNumber is not None:
14497 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
14498 
      oprot.writeString(self.modelNumber)
14499 
      oprot.writeFieldEnd()
14500 
    if self.modelName is not None:
14501 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
14502 
      oprot.writeString(self.modelName)
14503 
      oprot.writeFieldEnd()
14504 
    if self.color is not None:
14505 
      oprot.writeFieldBegin('color', TType.STRING, 4)
14506 
      oprot.writeString(self.color)
14507 
      oprot.writeFieldEnd()
14508 
    oprot.writeFieldStop()
14509 
    oprot.writeStructEnd()
14510 
 
14511 
  def validate(self):
14512 
    return
14513 
 
14514 
 
14515 
  def __repr__(self):
14516 
    L = ['%s=%r' % (key, value)
14517 
      for key, value in self.__dict__.iteritems()]
14518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14519 
 
14520 
  def __eq__(self, other):
14521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14522 
 
14523 
  def __ne__(self, other):
14524 
    return not (self == other)
14525 
 
14526 
class checkSimilarItem_result:
14527 
  """
14528 
  Attributes:
14529 
   - success
14530 
  """
14531 
 
14532 
  thrift_spec = (
14533 
    (0, TType.I64, 'success', None, None, ), # 0
14534 
  )
14535 
 
14536 
  def __init__(self, success=None,):
14537 
    self.success = success
14538 
 
14539 
  def read(self, iprot):
14540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14542 
      return
14543 
    iprot.readStructBegin()
14544 
    while True:
14545 
      (fname, ftype, fid) = iprot.readFieldBegin()
14546 
      if ftype == TType.STOP:
14547 
        break
14548 
      if fid == 0:
14549 
        if ftype == TType.I64:
14550 
          self.success = iprot.readI64();
14551 
        else:
14552 
          iprot.skip(ftype)
14553 
      else:
14554 
        iprot.skip(ftype)
14555 
      iprot.readFieldEnd()
14556 
    iprot.readStructEnd()
14557 
 
14558 
  def write(self, oprot):
14559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14561 
      return
14562 
    oprot.writeStructBegin('checkSimilarItem_result')
14563 
    if self.success is not None:
14564 
      oprot.writeFieldBegin('success', TType.I64, 0)
14565 
      oprot.writeI64(self.success)
14566 
      oprot.writeFieldEnd()
14567 
    oprot.writeFieldStop()
14568 
    oprot.writeStructEnd()
14569 
 
14570 
  def validate(self):
14571 
    return
14572 
 
14573 
 
14574 
  def __repr__(self):
14575 
    L = ['%s=%r' % (key, value)
14576 
      for key, value in self.__dict__.iteritems()]
14577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14578 
 
14579 
  def __eq__(self, other):
14580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14581 
 
14582 
  def __ne__(self, other):
14583 
    return not (self == other)
14584 
 
14585 
class validateRiskyStatus_args:
14586 
  """
14587 
  Attributes:
14588 
   - itemId
14589 
  """
14590 
 
14591 
  thrift_spec = (
14592 
    None, # 0
14593 
    (1, TType.I64, 'itemId', None, None, ), # 1
14594 
  )
14595 
 
14596 
  def __init__(self, itemId=None,):
14597 
    self.itemId = itemId
14598 
 
14599 
  def read(self, iprot):
14600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14602 
      return
14603 
    iprot.readStructBegin()
14604 
    while True:
14605 
      (fname, ftype, fid) = iprot.readFieldBegin()
14606 
      if ftype == TType.STOP:
14607 
        break
14608 
      if fid == 1:
14609 
        if ftype == TType.I64:
14610 
          self.itemId = iprot.readI64();
14611 
        else:
14612 
          iprot.skip(ftype)
14613 
      else:
14614 
        iprot.skip(ftype)
14615 
      iprot.readFieldEnd()
14616 
    iprot.readStructEnd()
14617 
 
14618 
  def write(self, oprot):
14619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14621 
      return
14622 
    oprot.writeStructBegin('validateRiskyStatus_args')
14623 
    if self.itemId is not None:
14624 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14625 
      oprot.writeI64(self.itemId)
14626 
      oprot.writeFieldEnd()
14627 
    oprot.writeFieldStop()
14628 
    oprot.writeStructEnd()
14629 
 
14630 
  def validate(self):
14631 
    return
14632 
 
14633 
 
14634 
  def __repr__(self):
14635 
    L = ['%s=%r' % (key, value)
14636 
      for key, value in self.__dict__.iteritems()]
14637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14638 
 
14639 
  def __eq__(self, other):
14640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14641 
 
14642 
  def __ne__(self, other):
14643 
    return not (self == other)
14644 
 
14645 
class validateRiskyStatus_result:
14646 
 
14647 
  thrift_spec = (
14648 
  )
14649 
 
14650 
  def read(self, iprot):
14651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14653 
      return
14654 
    iprot.readStructBegin()
14655 
    while True:
14656 
      (fname, ftype, fid) = iprot.readFieldBegin()
14657 
      if ftype == TType.STOP:
14658 
        break
14659 
      else:
14660 
        iprot.skip(ftype)
14661 
      iprot.readFieldEnd()
14662 
    iprot.readStructEnd()
14663 
 
14664 
  def write(self, oprot):
14665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14667 
      return
14668 
    oprot.writeStructBegin('validateRiskyStatus_result')
14669 
    oprot.writeFieldStop()
14670 
    oprot.writeStructEnd()
14671 
 
14672 
  def validate(self):
14673 
    return
14674 
 
14675 
 
14676 
  def __repr__(self):
14677 
    L = ['%s=%r' % (key, value)
14678 
      for key, value in self.__dict__.iteritems()]
14679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14680 
 
14681 
  def __eq__(self, other):
14682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14683 
 
14684 
  def __ne__(self, other):
14685 
    return not (self == other)
14686 
 
14687 
class changeItemRiskyFlag_args:
14688 
  """
14689 
  Attributes:
14690 
   - itemId
14691 
   - risky
14692 
  """
14693 
 
14694 
  thrift_spec = (
14695 
    None, # 0
14696 
    (1, TType.I64, 'itemId', None, None, ), # 1
14697 
    (2, TType.BOOL, 'risky', None, None, ), # 2
14698 
  )
14699 
 
14700 
  def __init__(self, itemId=None, risky=None,):
14701 
    self.itemId = itemId
14702 
    self.risky = risky
14703 
 
14704 
  def read(self, iprot):
14705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14707 
      return
14708 
    iprot.readStructBegin()
14709 
    while True:
14710 
      (fname, ftype, fid) = iprot.readFieldBegin()
14711 
      if ftype == TType.STOP:
14712 
        break
14713 
      if fid == 1:
14714 
        if ftype == TType.I64:
14715 
          self.itemId = iprot.readI64();
14716 
        else:
14717 
          iprot.skip(ftype)
14718 
      elif fid == 2:
14719 
        if ftype == TType.BOOL:
14720 
          self.risky = iprot.readBool();
14721 
        else:
14722 
          iprot.skip(ftype)
14723 
      else:
14724 
        iprot.skip(ftype)
14725 
      iprot.readFieldEnd()
14726 
    iprot.readStructEnd()
14727 
 
14728 
  def write(self, oprot):
14729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14731 
      return
14732 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
14733 
    if self.itemId is not None:
14734 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14735 
      oprot.writeI64(self.itemId)
14736 
      oprot.writeFieldEnd()
14737 
    if self.risky is not None:
14738 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
14739 
      oprot.writeBool(self.risky)
14740 
      oprot.writeFieldEnd()
14741 
    oprot.writeFieldStop()
14742 
    oprot.writeStructEnd()
14743 
 
14744 
  def validate(self):
14745 
    return
14746 
 
14747 
 
14748 
  def __repr__(self):
14749 
    L = ['%s=%r' % (key, value)
14750 
      for key, value in self.__dict__.iteritems()]
14751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14752 
 
14753 
  def __eq__(self, other):
14754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14755 
 
14756 
  def __ne__(self, other):
14757 
    return not (self == other)
14758 
 
14759 
class changeItemRiskyFlag_result:
14760 
 
14761 
  thrift_spec = (
14762 
  )
14763 
 
14764 
  def read(self, iprot):
14765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14767 
      return
14768 
    iprot.readStructBegin()
14769 
    while True:
14770 
      (fname, ftype, fid) = iprot.readFieldBegin()
14771 
      if ftype == TType.STOP:
14772 
        break
14773 
      else:
14774 
        iprot.skip(ftype)
14775 
      iprot.readFieldEnd()
14776 
    iprot.readStructEnd()
14777 
 
14778 
  def write(self, oprot):
14779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14781 
      return
14782 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
14783 
    oprot.writeFieldStop()
14784 
    oprot.writeStructEnd()
14785 
 
14786 
  def validate(self):
14787 
    return
14788 
 
14789 
 
14790 
  def __repr__(self):
14791 
    L = ['%s=%r' % (key, value)
14792 
      for key, value in self.__dict__.iteritems()]
14793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14794 
 
14795 
  def __eq__(self, other):
14796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14797 
 
14798 
  def __ne__(self, other):
14799 
    return not (self == other)
14800 
 
14801 
class getItemsByRiskyFlag_args:
14802 
 
14803 
  thrift_spec = (
14804 
  )
14805 
 
14806 
  def read(self, iprot):
14807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14809 
      return
14810 
    iprot.readStructBegin()
14811 
    while True:
14812 
      (fname, ftype, fid) = iprot.readFieldBegin()
14813 
      if ftype == TType.STOP:
14814 
        break
14815 
      else:
14816 
        iprot.skip(ftype)
14817 
      iprot.readFieldEnd()
14818 
    iprot.readStructEnd()
14819 
 
14820 
  def write(self, oprot):
14821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14823 
      return
14824 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
14825 
    oprot.writeFieldStop()
14826 
    oprot.writeStructEnd()
14827 
 
14828 
  def validate(self):
14829 
    return
14830 
 
14831 
 
14832 
  def __repr__(self):
14833 
    L = ['%s=%r' % (key, value)
14834 
      for key, value in self.__dict__.iteritems()]
14835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14836 
 
14837 
  def __eq__(self, other):
14838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14839 
 
14840 
  def __ne__(self, other):
14841 
    return not (self == other)
14842 
 
14843 
class getItemsByRiskyFlag_result:
14844 
  """
14845 
  Attributes:
14846 
   - success
14847 
  """
14848 
 
14849 
  thrift_spec = (
14850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14851 
  )
14852 
 
14853 
  def __init__(self, success=None,):
14854 
    self.success = success
14855 
 
14856 
  def read(self, iprot):
14857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14859 
      return
14860 
    iprot.readStructBegin()
14861 
    while True:
14862 
      (fname, ftype, fid) = iprot.readFieldBegin()
14863 
      if ftype == TType.STOP:
14864 
        break
14865 
      if fid == 0:
14866 
        if ftype == TType.LIST:
14867 
          self.success = []
9155 kshitij.so 14868 
          (_etype279, _size276) = iprot.readListBegin()
14869 
          for _i280 in xrange(_size276):
14870 
            _elem281 = Item()
14871 
            _elem281.read(iprot)
14872 
            self.success.append(_elem281)
5944 mandeep.dh 14873 
          iprot.readListEnd()
14874 
        else:
14875 
          iprot.skip(ftype)
14876 
      else:
14877 
        iprot.skip(ftype)
14878 
      iprot.readFieldEnd()
14879 
    iprot.readStructEnd()
14880 
 
14881 
  def write(self, oprot):
14882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14884 
      return
14885 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14886 
    if self.success is not None:
14887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 14889 
      for iter282 in self.success:
14890 
        iter282.write(oprot)
5944 mandeep.dh 14891 
      oprot.writeListEnd()
14892 
      oprot.writeFieldEnd()
14893 
    oprot.writeFieldStop()
14894 
    oprot.writeStructEnd()
14895 
 
14896 
  def validate(self):
14897 
    return
14898 
 
14899 
 
14900 
  def __repr__(self):
14901 
    L = ['%s=%r' % (key, value)
14902 
      for key, value in self.__dict__.iteritems()]
14903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14904 
 
14905 
  def __eq__(self, other):
14906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14907 
 
14908 
  def __ne__(self, other):
14909 
    return not (self == other)
14910 
 
14911 
class getItemsForMasterSheet_args:
14912 
  """
14913 
  Attributes:
14914 
   - category
14915 
   - brand
14916 
  """
14917 
 
14918 
  thrift_spec = (
14919 
    None, # 0
14920 
    (1, TType.STRING, 'category', None, None, ), # 1
14921 
    (2, TType.STRING, 'brand', None, None, ), # 2
14922 
  )
14923 
 
14924 
  def __init__(self, category=None, brand=None,):
14925 
    self.category = category
14926 
    self.brand = brand
14927 
 
14928 
  def read(self, iprot):
14929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14931 
      return
14932 
    iprot.readStructBegin()
14933 
    while True:
14934 
      (fname, ftype, fid) = iprot.readFieldBegin()
14935 
      if ftype == TType.STOP:
14936 
        break
14937 
      if fid == 1:
14938 
        if ftype == TType.STRING:
14939 
          self.category = iprot.readString();
14940 
        else:
14941 
          iprot.skip(ftype)
14942 
      elif fid == 2:
14943 
        if ftype == TType.STRING:
14944 
          self.brand = iprot.readString();
14945 
        else:
14946 
          iprot.skip(ftype)
14947 
      else:
14948 
        iprot.skip(ftype)
14949 
      iprot.readFieldEnd()
14950 
    iprot.readStructEnd()
14951 
 
14952 
  def write(self, oprot):
14953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14955 
      return
14956 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14957 
    if self.category is not None:
14958 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14959 
      oprot.writeString(self.category)
14960 
      oprot.writeFieldEnd()
14961 
    if self.brand is not None:
14962 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14963 
      oprot.writeString(self.brand)
14964 
      oprot.writeFieldEnd()
14965 
    oprot.writeFieldStop()
14966 
    oprot.writeStructEnd()
14967 
 
14968 
  def validate(self):
14969 
    return
14970 
 
14971 
 
14972 
  def __repr__(self):
14973 
    L = ['%s=%r' % (key, value)
14974 
      for key, value in self.__dict__.iteritems()]
14975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14976 
 
14977 
  def __eq__(self, other):
14978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14979 
 
14980 
  def __ne__(self, other):
14981 
    return not (self == other)
14982 
 
14983 
class getItemsForMasterSheet_result:
14984 
  """
14985 
  Attributes:
14986 
   - success
14987 
  """
14988 
 
14989 
  thrift_spec = (
14990 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14991 
  )
14992 
 
14993 
  def __init__(self, success=None,):
14994 
    self.success = success
14995 
 
14996 
  def read(self, iprot):
14997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14999 
      return
15000 
    iprot.readStructBegin()
15001 
    while True:
15002 
      (fname, ftype, fid) = iprot.readFieldBegin()
15003 
      if ftype == TType.STOP:
15004 
        break
15005 
      if fid == 0:
15006 
        if ftype == TType.LIST:
15007 
          self.success = []
9155 kshitij.so 15008 
          (_etype286, _size283) = iprot.readListBegin()
15009 
          for _i287 in xrange(_size283):
15010 
            _elem288 = Item()
15011 
            _elem288.read(iprot)
15012 
            self.success.append(_elem288)
5944 mandeep.dh 15013 
          iprot.readListEnd()
15014 
        else:
15015 
          iprot.skip(ftype)
15016 
      else:
15017 
        iprot.skip(ftype)
15018 
      iprot.readFieldEnd()
15019 
    iprot.readStructEnd()
15020 
 
15021 
  def write(self, oprot):
15022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15024 
      return
15025 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
15026 
    if self.success is not None:
15027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15028 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15029 
      for iter289 in self.success:
15030 
        iter289.write(oprot)
5944 mandeep.dh 15031 
      oprot.writeListEnd()
15032 
      oprot.writeFieldEnd()
15033 
    oprot.writeFieldStop()
15034 
    oprot.writeStructEnd()
15035 
 
15036 
  def validate(self):
15037 
    return
15038 
 
15039 
 
15040 
  def __repr__(self):
15041 
    L = ['%s=%r' % (key, value)
15042 
      for key, value in self.__dict__.iteritems()]
15043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15044 
 
15045 
  def __eq__(self, other):
15046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15047 
 
15048 
  def __ne__(self, other):
15049 
    return not (self == other)
15050 
 
15051 
class getSimilarItemsCatalogIds_args:
15052 
  """
15053 
  Attributes:
15054 
   - beginIndex
15055 
   - totalItems
15056 
   - itemId
15057 
  """
15058 
 
15059 
  thrift_spec = (
15060 
    None, # 0
15061 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
15062 
    (2, TType.I64, 'totalItems', None, None, ), # 2
15063 
    (3, TType.I64, 'itemId', None, None, ), # 3
15064 
  )
15065 
 
15066 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
15067 
    self.beginIndex = beginIndex
15068 
    self.totalItems = totalItems
15069 
    self.itemId = itemId
15070 
 
15071 
  def read(self, iprot):
15072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15074 
      return
15075 
    iprot.readStructBegin()
15076 
    while True:
15077 
      (fname, ftype, fid) = iprot.readFieldBegin()
15078 
      if ftype == TType.STOP:
15079 
        break
15080 
      if fid == 1:
15081 
        if ftype == TType.I64:
15082 
          self.beginIndex = iprot.readI64();
15083 
        else:
15084 
          iprot.skip(ftype)
15085 
      elif fid == 2:
15086 
        if ftype == TType.I64:
15087 
          self.totalItems = iprot.readI64();
15088 
        else:
15089 
          iprot.skip(ftype)
15090 
      elif fid == 3:
15091 
        if ftype == TType.I64:
15092 
          self.itemId = iprot.readI64();
15093 
        else:
15094 
          iprot.skip(ftype)
15095 
      else:
15096 
        iprot.skip(ftype)
15097 
      iprot.readFieldEnd()
15098 
    iprot.readStructEnd()
15099 
 
15100 
  def write(self, oprot):
15101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15103 
      return
15104 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
15105 
    if self.beginIndex is not None:
15106 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
15107 
      oprot.writeI64(self.beginIndex)
15108 
      oprot.writeFieldEnd()
15109 
    if self.totalItems is not None:
15110 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
15111 
      oprot.writeI64(self.totalItems)
15112 
      oprot.writeFieldEnd()
15113 
    if self.itemId is not None:
15114 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
15115 
      oprot.writeI64(self.itemId)
15116 
      oprot.writeFieldEnd()
15117 
    oprot.writeFieldStop()
15118 
    oprot.writeStructEnd()
15119 
 
15120 
  def validate(self):
15121 
    return
15122 
 
15123 
 
15124 
  def __repr__(self):
15125 
    L = ['%s=%r' % (key, value)
15126 
      for key, value in self.__dict__.iteritems()]
15127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15128 
 
15129 
  def __eq__(self, other):
15130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15131 
 
15132 
  def __ne__(self, other):
15133 
    return not (self == other)
15134 
 
15135 
class getSimilarItemsCatalogIds_result:
15136 
  """
15137 
  Attributes:
15138 
   - success
15139 
  """
15140 
 
15141 
  thrift_spec = (
15142 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
15143 
  )
15144 
 
15145 
  def __init__(self, success=None,):
15146 
    self.success = success
15147 
 
15148 
  def read(self, iprot):
15149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15151 
      return
15152 
    iprot.readStructBegin()
15153 
    while True:
15154 
      (fname, ftype, fid) = iprot.readFieldBegin()
15155 
      if ftype == TType.STOP:
15156 
        break
15157 
      if fid == 0:
15158 
        if ftype == TType.LIST:
15159 
          self.success = []
9155 kshitij.so 15160 
          (_etype293, _size290) = iprot.readListBegin()
15161 
          for _i294 in xrange(_size290):
15162 
            _elem295 = iprot.readI64();
15163 
            self.success.append(_elem295)
5944 mandeep.dh 15164 
          iprot.readListEnd()
15165 
        else:
15166 
          iprot.skip(ftype)
15167 
      else:
15168 
        iprot.skip(ftype)
15169 
      iprot.readFieldEnd()
15170 
    iprot.readStructEnd()
15171 
 
15172 
  def write(self, oprot):
15173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15175 
      return
15176 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
15177 
    if self.success is not None:
15178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15179 
      oprot.writeListBegin(TType.I64, len(self.success))
9155 kshitij.so 15180 
      for iter296 in self.success:
15181 
        oprot.writeI64(iter296)
5944 mandeep.dh 15182 
      oprot.writeListEnd()
15183 
      oprot.writeFieldEnd()
15184 
    oprot.writeFieldStop()
15185 
    oprot.writeStructEnd()
15186 
 
15187 
  def validate(self):
15188 
    return
15189 
 
15190 
 
15191 
  def __repr__(self):
15192 
    L = ['%s=%r' % (key, value)
15193 
      for key, value in self.__dict__.iteritems()]
15194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15195 
 
15196 
  def __eq__(self, other):
15197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15198 
 
15199 
  def __ne__(self, other):
15200 
    return not (self == other)
15201 
 
15202 
class addProductNotification_args:
15203 
  """
15204 
  Attributes:
15205 
   - itemId
15206 
   - email
15207 
  """
15208 
 
15209 
  thrift_spec = None
15210 
  def __init__(self, itemId=None, email=None,):
15211 
    self.itemId = itemId
15212 
    self.email = email
15213 
 
15214 
  def read(self, iprot):
15215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15217 
      return
15218 
    iprot.readStructBegin()
15219 
    while True:
15220 
      (fname, ftype, fid) = iprot.readFieldBegin()
15221 
      if ftype == TType.STOP:
15222 
        break
15223 
      if fid == -1:
15224 
        if ftype == TType.I64:
15225 
          self.itemId = iprot.readI64();
15226 
        else:
15227 
          iprot.skip(ftype)
15228 
      elif fid == -2:
15229 
        if ftype == TType.STRING:
15230 
          self.email = iprot.readString();
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
15242 
    oprot.writeStructBegin('addProductNotification_args')
15243 
    if self.email is not None:
15244 
      oprot.writeFieldBegin('email', TType.STRING, -2)
15245 
      oprot.writeString(self.email)
15246 
      oprot.writeFieldEnd()
15247 
    if self.itemId is not None:
15248 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
15249 
      oprot.writeI64(self.itemId)
15250 
      oprot.writeFieldEnd()
15251 
    oprot.writeFieldStop()
15252 
    oprot.writeStructEnd()
15253 
 
15254 
  def validate(self):
15255 
    return
15256 
 
15257 
 
15258 
  def __repr__(self):
15259 
    L = ['%s=%r' % (key, value)
15260 
      for key, value in self.__dict__.iteritems()]
15261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15262 
 
15263 
  def __eq__(self, other):
15264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15265 
 
15266 
  def __ne__(self, other):
15267 
    return not (self == other)
15268 
 
15269 
class addProductNotification_result:
15270 
  """
15271 
  Attributes:
15272 
   - success
15273 
  """
15274 
 
15275 
  thrift_spec = (
15276 
    (0, TType.BOOL, 'success', None, None, ), # 0
15277 
  )
15278 
 
15279 
  def __init__(self, success=None,):
15280 
    self.success = success
15281 
 
15282 
  def read(self, iprot):
15283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15285 
      return
15286 
    iprot.readStructBegin()
15287 
    while True:
15288 
      (fname, ftype, fid) = iprot.readFieldBegin()
15289 
      if ftype == TType.STOP:
15290 
        break
15291 
      if fid == 0:
15292 
        if ftype == TType.BOOL:
15293 
          self.success = iprot.readBool();
15294 
        else:
15295 
          iprot.skip(ftype)
15296 
      else:
15297 
        iprot.skip(ftype)
15298 
      iprot.readFieldEnd()
15299 
    iprot.readStructEnd()
15300 
 
15301 
  def write(self, oprot):
15302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15304 
      return
15305 
    oprot.writeStructBegin('addProductNotification_result')
15306 
    if self.success is not None:
15307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15308 
      oprot.writeBool(self.success)
15309 
      oprot.writeFieldEnd()
15310 
    oprot.writeFieldStop()
15311 
    oprot.writeStructEnd()
15312 
 
15313 
  def validate(self):
15314 
    return
15315 
 
15316 
 
15317 
  def __repr__(self):
15318 
    L = ['%s=%r' % (key, value)
15319 
      for key, value in self.__dict__.iteritems()]
15320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15321 
 
15322 
  def __eq__(self, other):
15323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15324 
 
15325 
  def __ne__(self, other):
15326 
    return not (self == other)
15327 
 
15328 
class sendProductNotifications_args:
15329 
 
15330 
  thrift_spec = (
15331 
  )
15332 
 
15333 
  def read(self, iprot):
15334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15336 
      return
15337 
    iprot.readStructBegin()
15338 
    while True:
15339 
      (fname, ftype, fid) = iprot.readFieldBegin()
15340 
      if ftype == TType.STOP:
15341 
        break
15342 
      else:
15343 
        iprot.skip(ftype)
15344 
      iprot.readFieldEnd()
15345 
    iprot.readStructEnd()
15346 
 
15347 
  def write(self, oprot):
15348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15350 
      return
15351 
    oprot.writeStructBegin('sendProductNotifications_args')
15352 
    oprot.writeFieldStop()
15353 
    oprot.writeStructEnd()
15354 
 
15355 
  def validate(self):
15356 
    return
15357 
 
15358 
 
15359 
  def __repr__(self):
15360 
    L = ['%s=%r' % (key, value)
15361 
      for key, value in self.__dict__.iteritems()]
15362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15363 
 
15364 
  def __eq__(self, other):
15365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15366 
 
15367 
  def __ne__(self, other):
15368 
    return not (self == other)
15369 
 
15370 
class sendProductNotifications_result:
15371 
  """
15372 
  Attributes:
15373 
   - success
15374 
  """
15375 
 
15376 
  thrift_spec = (
15377 
    (0, TType.BOOL, 'success', None, None, ), # 0
15378 
  )
15379 
 
15380 
  def __init__(self, success=None,):
15381 
    self.success = success
15382 
 
15383 
  def read(self, iprot):
15384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15386 
      return
15387 
    iprot.readStructBegin()
15388 
    while True:
15389 
      (fname, ftype, fid) = iprot.readFieldBegin()
15390 
      if ftype == TType.STOP:
15391 
        break
15392 
      if fid == 0:
15393 
        if ftype == TType.BOOL:
15394 
          self.success = iprot.readBool();
15395 
        else:
15396 
          iprot.skip(ftype)
15397 
      else:
15398 
        iprot.skip(ftype)
15399 
      iprot.readFieldEnd()
15400 
    iprot.readStructEnd()
15401 
 
15402 
  def write(self, oprot):
15403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15405 
      return
15406 
    oprot.writeStructBegin('sendProductNotifications_result')
15407 
    if self.success is not None:
15408 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15409 
      oprot.writeBool(self.success)
15410 
      oprot.writeFieldEnd()
15411 
    oprot.writeFieldStop()
15412 
    oprot.writeStructEnd()
15413 
 
15414 
  def validate(self):
15415 
    return
15416 
 
15417 
 
15418 
  def __repr__(self):
15419 
    L = ['%s=%r' % (key, value)
15420 
      for key, value in self.__dict__.iteritems()]
15421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15422 
 
15423 
  def __eq__(self, other):
15424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15425 
 
15426 
  def __ne__(self, other):
15427 
    return not (self == other)
15428 
 
15429 
class getAllBrandsByCategory_args:
15430 
  """
15431 
  Attributes:
15432 
   - categoryId
15433 
  """
15434 
 
15435 
  thrift_spec = (
15436 
    None, # 0
15437 
    (1, TType.I64, 'categoryId', None, None, ), # 1
15438 
  )
15439 
 
15440 
  def __init__(self, categoryId=None,):
15441 
    self.categoryId = categoryId
15442 
 
15443 
  def read(self, iprot):
15444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15446 
      return
15447 
    iprot.readStructBegin()
15448 
    while True:
15449 
      (fname, ftype, fid) = iprot.readFieldBegin()
15450 
      if ftype == TType.STOP:
15451 
        break
15452 
      if fid == 1:
15453 
        if ftype == TType.I64:
15454 
          self.categoryId = iprot.readI64();
15455 
        else:
15456 
          iprot.skip(ftype)
15457 
      else:
15458 
        iprot.skip(ftype)
15459 
      iprot.readFieldEnd()
15460 
    iprot.readStructEnd()
15461 
 
15462 
  def write(self, oprot):
15463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15465 
      return
15466 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
15467 
    if self.categoryId is not None:
15468 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
15469 
      oprot.writeI64(self.categoryId)
15470 
      oprot.writeFieldEnd()
15471 
    oprot.writeFieldStop()
15472 
    oprot.writeStructEnd()
15473 
 
15474 
  def validate(self):
15475 
    return
15476 
 
15477 
 
15478 
  def __repr__(self):
15479 
    L = ['%s=%r' % (key, value)
15480 
      for key, value in self.__dict__.iteritems()]
15481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15482 
 
15483 
  def __eq__(self, other):
15484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15485 
 
15486 
  def __ne__(self, other):
15487 
    return not (self == other)
15488 
 
15489 
class getAllBrandsByCategory_result:
15490 
  """
15491 
  Attributes:
15492 
   - success
15493 
  """
15494 
 
15495 
  thrift_spec = (
15496 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15497 
  )
15498 
 
15499 
  def __init__(self, success=None,):
15500 
    self.success = success
15501 
 
15502 
  def read(self, iprot):
15503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15505 
      return
15506 
    iprot.readStructBegin()
15507 
    while True:
15508 
      (fname, ftype, fid) = iprot.readFieldBegin()
15509 
      if ftype == TType.STOP:
15510 
        break
15511 
      if fid == 0:
15512 
        if ftype == TType.LIST:
15513 
          self.success = []
9155 kshitij.so 15514 
          (_etype300, _size297) = iprot.readListBegin()
15515 
          for _i301 in xrange(_size297):
15516 
            _elem302 = iprot.readString();
15517 
            self.success.append(_elem302)
5944 mandeep.dh 15518 
          iprot.readListEnd()
15519 
        else:
15520 
          iprot.skip(ftype)
15521 
      else:
15522 
        iprot.skip(ftype)
15523 
      iprot.readFieldEnd()
15524 
    iprot.readStructEnd()
15525 
 
15526 
  def write(self, oprot):
15527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15529 
      return
15530 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
15531 
    if self.success is not None:
15532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15533 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15534 
      for iter303 in self.success:
15535 
        oprot.writeString(iter303)
5944 mandeep.dh 15536 
      oprot.writeListEnd()
15537 
      oprot.writeFieldEnd()
15538 
    oprot.writeFieldStop()
15539 
    oprot.writeStructEnd()
15540 
 
15541 
  def validate(self):
15542 
    return
15543 
 
15544 
 
15545 
  def __repr__(self):
15546 
    L = ['%s=%r' % (key, value)
15547 
      for key, value in self.__dict__.iteritems()]
15548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15549 
 
15550 
  def __eq__(self, other):
15551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15552 
 
15553 
  def __ne__(self, other):
15554 
    return not (self == other)
15555 
 
15556 
class getAllBrands_args:
15557 
 
15558 
  thrift_spec = (
15559 
  )
15560 
 
15561 
  def read(self, iprot):
15562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15564 
      return
15565 
    iprot.readStructBegin()
15566 
    while True:
15567 
      (fname, ftype, fid) = iprot.readFieldBegin()
15568 
      if ftype == TType.STOP:
15569 
        break
15570 
      else:
15571 
        iprot.skip(ftype)
15572 
      iprot.readFieldEnd()
15573 
    iprot.readStructEnd()
15574 
 
15575 
  def write(self, oprot):
15576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15578 
      return
15579 
    oprot.writeStructBegin('getAllBrands_args')
15580 
    oprot.writeFieldStop()
15581 
    oprot.writeStructEnd()
15582 
 
15583 
  def validate(self):
15584 
    return
15585 
 
15586 
 
15587 
  def __repr__(self):
15588 
    L = ['%s=%r' % (key, value)
15589 
      for key, value in self.__dict__.iteritems()]
15590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15591 
 
15592 
  def __eq__(self, other):
15593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15594 
 
15595 
  def __ne__(self, other):
15596 
    return not (self == other)
15597 
 
15598 
class getAllBrands_result:
15599 
  """
15600 
  Attributes:
15601 
   - success
15602 
  """
15603 
 
15604 
  thrift_spec = (
15605 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15606 
  )
15607 
 
15608 
  def __init__(self, success=None,):
15609 
    self.success = success
15610 
 
15611 
  def read(self, iprot):
15612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15614 
      return
15615 
    iprot.readStructBegin()
15616 
    while True:
15617 
      (fname, ftype, fid) = iprot.readFieldBegin()
15618 
      if ftype == TType.STOP:
15619 
        break
15620 
      if fid == 0:
15621 
        if ftype == TType.LIST:
15622 
          self.success = []
9155 kshitij.so 15623 
          (_etype307, _size304) = iprot.readListBegin()
15624 
          for _i308 in xrange(_size304):
15625 
            _elem309 = iprot.readString();
15626 
            self.success.append(_elem309)
5944 mandeep.dh 15627 
          iprot.readListEnd()
15628 
        else:
15629 
          iprot.skip(ftype)
15630 
      else:
15631 
        iprot.skip(ftype)
15632 
      iprot.readFieldEnd()
15633 
    iprot.readStructEnd()
15634 
 
15635 
  def write(self, oprot):
15636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15638 
      return
15639 
    oprot.writeStructBegin('getAllBrands_result')
15640 
    if self.success is not None:
15641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15642 
      oprot.writeListBegin(TType.STRING, len(self.success))
9155 kshitij.so 15643 
      for iter310 in self.success:
15644 
        oprot.writeString(iter310)
5944 mandeep.dh 15645 
      oprot.writeListEnd()
15646 
      oprot.writeFieldEnd()
15647 
    oprot.writeFieldStop()
15648 
    oprot.writeStructEnd()
15649 
 
15650 
  def validate(self):
15651 
    return
15652 
 
15653 
 
15654 
  def __repr__(self):
15655 
    L = ['%s=%r' % (key, value)
15656 
      for key, value in self.__dict__.iteritems()]
15657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15658 
 
15659 
  def __eq__(self, other):
15660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15661 
 
15662 
  def __ne__(self, other):
15663 
    return not (self == other)
15664 
 
15665 
class getAllSources_args:
15666 
 
15667 
  thrift_spec = (
15668 
  )
15669 
 
15670 
  def read(self, iprot):
15671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15673 
      return
15674 
    iprot.readStructBegin()
15675 
    while True:
15676 
      (fname, ftype, fid) = iprot.readFieldBegin()
15677 
      if ftype == TType.STOP:
15678 
        break
15679 
      else:
15680 
        iprot.skip(ftype)
15681 
      iprot.readFieldEnd()
15682 
    iprot.readStructEnd()
15683 
 
15684 
  def write(self, oprot):
15685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15687 
      return
15688 
    oprot.writeStructBegin('getAllSources_args')
15689 
    oprot.writeFieldStop()
15690 
    oprot.writeStructEnd()
15691 
 
15692 
  def validate(self):
15693 
    return
15694 
 
15695 
 
15696 
  def __repr__(self):
15697 
    L = ['%s=%r' % (key, value)
15698 
      for key, value in self.__dict__.iteritems()]
15699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15700 
 
15701 
  def __eq__(self, other):
15702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15703 
 
15704 
  def __ne__(self, other):
15705 
    return not (self == other)
15706 
 
15707 
class getAllSources_result:
15708 
  """
15709 
  Attributes:
15710 
   - success
15711 
  """
15712 
 
15713 
  thrift_spec = (
15714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
15715 
  )
15716 
 
15717 
  def __init__(self, success=None,):
15718 
    self.success = success
15719 
 
15720 
  def read(self, iprot):
15721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15723 
      return
15724 
    iprot.readStructBegin()
15725 
    while True:
15726 
      (fname, ftype, fid) = iprot.readFieldBegin()
15727 
      if ftype == TType.STOP:
15728 
        break
15729 
      if fid == 0:
15730 
        if ftype == TType.LIST:
15731 
          self.success = []
9155 kshitij.so 15732 
          (_etype314, _size311) = iprot.readListBegin()
15733 
          for _i315 in xrange(_size311):
15734 
            _elem316 = Source()
15735 
            _elem316.read(iprot)
15736 
            self.success.append(_elem316)
5944 mandeep.dh 15737 
          iprot.readListEnd()
15738 
        else:
15739 
          iprot.skip(ftype)
15740 
      else:
15741 
        iprot.skip(ftype)
15742 
      iprot.readFieldEnd()
15743 
    iprot.readStructEnd()
15744 
 
15745 
  def write(self, oprot):
15746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15748 
      return
15749 
    oprot.writeStructBegin('getAllSources_result')
15750 
    if self.success is not None:
15751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 15753 
      for iter317 in self.success:
15754 
        iter317.write(oprot)
5944 mandeep.dh 15755 
      oprot.writeListEnd()
15756 
      oprot.writeFieldEnd()
15757 
    oprot.writeFieldStop()
15758 
    oprot.writeStructEnd()
15759 
 
15760 
  def validate(self):
15761 
    return
15762 
 
15763 
 
15764 
  def __repr__(self):
15765 
    L = ['%s=%r' % (key, value)
15766 
      for key, value in self.__dict__.iteritems()]
15767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15768 
 
15769 
  def __eq__(self, other):
15770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15771 
 
15772 
  def __ne__(self, other):
15773 
    return not (self == other)
15774 
 
15775 
class getItemPricingBySource_args:
15776 
  """
15777 
  Attributes:
15778 
   - itemId
15779 
   - sourceId
15780 
  """
15781 
 
15782 
  thrift_spec = (
15783 
    None, # 0
15784 
    (1, TType.I64, 'itemId', None, None, ), # 1
15785 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15786 
  )
15787 
 
15788 
  def __init__(self, itemId=None, sourceId=None,):
15789 
    self.itemId = itemId
15790 
    self.sourceId = sourceId
15791 
 
15792 
  def read(self, iprot):
15793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15795 
      return
15796 
    iprot.readStructBegin()
15797 
    while True:
15798 
      (fname, ftype, fid) = iprot.readFieldBegin()
15799 
      if ftype == TType.STOP:
15800 
        break
15801 
      if fid == 1:
15802 
        if ftype == TType.I64:
15803 
          self.itemId = iprot.readI64();
15804 
        else:
15805 
          iprot.skip(ftype)
15806 
      elif fid == 2:
15807 
        if ftype == TType.I64:
15808 
          self.sourceId = iprot.readI64();
15809 
        else:
15810 
          iprot.skip(ftype)
15811 
      else:
15812 
        iprot.skip(ftype)
15813 
      iprot.readFieldEnd()
15814 
    iprot.readStructEnd()
15815 
 
15816 
  def write(self, oprot):
15817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15819 
      return
15820 
    oprot.writeStructBegin('getItemPricingBySource_args')
15821 
    if self.itemId is not None:
15822 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15823 
      oprot.writeI64(self.itemId)
15824 
      oprot.writeFieldEnd()
15825 
    if self.sourceId is not None:
15826 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15827 
      oprot.writeI64(self.sourceId)
15828 
      oprot.writeFieldEnd()
15829 
    oprot.writeFieldStop()
15830 
    oprot.writeStructEnd()
15831 
 
15832 
  def validate(self):
15833 
    return
15834 
 
15835 
 
15836 
  def __repr__(self):
15837 
    L = ['%s=%r' % (key, value)
15838 
      for key, value in self.__dict__.iteritems()]
15839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15840 
 
15841 
  def __eq__(self, other):
15842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15843 
 
15844 
  def __ne__(self, other):
15845 
    return not (self == other)
15846 
 
15847 
class getItemPricingBySource_result:
15848 
  """
15849 
  Attributes:
15850 
   - success
15851 
   - cex
15852 
  """
15853 
 
15854 
  thrift_spec = (
15855 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15856 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15857 
  )
15858 
 
15859 
  def __init__(self, success=None, cex=None,):
15860 
    self.success = success
15861 
    self.cex = cex
15862 
 
15863 
  def read(self, iprot):
15864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15866 
      return
15867 
    iprot.readStructBegin()
15868 
    while True:
15869 
      (fname, ftype, fid) = iprot.readFieldBegin()
15870 
      if ftype == TType.STOP:
15871 
        break
15872 
      if fid == 0:
15873 
        if ftype == TType.STRUCT:
15874 
          self.success = SourceItemPricing()
15875 
          self.success.read(iprot)
15876 
        else:
15877 
          iprot.skip(ftype)
15878 
      elif fid == 1:
15879 
        if ftype == TType.STRUCT:
15880 
          self.cex = CatalogServiceException()
15881 
          self.cex.read(iprot)
15882 
        else:
15883 
          iprot.skip(ftype)
15884 
      else:
15885 
        iprot.skip(ftype)
15886 
      iprot.readFieldEnd()
15887 
    iprot.readStructEnd()
15888 
 
15889 
  def write(self, oprot):
15890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15892 
      return
15893 
    oprot.writeStructBegin('getItemPricingBySource_result')
15894 
    if self.success is not None:
15895 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15896 
      self.success.write(oprot)
15897 
      oprot.writeFieldEnd()
15898 
    if self.cex is not None:
15899 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15900 
      self.cex.write(oprot)
15901 
      oprot.writeFieldEnd()
15902 
    oprot.writeFieldStop()
15903 
    oprot.writeStructEnd()
15904 
 
15905 
  def validate(self):
15906 
    return
15907 
 
15908 
 
15909 
  def __repr__(self):
15910 
    L = ['%s=%r' % (key, value)
15911 
      for key, value in self.__dict__.iteritems()]
15912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15913 
 
15914 
  def __eq__(self, other):
15915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15916 
 
15917 
  def __ne__(self, other):
15918 
    return not (self == other)
15919 
 
15920 
class addSourceItemPricing_args:
15921 
  """
15922 
  Attributes:
15923 
   - sourceItemPricing
15924 
  """
15925 
 
15926 
  thrift_spec = (
15927 
    None, # 0
15928 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15929 
  )
15930 
 
15931 
  def __init__(self, sourceItemPricing=None,):
15932 
    self.sourceItemPricing = sourceItemPricing
15933 
 
15934 
  def read(self, iprot):
15935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15937 
      return
15938 
    iprot.readStructBegin()
15939 
    while True:
15940 
      (fname, ftype, fid) = iprot.readFieldBegin()
15941 
      if ftype == TType.STOP:
15942 
        break
15943 
      if fid == 1:
15944 
        if ftype == TType.STRUCT:
15945 
          self.sourceItemPricing = SourceItemPricing()
15946 
          self.sourceItemPricing.read(iprot)
15947 
        else:
15948 
          iprot.skip(ftype)
15949 
      else:
15950 
        iprot.skip(ftype)
15951 
      iprot.readFieldEnd()
15952 
    iprot.readStructEnd()
15953 
 
15954 
  def write(self, oprot):
15955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15957 
      return
15958 
    oprot.writeStructBegin('addSourceItemPricing_args')
15959 
    if self.sourceItemPricing is not None:
15960 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15961 
      self.sourceItemPricing.write(oprot)
15962 
      oprot.writeFieldEnd()
15963 
    oprot.writeFieldStop()
15964 
    oprot.writeStructEnd()
15965 
 
15966 
  def validate(self):
15967 
    return
15968 
 
15969 
 
15970 
  def __repr__(self):
15971 
    L = ['%s=%r' % (key, value)
15972 
      for key, value in self.__dict__.iteritems()]
15973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15974 
 
15975 
  def __eq__(self, other):
15976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15977 
 
15978 
  def __ne__(self, other):
15979 
    return not (self == other)
15980 
 
15981 
class addSourceItemPricing_result:
15982 
  """
15983 
  Attributes:
15984 
   - cex
15985 
  """
15986 
 
15987 
  thrift_spec = (
15988 
    None, # 0
15989 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15990 
  )
15991 
 
15992 
  def __init__(self, cex=None,):
15993 
    self.cex = cex
15994 
 
15995 
  def read(self, iprot):
15996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15998 
      return
15999 
    iprot.readStructBegin()
16000 
    while True:
16001 
      (fname, ftype, fid) = iprot.readFieldBegin()
16002 
      if ftype == TType.STOP:
16003 
        break
16004 
      if fid == 1:
16005 
        if ftype == TType.STRUCT:
16006 
          self.cex = CatalogServiceException()
16007 
          self.cex.read(iprot)
16008 
        else:
16009 
          iprot.skip(ftype)
16010 
      else:
16011 
        iprot.skip(ftype)
16012 
      iprot.readFieldEnd()
16013 
    iprot.readStructEnd()
16014 
 
16015 
  def write(self, oprot):
16016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16018 
      return
16019 
    oprot.writeStructBegin('addSourceItemPricing_result')
16020 
    if self.cex is not None:
16021 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16022 
      self.cex.write(oprot)
16023 
      oprot.writeFieldEnd()
16024 
    oprot.writeFieldStop()
16025 
    oprot.writeStructEnd()
16026 
 
16027 
  def validate(self):
16028 
    return
16029 
 
16030 
 
16031 
  def __repr__(self):
16032 
    L = ['%s=%r' % (key, value)
16033 
      for key, value in self.__dict__.iteritems()]
16034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16035 
 
16036 
  def __eq__(self, other):
16037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16038 
 
16039 
  def __ne__(self, other):
16040 
    return not (self == other)
16041 
 
16042 
class getAllSourcePricing_args:
16043 
  """
16044 
  Attributes:
16045 
   - itemId
16046 
  """
16047 
 
16048 
  thrift_spec = (
16049 
    None, # 0
16050 
    (1, TType.I64, 'itemId', None, None, ), # 1
16051 
  )
16052 
 
16053 
  def __init__(self, itemId=None,):
16054 
    self.itemId = itemId
16055 
 
16056 
  def read(self, iprot):
16057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16059 
      return
16060 
    iprot.readStructBegin()
16061 
    while True:
16062 
      (fname, ftype, fid) = iprot.readFieldBegin()
16063 
      if ftype == TType.STOP:
16064 
        break
16065 
      if fid == 1:
16066 
        if ftype == TType.I64:
16067 
          self.itemId = iprot.readI64();
16068 
        else:
16069 
          iprot.skip(ftype)
16070 
      else:
16071 
        iprot.skip(ftype)
16072 
      iprot.readFieldEnd()
16073 
    iprot.readStructEnd()
16074 
 
16075 
  def write(self, oprot):
16076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16078 
      return
16079 
    oprot.writeStructBegin('getAllSourcePricing_args')
16080 
    if self.itemId is not None:
16081 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16082 
      oprot.writeI64(self.itemId)
16083 
      oprot.writeFieldEnd()
16084 
    oprot.writeFieldStop()
16085 
    oprot.writeStructEnd()
16086 
 
16087 
  def validate(self):
16088 
    return
16089 
 
16090 
 
16091 
  def __repr__(self):
16092 
    L = ['%s=%r' % (key, value)
16093 
      for key, value in self.__dict__.iteritems()]
16094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16095 
 
16096 
  def __eq__(self, other):
16097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16098 
 
16099 
  def __ne__(self, other):
16100 
    return not (self == other)
16101 
 
16102 
class getAllSourcePricing_result:
16103 
  """
16104 
  Attributes:
16105 
   - success
16106 
   - cex
16107 
  """
16108 
 
16109 
  thrift_spec = (
16110 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
16111 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16112 
  )
16113 
 
16114 
  def __init__(self, success=None, cex=None,):
16115 
    self.success = success
16116 
    self.cex = cex
16117 
 
16118 
  def read(self, iprot):
16119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16121 
      return
16122 
    iprot.readStructBegin()
16123 
    while True:
16124 
      (fname, ftype, fid) = iprot.readFieldBegin()
16125 
      if ftype == TType.STOP:
16126 
        break
16127 
      if fid == 0:
16128 
        if ftype == TType.LIST:
16129 
          self.success = []
9155 kshitij.so 16130 
          (_etype321, _size318) = iprot.readListBegin()
16131 
          for _i322 in xrange(_size318):
16132 
            _elem323 = SourceItemPricing()
16133 
            _elem323.read(iprot)
16134 
            self.success.append(_elem323)
5944 mandeep.dh 16135 
          iprot.readListEnd()
16136 
        else:
16137 
          iprot.skip(ftype)
16138 
      elif fid == 1:
16139 
        if ftype == TType.STRUCT:
16140 
          self.cex = CatalogServiceException()
16141 
          self.cex.read(iprot)
16142 
        else:
16143 
          iprot.skip(ftype)
16144 
      else:
16145 
        iprot.skip(ftype)
16146 
      iprot.readFieldEnd()
16147 
    iprot.readStructEnd()
16148 
 
16149 
  def write(self, oprot):
16150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16152 
      return
16153 
    oprot.writeStructBegin('getAllSourcePricing_result')
16154 
    if self.success is not None:
16155 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16156 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16157 
      for iter324 in self.success:
16158 
        iter324.write(oprot)
5944 mandeep.dh 16159 
      oprot.writeListEnd()
16160 
      oprot.writeFieldEnd()
16161 
    if self.cex is not None:
16162 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16163 
      self.cex.write(oprot)
16164 
      oprot.writeFieldEnd()
16165 
    oprot.writeFieldStop()
16166 
    oprot.writeStructEnd()
16167 
 
16168 
  def validate(self):
16169 
    return
16170 
 
16171 
 
16172 
  def __repr__(self):
16173 
    L = ['%s=%r' % (key, value)
16174 
      for key, value in self.__dict__.iteritems()]
16175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16176 
 
16177 
  def __eq__(self, other):
16178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16179 
 
16180 
  def __ne__(self, other):
16181 
    return not (self == other)
16182 
 
16183 
class getItemForSource_args:
16184 
  """
16185 
  Attributes:
16186 
   - item_id
16187 
   - sourceId
16188 
  """
16189 
 
16190 
  thrift_spec = (
16191 
    None, # 0
16192 
    (1, TType.I64, 'item_id', None, None, ), # 1
16193 
    (2, TType.I64, 'sourceId', None, None, ), # 2
16194 
  )
16195 
 
16196 
  def __init__(self, item_id=None, sourceId=None,):
16197 
    self.item_id = item_id
16198 
    self.sourceId = sourceId
16199 
 
16200 
  def read(self, iprot):
16201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16203 
      return
16204 
    iprot.readStructBegin()
16205 
    while True:
16206 
      (fname, ftype, fid) = iprot.readFieldBegin()
16207 
      if ftype == TType.STOP:
16208 
        break
16209 
      if fid == 1:
16210 
        if ftype == TType.I64:
16211 
          self.item_id = iprot.readI64();
16212 
        else:
16213 
          iprot.skip(ftype)
16214 
      elif fid == 2:
16215 
        if ftype == TType.I64:
16216 
          self.sourceId = iprot.readI64();
16217 
        else:
16218 
          iprot.skip(ftype)
16219 
      else:
16220 
        iprot.skip(ftype)
16221 
      iprot.readFieldEnd()
16222 
    iprot.readStructEnd()
16223 
 
16224 
  def write(self, oprot):
16225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16227 
      return
16228 
    oprot.writeStructBegin('getItemForSource_args')
16229 
    if self.item_id is not None:
16230 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
16231 
      oprot.writeI64(self.item_id)
16232 
      oprot.writeFieldEnd()
16233 
    if self.sourceId is not None:
16234 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
16235 
      oprot.writeI64(self.sourceId)
16236 
      oprot.writeFieldEnd()
16237 
    oprot.writeFieldStop()
16238 
    oprot.writeStructEnd()
16239 
 
16240 
  def validate(self):
16241 
    return
16242 
 
16243 
 
16244 
  def __repr__(self):
16245 
    L = ['%s=%r' % (key, value)
16246 
      for key, value in self.__dict__.iteritems()]
16247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16248 
 
16249 
  def __eq__(self, other):
16250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16251 
 
16252 
  def __ne__(self, other):
16253 
    return not (self == other)
16254 
 
16255 
class getItemForSource_result:
16256 
  """
16257 
  Attributes:
16258 
   - success
16259 
   - cex
16260 
  """
16261 
 
16262 
  thrift_spec = (
16263 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
16264 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16265 
  )
16266 
 
16267 
  def __init__(self, success=None, cex=None,):
16268 
    self.success = success
16269 
    self.cex = cex
16270 
 
16271 
  def read(self, iprot):
16272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16274 
      return
16275 
    iprot.readStructBegin()
16276 
    while True:
16277 
      (fname, ftype, fid) = iprot.readFieldBegin()
16278 
      if ftype == TType.STOP:
16279 
        break
16280 
      if fid == 0:
16281 
        if ftype == TType.STRUCT:
16282 
          self.success = Item()
16283 
          self.success.read(iprot)
16284 
        else:
16285 
          iprot.skip(ftype)
16286 
      elif fid == 1:
16287 
        if ftype == TType.STRUCT:
16288 
          self.cex = CatalogServiceException()
16289 
          self.cex.read(iprot)
16290 
        else:
16291 
          iprot.skip(ftype)
16292 
      else:
16293 
        iprot.skip(ftype)
16294 
      iprot.readFieldEnd()
16295 
    iprot.readStructEnd()
16296 
 
16297 
  def write(self, oprot):
16298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16300 
      return
16301 
    oprot.writeStructBegin('getItemForSource_result')
16302 
    if self.success is not None:
16303 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16304 
      self.success.write(oprot)
16305 
      oprot.writeFieldEnd()
16306 
    if self.cex is not None:
16307 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16308 
      self.cex.write(oprot)
16309 
      oprot.writeFieldEnd()
16310 
    oprot.writeFieldStop()
16311 
    oprot.writeStructEnd()
16312 
 
16313 
  def validate(self):
16314 
    return
16315 
 
16316 
 
16317 
  def __repr__(self):
16318 
    L = ['%s=%r' % (key, value)
16319 
      for key, value in self.__dict__.iteritems()]
16320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16321 
 
16322 
  def __eq__(self, other):
16323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16324 
 
16325 
  def __ne__(self, other):
16326 
    return not (self == other)
16327 
 
16328 
class searchItemsInRange_args:
16329 
  """
16330 
  Attributes:
16331 
   - searchTerms
16332 
   - offset
16333 
   - limit
16334 
  """
16335 
 
16336 
  thrift_spec = (
16337 
    None, # 0
16338 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16339 
    (2, TType.I64, 'offset', None, None, ), # 2
16340 
    (3, TType.I64, 'limit', None, None, ), # 3
16341 
  )
16342 
 
16343 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
16344 
    self.searchTerms = searchTerms
16345 
    self.offset = offset
16346 
    self.limit = limit
16347 
 
16348 
  def read(self, iprot):
16349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16351 
      return
16352 
    iprot.readStructBegin()
16353 
    while True:
16354 
      (fname, ftype, fid) = iprot.readFieldBegin()
16355 
      if ftype == TType.STOP:
16356 
        break
16357 
      if fid == 1:
16358 
        if ftype == TType.LIST:
16359 
          self.searchTerms = []
9155 kshitij.so 16360 
          (_etype328, _size325) = iprot.readListBegin()
16361 
          for _i329 in xrange(_size325):
16362 
            _elem330 = iprot.readString();
16363 
            self.searchTerms.append(_elem330)
5944 mandeep.dh 16364 
          iprot.readListEnd()
16365 
        else:
16366 
          iprot.skip(ftype)
16367 
      elif fid == 2:
16368 
        if ftype == TType.I64:
16369 
          self.offset = iprot.readI64();
16370 
        else:
16371 
          iprot.skip(ftype)
16372 
      elif fid == 3:
16373 
        if ftype == TType.I64:
16374 
          self.limit = iprot.readI64();
16375 
        else:
16376 
          iprot.skip(ftype)
16377 
      else:
16378 
        iprot.skip(ftype)
16379 
      iprot.readFieldEnd()
16380 
    iprot.readStructEnd()
16381 
 
16382 
  def write(self, oprot):
16383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16385 
      return
16386 
    oprot.writeStructBegin('searchItemsInRange_args')
16387 
    if self.searchTerms is not None:
16388 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16389 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16390 
      for iter331 in self.searchTerms:
16391 
        oprot.writeString(iter331)
5944 mandeep.dh 16392 
      oprot.writeListEnd()
16393 
      oprot.writeFieldEnd()
16394 
    if self.offset is not None:
16395 
      oprot.writeFieldBegin('offset', TType.I64, 2)
16396 
      oprot.writeI64(self.offset)
16397 
      oprot.writeFieldEnd()
16398 
    if self.limit is not None:
16399 
      oprot.writeFieldBegin('limit', TType.I64, 3)
16400 
      oprot.writeI64(self.limit)
16401 
      oprot.writeFieldEnd()
16402 
    oprot.writeFieldStop()
16403 
    oprot.writeStructEnd()
16404 
 
16405 
  def validate(self):
16406 
    return
16407 
 
16408 
 
16409 
  def __repr__(self):
16410 
    L = ['%s=%r' % (key, value)
16411 
      for key, value in self.__dict__.iteritems()]
16412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16413 
 
16414 
  def __eq__(self, other):
16415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16416 
 
16417 
  def __ne__(self, other):
16418 
    return not (self == other)
16419 
 
16420 
class searchItemsInRange_result:
16421 
  """
16422 
  Attributes:
16423 
   - success
16424 
  """
16425 
 
16426 
  thrift_spec = (
16427 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16428 
  )
16429 
 
16430 
  def __init__(self, success=None,):
16431 
    self.success = success
16432 
 
16433 
  def read(self, iprot):
16434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16436 
      return
16437 
    iprot.readStructBegin()
16438 
    while True:
16439 
      (fname, ftype, fid) = iprot.readFieldBegin()
16440 
      if ftype == TType.STOP:
16441 
        break
16442 
      if fid == 0:
16443 
        if ftype == TType.LIST:
16444 
          self.success = []
9155 kshitij.so 16445 
          (_etype335, _size332) = iprot.readListBegin()
16446 
          for _i336 in xrange(_size332):
16447 
            _elem337 = Item()
16448 
            _elem337.read(iprot)
16449 
            self.success.append(_elem337)
5944 mandeep.dh 16450 
          iprot.readListEnd()
16451 
        else:
16452 
          iprot.skip(ftype)
16453 
      else:
16454 
        iprot.skip(ftype)
16455 
      iprot.readFieldEnd()
16456 
    iprot.readStructEnd()
16457 
 
16458 
  def write(self, oprot):
16459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16461 
      return
16462 
    oprot.writeStructBegin('searchItemsInRange_result')
16463 
    if self.success is not None:
16464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16465 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16466 
      for iter338 in self.success:
16467 
        iter338.write(oprot)
5944 mandeep.dh 16468 
      oprot.writeListEnd()
16469 
      oprot.writeFieldEnd()
16470 
    oprot.writeFieldStop()
16471 
    oprot.writeStructEnd()
16472 
 
16473 
  def validate(self):
16474 
    return
16475 
 
16476 
 
16477 
  def __repr__(self):
16478 
    L = ['%s=%r' % (key, value)
16479 
      for key, value in self.__dict__.iteritems()]
16480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16481 
 
16482 
  def __eq__(self, other):
16483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16484 
 
16485 
  def __ne__(self, other):
16486 
    return not (self == other)
16487 
 
16488 
class getSearchResultCount_args:
16489 
  """
16490 
  Attributes:
16491 
   - searchTerms
16492 
  """
16493 
 
16494 
  thrift_spec = (
16495 
    None, # 0
16496 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16497 
  )
16498 
 
16499 
  def __init__(self, searchTerms=None,):
16500 
    self.searchTerms = searchTerms
16501 
 
16502 
  def read(self, iprot):
16503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16505 
      return
16506 
    iprot.readStructBegin()
16507 
    while True:
16508 
      (fname, ftype, fid) = iprot.readFieldBegin()
16509 
      if ftype == TType.STOP:
16510 
        break
16511 
      if fid == 1:
16512 
        if ftype == TType.LIST:
16513 
          self.searchTerms = []
9155 kshitij.so 16514 
          (_etype342, _size339) = iprot.readListBegin()
16515 
          for _i343 in xrange(_size339):
16516 
            _elem344 = iprot.readString();
16517 
            self.searchTerms.append(_elem344)
5944 mandeep.dh 16518 
          iprot.readListEnd()
16519 
        else:
16520 
          iprot.skip(ftype)
16521 
      else:
16522 
        iprot.skip(ftype)
16523 
      iprot.readFieldEnd()
16524 
    iprot.readStructEnd()
16525 
 
16526 
  def write(self, oprot):
16527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16529 
      return
16530 
    oprot.writeStructBegin('getSearchResultCount_args')
16531 
    if self.searchTerms is not None:
16532 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16533 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
9155 kshitij.so 16534 
      for iter345 in self.searchTerms:
16535 
        oprot.writeString(iter345)
5944 mandeep.dh 16536 
      oprot.writeListEnd()
16537 
      oprot.writeFieldEnd()
16538 
    oprot.writeFieldStop()
16539 
    oprot.writeStructEnd()
16540 
 
16541 
  def validate(self):
16542 
    return
16543 
 
16544 
 
16545 
  def __repr__(self):
16546 
    L = ['%s=%r' % (key, value)
16547 
      for key, value in self.__dict__.iteritems()]
16548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16549 
 
16550 
  def __eq__(self, other):
16551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16552 
 
16553 
  def __ne__(self, other):
16554 
    return not (self == other)
16555 
 
16556 
class getSearchResultCount_result:
16557 
  """
16558 
  Attributes:
16559 
   - success
16560 
  """
16561 
 
16562 
  thrift_spec = (
16563 
    (0, TType.I32, 'success', None, None, ), # 0
16564 
  )
16565 
 
16566 
  def __init__(self, success=None,):
16567 
    self.success = success
16568 
 
16569 
  def read(self, iprot):
16570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16572 
      return
16573 
    iprot.readStructBegin()
16574 
    while True:
16575 
      (fname, ftype, fid) = iprot.readFieldBegin()
16576 
      if ftype == TType.STOP:
16577 
        break
16578 
      if fid == 0:
16579 
        if ftype == TType.I32:
16580 
          self.success = iprot.readI32();
16581 
        else:
16582 
          iprot.skip(ftype)
16583 
      else:
16584 
        iprot.skip(ftype)
16585 
      iprot.readFieldEnd()
16586 
    iprot.readStructEnd()
16587 
 
16588 
  def write(self, oprot):
16589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16591 
      return
16592 
    oprot.writeStructBegin('getSearchResultCount_result')
16593 
    if self.success is not None:
16594 
      oprot.writeFieldBegin('success', TType.I32, 0)
16595 
      oprot.writeI32(self.success)
16596 
      oprot.writeFieldEnd()
16597 
    oprot.writeFieldStop()
16598 
    oprot.writeStructEnd()
16599 
 
16600 
  def validate(self):
16601 
    return
16602 
 
16603 
 
16604 
  def __repr__(self):
16605 
    L = ['%s=%r' % (key, value)
16606 
      for key, value in self.__dict__.iteritems()]
16607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16608 
 
16609 
  def __eq__(self, other):
16610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16611 
 
16612 
  def __ne__(self, other):
16613 
    return not (self == other)
16614 
 
16615 
class getProductNotifications_args:
16616 
  """
16617 
  Attributes:
16618 
   - startDateTime
16619 
  """
16620 
 
16621 
  thrift_spec = (
16622 
    None, # 0
16623 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
16624 
  )
16625 
 
16626 
  def __init__(self, startDateTime=None,):
16627 
    self.startDateTime = startDateTime
16628 
 
16629 
  def read(self, iprot):
16630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16632 
      return
16633 
    iprot.readStructBegin()
16634 
    while True:
16635 
      (fname, ftype, fid) = iprot.readFieldBegin()
16636 
      if ftype == TType.STOP:
16637 
        break
16638 
      if fid == 1:
16639 
        if ftype == TType.I64:
16640 
          self.startDateTime = iprot.readI64();
16641 
        else:
16642 
          iprot.skip(ftype)
16643 
      else:
16644 
        iprot.skip(ftype)
16645 
      iprot.readFieldEnd()
16646 
    iprot.readStructEnd()
16647 
 
16648 
  def write(self, oprot):
16649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16651 
      return
16652 
    oprot.writeStructBegin('getProductNotifications_args')
16653 
    if self.startDateTime is not None:
16654 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16655 
      oprot.writeI64(self.startDateTime)
16656 
      oprot.writeFieldEnd()
16657 
    oprot.writeFieldStop()
16658 
    oprot.writeStructEnd()
16659 
 
16660 
  def validate(self):
16661 
    return
16662 
 
16663 
 
16664 
  def __repr__(self):
16665 
    L = ['%s=%r' % (key, value)
16666 
      for key, value in self.__dict__.iteritems()]
16667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16668 
 
16669 
  def __eq__(self, other):
16670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16671 
 
16672 
  def __ne__(self, other):
16673 
    return not (self == other)
16674 
 
16675 
class getProductNotifications_result:
16676 
  """
16677 
  Attributes:
16678 
   - success
16679 
  """
16680 
 
16681 
  thrift_spec = (
16682 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
16683 
  )
16684 
 
16685 
  def __init__(self, success=None,):
16686 
    self.success = success
16687 
 
16688 
  def read(self, iprot):
16689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16691 
      return
16692 
    iprot.readStructBegin()
16693 
    while True:
16694 
      (fname, ftype, fid) = iprot.readFieldBegin()
16695 
      if ftype == TType.STOP:
16696 
        break
16697 
      if fid == 0:
16698 
        if ftype == TType.LIST:
16699 
          self.success = []
9155 kshitij.so 16700 
          (_etype349, _size346) = iprot.readListBegin()
16701 
          for _i350 in xrange(_size346):
16702 
            _elem351 = ProductNotificationRequest()
16703 
            _elem351.read(iprot)
16704 
            self.success.append(_elem351)
5944 mandeep.dh 16705 
          iprot.readListEnd()
16706 
        else:
16707 
          iprot.skip(ftype)
16708 
      else:
16709 
        iprot.skip(ftype)
16710 
      iprot.readFieldEnd()
16711 
    iprot.readStructEnd()
16712 
 
16713 
  def write(self, oprot):
16714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16716 
      return
16717 
    oprot.writeStructBegin('getProductNotifications_result')
16718 
    if self.success is not None:
16719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16720 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16721 
      for iter352 in self.success:
16722 
        iter352.write(oprot)
5944 mandeep.dh 16723 
      oprot.writeListEnd()
16724 
      oprot.writeFieldEnd()
16725 
    oprot.writeFieldStop()
16726 
    oprot.writeStructEnd()
16727 
 
16728 
  def validate(self):
16729 
    return
16730 
 
16731 
 
16732 
  def __repr__(self):
16733 
    L = ['%s=%r' % (key, value)
16734 
      for key, value in self.__dict__.iteritems()]
16735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16736 
 
16737 
  def __eq__(self, other):
16738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16739 
 
16740 
  def __ne__(self, other):
16741 
    return not (self == other)
16742 
 
16743 
class getProductNotificationRequestCount_args:
16744 
  """
16745 
  Attributes:
16746 
   - startDateTime
7897 amar.kumar 16747 
   - categoryId
5944 mandeep.dh 16748 
  """
16749 
 
16750 
  thrift_spec = (
16751 
    None, # 0
16752 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 16753 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 16754 
  )
16755 
 
7897 amar.kumar 16756 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 16757 
    self.startDateTime = startDateTime
7897 amar.kumar 16758 
    self.categoryId = categoryId
5944 mandeep.dh 16759 
 
16760 
  def read(self, iprot):
16761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16763 
      return
16764 
    iprot.readStructBegin()
16765 
    while True:
16766 
      (fname, ftype, fid) = iprot.readFieldBegin()
16767 
      if ftype == TType.STOP:
16768 
        break
16769 
      if fid == 1:
16770 
        if ftype == TType.I64:
16771 
          self.startDateTime = iprot.readI64();
16772 
        else:
16773 
          iprot.skip(ftype)
7897 amar.kumar 16774 
      elif fid == 2:
16775 
        if ftype == TType.I64:
16776 
          self.categoryId = iprot.readI64();
16777 
        else:
16778 
          iprot.skip(ftype)
5944 mandeep.dh 16779 
      else:
16780 
        iprot.skip(ftype)
16781 
      iprot.readFieldEnd()
16782 
    iprot.readStructEnd()
16783 
 
16784 
  def write(self, oprot):
16785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16787 
      return
16788 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
16789 
    if self.startDateTime is not None:
16790 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16791 
      oprot.writeI64(self.startDateTime)
16792 
      oprot.writeFieldEnd()
7897 amar.kumar 16793 
    if self.categoryId is not None:
16794 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
16795 
      oprot.writeI64(self.categoryId)
16796 
      oprot.writeFieldEnd()
5944 mandeep.dh 16797 
    oprot.writeFieldStop()
16798 
    oprot.writeStructEnd()
16799 
 
16800 
  def validate(self):
16801 
    return
16802 
 
16803 
 
16804 
  def __repr__(self):
16805 
    L = ['%s=%r' % (key, value)
16806 
      for key, value in self.__dict__.iteritems()]
16807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16808 
 
16809 
  def __eq__(self, other):
16810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16811 
 
16812 
  def __ne__(self, other):
16813 
    return not (self == other)
16814 
 
16815 
class getProductNotificationRequestCount_result:
16816 
  """
16817 
  Attributes:
16818 
   - success
16819 
  """
16820 
 
16821 
  thrift_spec = (
16822 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
16823 
  )
16824 
 
16825 
  def __init__(self, success=None,):
16826 
    self.success = success
16827 
 
16828 
  def read(self, iprot):
16829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16831 
      return
16832 
    iprot.readStructBegin()
16833 
    while True:
16834 
      (fname, ftype, fid) = iprot.readFieldBegin()
16835 
      if ftype == TType.STOP:
16836 
        break
16837 
      if fid == 0:
16838 
        if ftype == TType.LIST:
16839 
          self.success = []
9155 kshitij.so 16840 
          (_etype356, _size353) = iprot.readListBegin()
16841 
          for _i357 in xrange(_size353):
16842 
            _elem358 = ProductNotificationRequestCount()
16843 
            _elem358.read(iprot)
16844 
            self.success.append(_elem358)
5944 mandeep.dh 16845 
          iprot.readListEnd()
16846 
        else:
16847 
          iprot.skip(ftype)
16848 
      else:
16849 
        iprot.skip(ftype)
16850 
      iprot.readFieldEnd()
16851 
    iprot.readStructEnd()
16852 
 
16853 
  def write(self, oprot):
16854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16856 
      return
16857 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16858 
    if self.success is not None:
16859 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16860 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 16861 
      for iter359 in self.success:
16862 
        iter359.write(oprot)
5944 mandeep.dh 16863 
      oprot.writeListEnd()
16864 
      oprot.writeFieldEnd()
16865 
    oprot.writeFieldStop()
16866 
    oprot.writeStructEnd()
16867 
 
16868 
  def validate(self):
16869 
    return
16870 
 
16871 
 
16872 
  def __repr__(self):
16873 
    L = ['%s=%r' % (key, value)
16874 
      for key, value in self.__dict__.iteritems()]
16875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16876 
 
16877 
  def __eq__(self, other):
16878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16879 
 
16880 
  def __ne__(self, other):
16881 
    return not (self == other)
16882 
 
16883 
class addAuthorizationLog_args:
16884 
  """
16885 
  Attributes:
16886 
   - itemId
16887 
   - username
16888 
   - reason
16889 
  """
16890 
 
16891 
  thrift_spec = (
16892 
    None, # 0
16893 
    (1, TType.I64, 'itemId', None, None, ), # 1
16894 
    (2, TType.STRING, 'username', None, None, ), # 2
16895 
    (3, TType.STRING, 'reason', None, None, ), # 3
16896 
  )
16897 
 
16898 
  def __init__(self, itemId=None, username=None, reason=None,):
16899 
    self.itemId = itemId
16900 
    self.username = username
16901 
    self.reason = reason
16902 
 
16903 
  def read(self, iprot):
16904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16906 
      return
16907 
    iprot.readStructBegin()
16908 
    while True:
16909 
      (fname, ftype, fid) = iprot.readFieldBegin()
16910 
      if ftype == TType.STOP:
16911 
        break
16912 
      if fid == 1:
16913 
        if ftype == TType.I64:
16914 
          self.itemId = iprot.readI64();
16915 
        else:
16916 
          iprot.skip(ftype)
16917 
      elif fid == 2:
16918 
        if ftype == TType.STRING:
16919 
          self.username = iprot.readString();
16920 
        else:
16921 
          iprot.skip(ftype)
16922 
      elif fid == 3:
16923 
        if ftype == TType.STRING:
16924 
          self.reason = iprot.readString();
16925 
        else:
16926 
          iprot.skip(ftype)
16927 
      else:
16928 
        iprot.skip(ftype)
16929 
      iprot.readFieldEnd()
16930 
    iprot.readStructEnd()
16931 
 
16932 
  def write(self, oprot):
16933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16935 
      return
16936 
    oprot.writeStructBegin('addAuthorizationLog_args')
16937 
    if self.itemId is not None:
16938 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16939 
      oprot.writeI64(self.itemId)
16940 
      oprot.writeFieldEnd()
16941 
    if self.username is not None:
16942 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16943 
      oprot.writeString(self.username)
16944 
      oprot.writeFieldEnd()
16945 
    if self.reason is not None:
16946 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16947 
      oprot.writeString(self.reason)
16948 
      oprot.writeFieldEnd()
16949 
    oprot.writeFieldStop()
16950 
    oprot.writeStructEnd()
16951 
 
16952 
  def validate(self):
16953 
    return
16954 
 
16955 
 
16956 
  def __repr__(self):
16957 
    L = ['%s=%r' % (key, value)
16958 
      for key, value in self.__dict__.iteritems()]
16959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16960 
 
16961 
  def __eq__(self, other):
16962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16963 
 
16964 
  def __ne__(self, other):
16965 
    return not (self == other)
16966 
 
16967 
class addAuthorizationLog_result:
16968 
  """
16969 
  Attributes:
16970 
   - success
16971 
   - cex
16972 
  """
16973 
 
16974 
  thrift_spec = (
16975 
    (0, TType.BOOL, 'success', None, None, ), # 0
16976 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16977 
  )
16978 
 
16979 
  def __init__(self, success=None, cex=None,):
16980 
    self.success = success
16981 
    self.cex = cex
16982 
 
16983 
  def read(self, iprot):
16984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16986 
      return
16987 
    iprot.readStructBegin()
16988 
    while True:
16989 
      (fname, ftype, fid) = iprot.readFieldBegin()
16990 
      if ftype == TType.STOP:
16991 
        break
16992 
      if fid == 0:
16993 
        if ftype == TType.BOOL:
16994 
          self.success = iprot.readBool();
16995 
        else:
16996 
          iprot.skip(ftype)
16997 
      elif fid == 1:
16998 
        if ftype == TType.STRUCT:
16999 
          self.cex = CatalogServiceException()
17000 
          self.cex.read(iprot)
17001 
        else:
17002 
          iprot.skip(ftype)
17003 
      else:
17004 
        iprot.skip(ftype)
17005 
      iprot.readFieldEnd()
17006 
    iprot.readStructEnd()
17007 
 
17008 
  def write(self, oprot):
17009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17011 
      return
17012 
    oprot.writeStructBegin('addAuthorizationLog_result')
17013 
    if self.success is not None:
17014 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17015 
      oprot.writeBool(self.success)
17016 
      oprot.writeFieldEnd()
17017 
    if self.cex is not None:
17018 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17019 
      self.cex.write(oprot)
17020 
      oprot.writeFieldEnd()
17021 
    oprot.writeFieldStop()
17022 
    oprot.writeStructEnd()
17023 
 
17024 
  def validate(self):
17025 
    return
17026 
 
17027 
 
17028 
  def __repr__(self):
17029 
    L = ['%s=%r' % (key, value)
17030 
      for key, value in self.__dict__.iteritems()]
17031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17032 
 
17033 
  def __eq__(self, other):
17034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17035 
 
17036 
  def __ne__(self, other):
17037 
    return not (self == other)
17038 
 
17039 
class addupdateVoucherForItem_args:
17040 
  """
17041 
  Attributes:
17042 
   - catalog_item_id
17043 
   - voucherType
17044 
   - voucherAmount
17045 
  """
17046 
 
17047 
  thrift_spec = (
17048 
    None, # 0
17049 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17050 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17051 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
17052 
  )
17053 
 
17054 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
17055 
    self.catalog_item_id = catalog_item_id
17056 
    self.voucherType = voucherType
17057 
    self.voucherAmount = voucherAmount
17058 
 
17059 
  def read(self, iprot):
17060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17062 
      return
17063 
    iprot.readStructBegin()
17064 
    while True:
17065 
      (fname, ftype, fid) = iprot.readFieldBegin()
17066 
      if ftype == TType.STOP:
17067 
        break
17068 
      if fid == 1:
17069 
        if ftype == TType.I64:
17070 
          self.catalog_item_id = iprot.readI64();
17071 
        else:
17072 
          iprot.skip(ftype)
17073 
      elif fid == 2:
17074 
        if ftype == TType.I64:
17075 
          self.voucherType = iprot.readI64();
17076 
        else:
17077 
          iprot.skip(ftype)
17078 
      elif fid == 3:
17079 
        if ftype == TType.I64:
17080 
          self.voucherAmount = iprot.readI64();
17081 
        else:
17082 
          iprot.skip(ftype)
17083 
      else:
17084 
        iprot.skip(ftype)
17085 
      iprot.readFieldEnd()
17086 
    iprot.readStructEnd()
17087 
 
17088 
  def write(self, oprot):
17089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17091 
      return
17092 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
17093 
    if self.catalog_item_id is not None:
17094 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17095 
      oprot.writeI64(self.catalog_item_id)
17096 
      oprot.writeFieldEnd()
17097 
    if self.voucherType is not None:
17098 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17099 
      oprot.writeI64(self.voucherType)
17100 
      oprot.writeFieldEnd()
17101 
    if self.voucherAmount is not None:
17102 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
17103 
      oprot.writeI64(self.voucherAmount)
17104 
      oprot.writeFieldEnd()
17105 
    oprot.writeFieldStop()
17106 
    oprot.writeStructEnd()
17107 
 
17108 
  def validate(self):
17109 
    return
17110 
 
17111 
 
17112 
  def __repr__(self):
17113 
    L = ['%s=%r' % (key, value)
17114 
      for key, value in self.__dict__.iteritems()]
17115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17116 
 
17117 
  def __eq__(self, other):
17118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17119 
 
17120 
  def __ne__(self, other):
17121 
    return not (self == other)
17122 
 
17123 
class addupdateVoucherForItem_result:
17124 
  """
17125 
  Attributes:
17126 
   - success
17127 
   - cex
17128 
  """
17129 
 
17130 
  thrift_spec = (
17131 
    (0, TType.BOOL, 'success', None, None, ), # 0
17132 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17133 
  )
17134 
 
17135 
  def __init__(self, success=None, cex=None,):
17136 
    self.success = success
17137 
    self.cex = cex
17138 
 
17139 
  def read(self, iprot):
17140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17142 
      return
17143 
    iprot.readStructBegin()
17144 
    while True:
17145 
      (fname, ftype, fid) = iprot.readFieldBegin()
17146 
      if ftype == TType.STOP:
17147 
        break
17148 
      if fid == 0:
17149 
        if ftype == TType.BOOL:
17150 
          self.success = iprot.readBool();
17151 
        else:
17152 
          iprot.skip(ftype)
17153 
      elif fid == 1:
17154 
        if ftype == TType.STRUCT:
17155 
          self.cex = CatalogServiceException()
17156 
          self.cex.read(iprot)
17157 
        else:
17158 
          iprot.skip(ftype)
17159 
      else:
17160 
        iprot.skip(ftype)
17161 
      iprot.readFieldEnd()
17162 
    iprot.readStructEnd()
17163 
 
17164 
  def write(self, oprot):
17165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17167 
      return
17168 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
17169 
    if self.success is not None:
17170 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17171 
      oprot.writeBool(self.success)
17172 
      oprot.writeFieldEnd()
17173 
    if self.cex is not None:
17174 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17175 
      self.cex.write(oprot)
17176 
      oprot.writeFieldEnd()
17177 
    oprot.writeFieldStop()
17178 
    oprot.writeStructEnd()
17179 
 
17180 
  def validate(self):
17181 
    return
17182 
 
17183 
 
17184 
  def __repr__(self):
17185 
    L = ['%s=%r' % (key, value)
17186 
      for key, value in self.__dict__.iteritems()]
17187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17188 
 
17189 
  def __eq__(self, other):
17190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17191 
 
17192 
  def __ne__(self, other):
17193 
    return not (self == other)
17194 
 
17195 
class deleteVoucherForItem_args:
17196 
  """
17197 
  Attributes:
17198 
   - catalog_item_id
17199 
   - voucherType
17200 
  """
17201 
 
17202 
  thrift_spec = (
17203 
    None, # 0
17204 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17205 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17206 
  )
17207 
 
17208 
  def __init__(self, catalog_item_id=None, voucherType=None,):
17209 
    self.catalog_item_id = catalog_item_id
17210 
    self.voucherType = voucherType
17211 
 
17212 
  def read(self, iprot):
17213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17215 
      return
17216 
    iprot.readStructBegin()
17217 
    while True:
17218 
      (fname, ftype, fid) = iprot.readFieldBegin()
17219 
      if ftype == TType.STOP:
17220 
        break
17221 
      if fid == 1:
17222 
        if ftype == TType.I64:
17223 
          self.catalog_item_id = iprot.readI64();
17224 
        else:
17225 
          iprot.skip(ftype)
17226 
      elif fid == 2:
17227 
        if ftype == TType.I64:
17228 
          self.voucherType = iprot.readI64();
17229 
        else:
17230 
          iprot.skip(ftype)
17231 
      else:
17232 
        iprot.skip(ftype)
17233 
      iprot.readFieldEnd()
17234 
    iprot.readStructEnd()
17235 
 
17236 
  def write(self, oprot):
17237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17239 
      return
17240 
    oprot.writeStructBegin('deleteVoucherForItem_args')
17241 
    if self.catalog_item_id is not None:
17242 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17243 
      oprot.writeI64(self.catalog_item_id)
17244 
      oprot.writeFieldEnd()
17245 
    if self.voucherType is not None:
17246 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17247 
      oprot.writeI64(self.voucherType)
17248 
      oprot.writeFieldEnd()
17249 
    oprot.writeFieldStop()
17250 
    oprot.writeStructEnd()
17251 
 
17252 
  def validate(self):
17253 
    return
17254 
 
17255 
 
17256 
  def __repr__(self):
17257 
    L = ['%s=%r' % (key, value)
17258 
      for key, value in self.__dict__.iteritems()]
17259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17260 
 
17261 
  def __eq__(self, other):
17262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17263 
 
17264 
  def __ne__(self, other):
17265 
    return not (self == other)
17266 
 
17267 
class deleteVoucherForItem_result:
17268 
  """
17269 
  Attributes:
17270 
   - success
17271 
   - cex
17272 
  """
17273 
 
17274 
  thrift_spec = (
17275 
    (0, TType.BOOL, 'success', None, None, ), # 0
17276 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
17277 
  )
17278 
 
17279 
  def __init__(self, success=None, cex=None,):
17280 
    self.success = success
17281 
    self.cex = cex
17282 
 
17283 
  def read(self, iprot):
17284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17286 
      return
17287 
    iprot.readStructBegin()
17288 
    while True:
17289 
      (fname, ftype, fid) = iprot.readFieldBegin()
17290 
      if ftype == TType.STOP:
17291 
        break
17292 
      if fid == 0:
17293 
        if ftype == TType.BOOL:
17294 
          self.success = iprot.readBool();
17295 
        else:
17296 
          iprot.skip(ftype)
17297 
      elif fid == 1:
17298 
        if ftype == TType.STRUCT:
17299 
          self.cex = CatalogServiceException()
17300 
          self.cex.read(iprot)
17301 
        else:
17302 
          iprot.skip(ftype)
17303 
      else:
17304 
        iprot.skip(ftype)
17305 
      iprot.readFieldEnd()
17306 
    iprot.readStructEnd()
17307 
 
17308 
  def write(self, oprot):
17309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17311 
      return
17312 
    oprot.writeStructBegin('deleteVoucherForItem_result')
17313 
    if self.success is not None:
17314 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17315 
      oprot.writeBool(self.success)
17316 
      oprot.writeFieldEnd()
17317 
    if self.cex is not None:
17318 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17319 
      self.cex.write(oprot)
17320 
      oprot.writeFieldEnd()
17321 
    oprot.writeFieldStop()
17322 
    oprot.writeStructEnd()
17323 
 
17324 
  def validate(self):
17325 
    return
17326 
 
17327 
 
17328 
  def __repr__(self):
17329 
    L = ['%s=%r' % (key, value)
17330 
      for key, value in self.__dict__.iteritems()]
17331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17332 
 
17333 
  def __eq__(self, other):
17334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17335 
 
17336 
  def __ne__(self, other):
17337 
    return not (self == other)
17338 
 
17339 
class getVoucherAmount_args:
17340 
  """
17341 
  Attributes:
17342 
   - itemId
17343 
   - voucherType
17344 
  """
17345 
 
17346 
  thrift_spec = (
17347 
    None, # 0
17348 
    (1, TType.I64, 'itemId', None, None, ), # 1
17349 
    (2, TType.I64, 'voucherType', None, None, ), # 2
17350 
  )
17351 
 
17352 
  def __init__(self, itemId=None, voucherType=None,):
17353 
    self.itemId = itemId
17354 
    self.voucherType = voucherType
17355 
 
17356 
  def read(self, iprot):
17357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17359 
      return
17360 
    iprot.readStructBegin()
17361 
    while True:
17362 
      (fname, ftype, fid) = iprot.readFieldBegin()
17363 
      if ftype == TType.STOP:
17364 
        break
17365 
      if fid == 1:
17366 
        if ftype == TType.I64:
17367 
          self.itemId = iprot.readI64();
17368 
        else:
17369 
          iprot.skip(ftype)
17370 
      elif fid == 2:
17371 
        if ftype == TType.I64:
17372 
          self.voucherType = iprot.readI64();
17373 
        else:
17374 
          iprot.skip(ftype)
17375 
      else:
17376 
        iprot.skip(ftype)
17377 
      iprot.readFieldEnd()
17378 
    iprot.readStructEnd()
17379 
 
17380 
  def write(self, oprot):
17381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17383 
      return
17384 
    oprot.writeStructBegin('getVoucherAmount_args')
17385 
    if self.itemId is not None:
17386 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17387 
      oprot.writeI64(self.itemId)
17388 
      oprot.writeFieldEnd()
17389 
    if self.voucherType is not None:
17390 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
17391 
      oprot.writeI64(self.voucherType)
17392 
      oprot.writeFieldEnd()
17393 
    oprot.writeFieldStop()
17394 
    oprot.writeStructEnd()
17395 
 
17396 
  def validate(self):
17397 
    return
17398 
 
17399 
 
17400 
  def __repr__(self):
17401 
    L = ['%s=%r' % (key, value)
17402 
      for key, value in self.__dict__.iteritems()]
17403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17404 
 
17405 
  def __eq__(self, other):
17406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17407 
 
17408 
  def __ne__(self, other):
17409 
    return not (self == other)
17410 
 
17411 
class getVoucherAmount_result:
17412 
  """
17413 
  Attributes:
17414 
   - success
17415 
  """
17416 
 
17417 
  thrift_spec = (
17418 
    (0, TType.I64, 'success', None, None, ), # 0
17419 
  )
17420 
 
17421 
  def __init__(self, success=None,):
17422 
    self.success = success
17423 
 
17424 
  def read(self, iprot):
17425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17427 
      return
17428 
    iprot.readStructBegin()
17429 
    while True:
17430 
      (fname, ftype, fid) = iprot.readFieldBegin()
17431 
      if ftype == TType.STOP:
17432 
        break
17433 
      if fid == 0:
17434 
        if ftype == TType.I64:
17435 
          self.success = iprot.readI64();
17436 
        else:
17437 
          iprot.skip(ftype)
17438 
      else:
17439 
        iprot.skip(ftype)
17440 
      iprot.readFieldEnd()
17441 
    iprot.readStructEnd()
17442 
 
17443 
  def write(self, oprot):
17444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17446 
      return
17447 
    oprot.writeStructBegin('getVoucherAmount_result')
17448 
    if self.success is not None:
17449 
      oprot.writeFieldBegin('success', TType.I64, 0)
17450 
      oprot.writeI64(self.success)
17451 
      oprot.writeFieldEnd()
17452 
    oprot.writeFieldStop()
17453 
    oprot.writeStructEnd()
17454 
 
17455 
  def validate(self):
17456 
    return
17457 
 
17458 
 
17459 
  def __repr__(self):
17460 
    L = ['%s=%r' % (key, value)
17461 
      for key, value in self.__dict__.iteritems()]
17462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17463 
 
17464 
  def __eq__(self, other):
17465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17466 
 
17467 
  def __ne__(self, other):
17468 
    return not (self == other)
17469 
 
17470 
class getAllItemVouchers_args:
17471 
  """
17472 
  Attributes:
17473 
   - itemId
17474 
  """
17475 
 
17476 
  thrift_spec = (
17477 
    None, # 0
17478 
    (1, TType.I64, 'itemId', None, None, ), # 1
17479 
  )
17480 
 
17481 
  def __init__(self, itemId=None,):
17482 
    self.itemId = itemId
17483 
 
17484 
  def read(self, iprot):
17485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17487 
      return
17488 
    iprot.readStructBegin()
17489 
    while True:
17490 
      (fname, ftype, fid) = iprot.readFieldBegin()
17491 
      if ftype == TType.STOP:
17492 
        break
17493 
      if fid == 1:
17494 
        if ftype == TType.I64:
17495 
          self.itemId = iprot.readI64();
17496 
        else:
17497 
          iprot.skip(ftype)
17498 
      else:
17499 
        iprot.skip(ftype)
17500 
      iprot.readFieldEnd()
17501 
    iprot.readStructEnd()
17502 
 
17503 
  def write(self, oprot):
17504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17506 
      return
17507 
    oprot.writeStructBegin('getAllItemVouchers_args')
17508 
    if self.itemId is not None:
17509 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17510 
      oprot.writeI64(self.itemId)
17511 
      oprot.writeFieldEnd()
17512 
    oprot.writeFieldStop()
17513 
    oprot.writeStructEnd()
17514 
 
17515 
  def validate(self):
17516 
    return
17517 
 
17518 
 
17519 
  def __repr__(self):
17520 
    L = ['%s=%r' % (key, value)
17521 
      for key, value in self.__dict__.iteritems()]
17522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17523 
 
17524 
  def __eq__(self, other):
17525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17526 
 
17527 
  def __ne__(self, other):
17528 
    return not (self == other)
17529 
 
17530 
class getAllItemVouchers_result:
17531 
  """
17532 
  Attributes:
17533 
   - success
17534 
  """
17535 
 
17536 
  thrift_spec = (
17537 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
17538 
  )
17539 
 
17540 
  def __init__(self, success=None,):
17541 
    self.success = success
17542 
 
17543 
  def read(self, iprot):
17544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17546 
      return
17547 
    iprot.readStructBegin()
17548 
    while True:
17549 
      (fname, ftype, fid) = iprot.readFieldBegin()
17550 
      if ftype == TType.STOP:
17551 
        break
17552 
      if fid == 0:
17553 
        if ftype == TType.LIST:
17554 
          self.success = []
9155 kshitij.so 17555 
          (_etype363, _size360) = iprot.readListBegin()
17556 
          for _i364 in xrange(_size360):
17557 
            _elem365 = VoucherItemMapping()
17558 
            _elem365.read(iprot)
17559 
            self.success.append(_elem365)
5944 mandeep.dh 17560 
          iprot.readListEnd()
17561 
        else:
17562 
          iprot.skip(ftype)
17563 
      else:
17564 
        iprot.skip(ftype)
17565 
      iprot.readFieldEnd()
17566 
    iprot.readStructEnd()
17567 
 
17568 
  def write(self, oprot):
17569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17571 
      return
17572 
    oprot.writeStructBegin('getAllItemVouchers_result')
17573 
    if self.success is not None:
17574 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17575 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 17576 
      for iter366 in self.success:
17577 
        iter366.write(oprot)
5944 mandeep.dh 17578 
      oprot.writeListEnd()
17579 
      oprot.writeFieldEnd()
17580 
    oprot.writeFieldStop()
17581 
    oprot.writeStructEnd()
17582 
 
17583 
  def validate(self):
17584 
    return
17585 
 
17586 
 
17587 
  def __repr__(self):
17588 
    L = ['%s=%r' % (key, value)
17589 
      for key, value in self.__dict__.iteritems()]
17590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17591 
 
17592 
  def __eq__(self, other):
17593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17594 
 
17595 
  def __ne__(self, other):
17596 
    return not (self == other)
17597 
 
17598 
class isValidCatalogItemId_args:
17599 
  """
17600 
  Attributes:
17601 
   - catalog_item_id
17602 
  """
17603 
 
17604 
  thrift_spec = (
17605 
    None, # 0
17606 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17607 
  )
17608 
 
17609 
  def __init__(self, catalog_item_id=None,):
17610 
    self.catalog_item_id = catalog_item_id
17611 
 
17612 
  def read(self, iprot):
17613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17615 
      return
17616 
    iprot.readStructBegin()
17617 
    while True:
17618 
      (fname, ftype, fid) = iprot.readFieldBegin()
17619 
      if ftype == TType.STOP:
17620 
        break
17621 
      if fid == 1:
17622 
        if ftype == TType.I64:
17623 
          self.catalog_item_id = iprot.readI64();
17624 
        else:
17625 
          iprot.skip(ftype)
17626 
      else:
17627 
        iprot.skip(ftype)
17628 
      iprot.readFieldEnd()
17629 
    iprot.readStructEnd()
17630 
 
17631 
  def write(self, oprot):
17632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17634 
      return
17635 
    oprot.writeStructBegin('isValidCatalogItemId_args')
17636 
    if self.catalog_item_id is not None:
17637 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17638 
      oprot.writeI64(self.catalog_item_id)
17639 
      oprot.writeFieldEnd()
17640 
    oprot.writeFieldStop()
17641 
    oprot.writeStructEnd()
17642 
 
17643 
  def validate(self):
17644 
    return
17645 
 
17646 
 
17647 
  def __repr__(self):
17648 
    L = ['%s=%r' % (key, value)
17649 
      for key, value in self.__dict__.iteritems()]
17650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17651 
 
17652 
  def __eq__(self, other):
17653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17654 
 
17655 
  def __ne__(self, other):
17656 
    return not (self == other)
17657 
 
17658 
class isValidCatalogItemId_result:
17659 
  """
17660 
  Attributes:
17661 
   - success
17662 
  """
17663 
 
17664 
  thrift_spec = (
17665 
    (0, TType.BOOL, 'success', None, None, ), # 0
17666 
  )
17667 
 
17668 
  def __init__(self, success=None,):
17669 
    self.success = success
17670 
 
17671 
  def read(self, iprot):
17672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17674 
      return
17675 
    iprot.readStructBegin()
17676 
    while True:
17677 
      (fname, ftype, fid) = iprot.readFieldBegin()
17678 
      if ftype == TType.STOP:
17679 
        break
17680 
      if fid == 0:
17681 
        if ftype == TType.BOOL:
17682 
          self.success = iprot.readBool();
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('isValidCatalogItemId_result')
17695 
    if self.success is not None:
17696 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17697 
      oprot.writeBool(self.success)
17698 
      oprot.writeFieldEnd()
17699 
    oprot.writeFieldStop()
17700 
    oprot.writeStructEnd()
17701 
 
17702 
  def validate(self):
17703 
    return
17704 
 
17705 
 
17706 
  def __repr__(self):
17707 
    L = ['%s=%r' % (key, value)
17708 
      for key, value in self.__dict__.iteritems()]
17709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17710 
 
17711 
  def __eq__(self, other):
17712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17713 
 
17714 
  def __ne__(self, other):
17715 
    return not (self == other)
6039 amit.gupta 17716 
 
17717 
class getVatPercentageForItem_args:
17718 
  """
17719 
  Attributes:
17720 
   - itemId
7330 amit.gupta 17721 
   - stateId
6039 amit.gupta 17722 
   - price
17723 
  """
17724 
 
17725 
  thrift_spec = (
17726 
    None, # 0
17727 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 17728 
    (2, TType.I64, 'stateId', None, None, ), # 2
17729 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 17730 
  )
17731 
 
7330 amit.gupta 17732 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 17733 
    self.itemId = itemId
7330 amit.gupta 17734 
    self.stateId = stateId
6039 amit.gupta 17735 
    self.price = price
17736 
 
17737 
  def read(self, iprot):
17738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17740 
      return
17741 
    iprot.readStructBegin()
17742 
    while True:
17743 
      (fname, ftype, fid) = iprot.readFieldBegin()
17744 
      if ftype == TType.STOP:
17745 
        break
17746 
      if fid == 1:
17747 
        if ftype == TType.I64:
17748 
          self.itemId = iprot.readI64();
17749 
        else:
17750 
          iprot.skip(ftype)
17751 
      elif fid == 2:
7330 amit.gupta 17752 
        if ftype == TType.I64:
17753 
          self.stateId = iprot.readI64();
17754 
        else:
17755 
          iprot.skip(ftype)
17756 
      elif fid == 3:
6039 amit.gupta 17757 
        if ftype == TType.DOUBLE:
17758 
          self.price = iprot.readDouble();
17759 
        else:
17760 
          iprot.skip(ftype)
17761 
      else:
17762 
        iprot.skip(ftype)
17763 
      iprot.readFieldEnd()
17764 
    iprot.readStructEnd()
17765 
 
17766 
  def write(self, oprot):
17767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17769 
      return
17770 
    oprot.writeStructBegin('getVatPercentageForItem_args')
17771 
    if self.itemId is not None:
17772 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17773 
      oprot.writeI64(self.itemId)
17774 
      oprot.writeFieldEnd()
7330 amit.gupta 17775 
    if self.stateId is not None:
17776 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
17777 
      oprot.writeI64(self.stateId)
17778 
      oprot.writeFieldEnd()
6039 amit.gupta 17779 
    if self.price is not None:
7330 amit.gupta 17780 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 17781 
      oprot.writeDouble(self.price)
17782 
      oprot.writeFieldEnd()
17783 
    oprot.writeFieldStop()
17784 
    oprot.writeStructEnd()
17785 
 
17786 
  def validate(self):
17787 
    return
17788 
 
17789 
 
17790 
  def __repr__(self):
17791 
    L = ['%s=%r' % (key, value)
17792 
      for key, value in self.__dict__.iteritems()]
17793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17794 
 
17795 
  def __eq__(self, other):
17796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17797 
 
17798 
  def __ne__(self, other):
17799 
    return not (self == other)
17800 
 
17801 
class getVatPercentageForItem_result:
17802 
  """
17803 
  Attributes:
17804 
   - success
7340 amit.gupta 17805 
   - cex
6039 amit.gupta 17806 
  """
17807 
 
17808 
  thrift_spec = (
17809 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 17810 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 17811 
  )
17812 
 
7340 amit.gupta 17813 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 17814 
    self.success = success
7340 amit.gupta 17815 
    self.cex = cex
6039 amit.gupta 17816 
 
17817 
  def read(self, iprot):
17818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17820 
      return
17821 
    iprot.readStructBegin()
17822 
    while True:
17823 
      (fname, ftype, fid) = iprot.readFieldBegin()
17824 
      if ftype == TType.STOP:
17825 
        break
17826 
      if fid == 0:
17827 
        if ftype == TType.DOUBLE:
17828 
          self.success = iprot.readDouble();
17829 
        else:
17830 
          iprot.skip(ftype)
7340 amit.gupta 17831 
      elif fid == 1:
17832 
        if ftype == TType.STRUCT:
17833 
          self.cex = CatalogServiceException()
17834 
          self.cex.read(iprot)
17835 
        else:
17836 
          iprot.skip(ftype)
6039 amit.gupta 17837 
      else:
17838 
        iprot.skip(ftype)
17839 
      iprot.readFieldEnd()
17840 
    iprot.readStructEnd()
17841 
 
17842 
  def write(self, oprot):
17843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17845 
      return
17846 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17847 
    if self.success is not None:
17848 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17849 
      oprot.writeDouble(self.success)
17850 
      oprot.writeFieldEnd()
7340 amit.gupta 17851 
    if self.cex is not None:
17852 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17853 
      self.cex.write(oprot)
17854 
      oprot.writeFieldEnd()
6039 amit.gupta 17855 
    oprot.writeFieldStop()
17856 
    oprot.writeStructEnd()
17857 
 
17858 
  def validate(self):
17859 
    return
17860 
 
17861 
 
17862 
  def __repr__(self):
17863 
    L = ['%s=%r' % (key, value)
17864 
      for key, value in self.__dict__.iteritems()]
17865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17866 
 
17867 
  def __eq__(self, other):
17868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17869 
 
17870 
  def __ne__(self, other):
17871 
    return not (self == other)
17872 
 
17873 
class getVatAmountForItem_args:
17874 
  """
17875 
  Attributes:
17876 
   - itemId
17877 
   - price
17878 
  """
17879 
 
17880 
  thrift_spec = (
17881 
    None, # 0
17882 
    (1, TType.I64, 'itemId', None, None, ), # 1
17883 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17884 
  )
17885 
 
17886 
  def __init__(self, itemId=None, price=None,):
17887 
    self.itemId = itemId
17888 
    self.price = price
17889 
 
17890 
  def read(self, iprot):
17891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17893 
      return
17894 
    iprot.readStructBegin()
17895 
    while True:
17896 
      (fname, ftype, fid) = iprot.readFieldBegin()
17897 
      if ftype == TType.STOP:
17898 
        break
17899 
      if fid == 1:
17900 
        if ftype == TType.I64:
17901 
          self.itemId = iprot.readI64();
17902 
        else:
17903 
          iprot.skip(ftype)
17904 
      elif fid == 2:
17905 
        if ftype == TType.DOUBLE:
17906 
          self.price = iprot.readDouble();
17907 
        else:
17908 
          iprot.skip(ftype)
17909 
      else:
17910 
        iprot.skip(ftype)
17911 
      iprot.readFieldEnd()
17912 
    iprot.readStructEnd()
17913 
 
17914 
  def write(self, oprot):
17915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17917 
      return
17918 
    oprot.writeStructBegin('getVatAmountForItem_args')
17919 
    if self.itemId is not None:
17920 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17921 
      oprot.writeI64(self.itemId)
17922 
      oprot.writeFieldEnd()
17923 
    if self.price is not None:
17924 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17925 
      oprot.writeDouble(self.price)
17926 
      oprot.writeFieldEnd()
17927 
    oprot.writeFieldStop()
17928 
    oprot.writeStructEnd()
17929 
 
17930 
  def validate(self):
17931 
    return
17932 
 
17933 
 
17934 
  def __repr__(self):
17935 
    L = ['%s=%r' % (key, value)
17936 
      for key, value in self.__dict__.iteritems()]
17937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17938 
 
17939 
  def __eq__(self, other):
17940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17941 
 
17942 
  def __ne__(self, other):
17943 
    return not (self == other)
17944 
 
17945 
class getVatAmountForItem_result:
17946 
  """
17947 
  Attributes:
17948 
   - success
17949 
  """
17950 
 
17951 
  thrift_spec = (
17952 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17953 
  )
17954 
 
17955 
  def __init__(self, success=None,):
17956 
    self.success = success
17957 
 
17958 
  def read(self, iprot):
17959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17961 
      return
17962 
    iprot.readStructBegin()
17963 
    while True:
17964 
      (fname, ftype, fid) = iprot.readFieldBegin()
17965 
      if ftype == TType.STOP:
17966 
        break
17967 
      if fid == 0:
17968 
        if ftype == TType.DOUBLE:
17969 
          self.success = iprot.readDouble();
17970 
        else:
17971 
          iprot.skip(ftype)
17972 
      else:
17973 
        iprot.skip(ftype)
17974 
      iprot.readFieldEnd()
17975 
    iprot.readStructEnd()
17976 
 
17977 
  def write(self, oprot):
17978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17980 
      return
17981 
    oprot.writeStructBegin('getVatAmountForItem_result')
17982 
    if self.success is not None:
17983 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17984 
      oprot.writeDouble(self.success)
17985 
      oprot.writeFieldEnd()
17986 
    oprot.writeFieldStop()
17987 
    oprot.writeStructEnd()
17988 
 
17989 
  def validate(self):
17990 
    return
17991 
 
17992 
 
17993 
  def __repr__(self):
17994 
    L = ['%s=%r' % (key, value)
17995 
      for key, value in self.__dict__.iteritems()]
17996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17997 
 
17998 
  def __eq__(self, other):
17999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18000 
 
18001 
  def __ne__(self, other):
18002 
    return not (self == other)
6531 vikram.rag 18003 
 
18004 
class getAllIgnoredInventoryUpdateItemsList_args:
18005 
  """
18006 
  Attributes:
18007 
   - offset
18008 
   - limit
18009 
  """
18010 
 
18011 
  thrift_spec = (
18012 
    None, # 0
18013 
    (1, TType.I32, 'offset', None, None, ), # 1
18014 
    (2, TType.I32, 'limit', None, None, ), # 2
18015 
  )
18016 
 
18017 
  def __init__(self, offset=None, limit=None,):
18018 
    self.offset = offset
18019 
    self.limit = limit
18020 
 
18021 
  def read(self, iprot):
18022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18024 
      return
18025 
    iprot.readStructBegin()
18026 
    while True:
18027 
      (fname, ftype, fid) = iprot.readFieldBegin()
18028 
      if ftype == TType.STOP:
18029 
        break
18030 
      if fid == 1:
18031 
        if ftype == TType.I32:
18032 
          self.offset = iprot.readI32();
18033 
        else:
18034 
          iprot.skip(ftype)
18035 
      elif fid == 2:
18036 
        if ftype == TType.I32:
18037 
          self.limit = iprot.readI32();
18038 
        else:
18039 
          iprot.skip(ftype)
18040 
      else:
18041 
        iprot.skip(ftype)
18042 
      iprot.readFieldEnd()
18043 
    iprot.readStructEnd()
18044 
 
18045 
  def write(self, oprot):
18046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18048 
      return
18049 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
18050 
    if self.offset is not None:
18051 
      oprot.writeFieldBegin('offset', TType.I32, 1)
18052 
      oprot.writeI32(self.offset)
18053 
      oprot.writeFieldEnd()
18054 
    if self.limit is not None:
18055 
      oprot.writeFieldBegin('limit', TType.I32, 2)
18056 
      oprot.writeI32(self.limit)
18057 
      oprot.writeFieldEnd()
18058 
    oprot.writeFieldStop()
18059 
    oprot.writeStructEnd()
18060 
 
18061 
  def validate(self):
18062 
    return
18063 
 
18064 
 
18065 
  def __repr__(self):
18066 
    L = ['%s=%r' % (key, value)
18067 
      for key, value in self.__dict__.iteritems()]
18068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18069 
 
18070 
  def __eq__(self, other):
18071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18072 
 
18073 
  def __ne__(self, other):
18074 
    return not (self == other)
18075 
 
18076 
class getAllIgnoredInventoryUpdateItemsList_result:
18077 
  """
18078 
  Attributes:
18079 
   - success
18080 
  """
18081 
 
18082 
  thrift_spec = (
18083 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18084 
  )
18085 
 
18086 
  def __init__(self, success=None,):
18087 
    self.success = success
18088 
 
18089 
  def read(self, iprot):
18090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18092 
      return
18093 
    iprot.readStructBegin()
18094 
    while True:
18095 
      (fname, ftype, fid) = iprot.readFieldBegin()
18096 
      if ftype == TType.STOP:
18097 
        break
18098 
      if fid == 0:
18099 
        if ftype == TType.LIST:
18100 
          self.success = []
9155 kshitij.so 18101 
          (_etype370, _size367) = iprot.readListBegin()
18102 
          for _i371 in xrange(_size367):
18103 
            _elem372 = Item()
18104 
            _elem372.read(iprot)
18105 
            self.success.append(_elem372)
6531 vikram.rag 18106 
          iprot.readListEnd()
18107 
        else:
18108 
          iprot.skip(ftype)
18109 
      else:
18110 
        iprot.skip(ftype)
18111 
      iprot.readFieldEnd()
18112 
    iprot.readStructEnd()
18113 
 
18114 
  def write(self, oprot):
18115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18117 
      return
18118 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
18119 
    if self.success is not None:
18120 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18121 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18122 
      for iter373 in self.success:
18123 
        iter373.write(oprot)
6531 vikram.rag 18124 
      oprot.writeListEnd()
18125 
      oprot.writeFieldEnd()
18126 
    oprot.writeFieldStop()
18127 
    oprot.writeStructEnd()
18128 
 
18129 
  def validate(self):
18130 
    return
18131 
 
18132 
 
18133 
  def __repr__(self):
18134 
    L = ['%s=%r' % (key, value)
18135 
      for key, value in self.__dict__.iteritems()]
18136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18137 
 
18138 
  def __eq__(self, other):
18139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18140 
 
18141 
  def __ne__(self, other):
18142 
    return not (self == other)
6805 anupam.sin 18143 
 
6821 amar.kumar 18144 
class getAllAliveItems_args:
18145 
 
18146 
  thrift_spec = (
18147 
  )
18148 
 
18149 
  def read(self, iprot):
18150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18152 
      return
18153 
    iprot.readStructBegin()
18154 
    while True:
18155 
      (fname, ftype, fid) = iprot.readFieldBegin()
18156 
      if ftype == TType.STOP:
18157 
        break
18158 
      else:
18159 
        iprot.skip(ftype)
18160 
      iprot.readFieldEnd()
18161 
    iprot.readStructEnd()
18162 
 
18163 
  def write(self, oprot):
18164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18166 
      return
18167 
    oprot.writeStructBegin('getAllAliveItems_args')
18168 
    oprot.writeFieldStop()
18169 
    oprot.writeStructEnd()
18170 
 
18171 
  def validate(self):
18172 
    return
18173 
 
18174 
 
18175 
  def __repr__(self):
18176 
    L = ['%s=%r' % (key, value)
18177 
      for key, value in self.__dict__.iteritems()]
18178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18179 
 
18180 
  def __eq__(self, other):
18181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18182 
 
18183 
  def __ne__(self, other):
18184 
    return not (self == other)
18185 
 
18186 
class getAllAliveItems_result:
18187 
  """
18188 
  Attributes:
18189 
   - success
18190 
  """
18191 
 
18192 
  thrift_spec = (
18193 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
18194 
  )
18195 
 
18196 
  def __init__(self, success=None,):
18197 
    self.success = success
18198 
 
18199 
  def read(self, iprot):
18200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18202 
      return
18203 
    iprot.readStructBegin()
18204 
    while True:
18205 
      (fname, ftype, fid) = iprot.readFieldBegin()
18206 
      if ftype == TType.STOP:
18207 
        break
18208 
      if fid == 0:
18209 
        if ftype == TType.LIST:
18210 
          self.success = []
9155 kshitij.so 18211 
          (_etype377, _size374) = iprot.readListBegin()
18212 
          for _i378 in xrange(_size374):
18213 
            _elem379 = Item()
18214 
            _elem379.read(iprot)
18215 
            self.success.append(_elem379)
6821 amar.kumar 18216 
          iprot.readListEnd()
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('getAllAliveItems_result')
18229 
    if self.success is not None:
18230 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18231 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18232 
      for iter380 in self.success:
18233 
        iter380.write(oprot)
6821 amar.kumar 18234 
      oprot.writeListEnd()
18235 
      oprot.writeFieldEnd()
18236 
    oprot.writeFieldStop()
18237 
    oprot.writeStructEnd()
18238 
 
18239 
  def validate(self):
18240 
    return
18241 
 
18242 
 
18243 
  def __repr__(self):
18244 
    L = ['%s=%r' % (key, value)
18245 
      for key, value in self.__dict__.iteritems()]
18246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18247 
 
18248 
  def __eq__(self, other):
18249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18250 
 
18251 
  def __ne__(self, other):
18252 
    return not (self == other)
18253 
 
6805 anupam.sin 18254 
class getInsuranceAmount_args:
18255 
  """
18256 
  Attributes:
18257 
   - itemId
6921 anupam.sin 18258 
   - price
6805 anupam.sin 18259 
   - insurerId
18260 
   - quantity
18261 
  """
18262 
 
18263 
  thrift_spec = (
18264 
    None, # 0
18265 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 18266 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
18267 
    (3, TType.I64, 'insurerId', None, None, ), # 3
18268 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 18269 
  )
18270 
 
6921 anupam.sin 18271 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 18272 
    self.itemId = itemId
6921 anupam.sin 18273 
    self.price = price
6805 anupam.sin 18274 
    self.insurerId = insurerId
18275 
    self.quantity = quantity
18276 
 
18277 
  def read(self, iprot):
18278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18280 
      return
18281 
    iprot.readStructBegin()
18282 
    while True:
18283 
      (fname, ftype, fid) = iprot.readFieldBegin()
18284 
      if ftype == TType.STOP:
18285 
        break
18286 
      if fid == 1:
18287 
        if ftype == TType.I64:
18288 
          self.itemId = iprot.readI64();
18289 
        else:
18290 
          iprot.skip(ftype)
18291 
      elif fid == 2:
6921 anupam.sin 18292 
        if ftype == TType.DOUBLE:
18293 
          self.price = iprot.readDouble();
18294 
        else:
18295 
          iprot.skip(ftype)
18296 
      elif fid == 3:
6805 anupam.sin 18297 
        if ftype == TType.I64:
18298 
          self.insurerId = iprot.readI64();
18299 
        else:
18300 
          iprot.skip(ftype)
6921 anupam.sin 18301 
      elif fid == 4:
6805 anupam.sin 18302 
        if ftype == TType.I64:
18303 
          self.quantity = iprot.readI64();
18304 
        else:
18305 
          iprot.skip(ftype)
18306 
      else:
18307 
        iprot.skip(ftype)
18308 
      iprot.readFieldEnd()
18309 
    iprot.readStructEnd()
18310 
 
18311 
  def write(self, oprot):
18312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18314 
      return
18315 
    oprot.writeStructBegin('getInsuranceAmount_args')
18316 
    if self.itemId is not None:
18317 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18318 
      oprot.writeI64(self.itemId)
18319 
      oprot.writeFieldEnd()
6921 anupam.sin 18320 
    if self.price is not None:
18321 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
18322 
      oprot.writeDouble(self.price)
18323 
      oprot.writeFieldEnd()
6805 anupam.sin 18324 
    if self.insurerId is not None:
6921 anupam.sin 18325 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 18326 
      oprot.writeI64(self.insurerId)
18327 
      oprot.writeFieldEnd()
18328 
    if self.quantity is not None:
6921 anupam.sin 18329 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 18330 
      oprot.writeI64(self.quantity)
18331 
      oprot.writeFieldEnd()
18332 
    oprot.writeFieldStop()
18333 
    oprot.writeStructEnd()
18334 
 
18335 
  def validate(self):
18336 
    return
18337 
 
18338 
 
18339 
  def __repr__(self):
18340 
    L = ['%s=%r' % (key, value)
18341 
      for key, value in self.__dict__.iteritems()]
18342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18343 
 
18344 
  def __eq__(self, other):
18345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18346 
 
18347 
  def __ne__(self, other):
18348 
    return not (self == other)
18349 
 
18350 
class getInsuranceAmount_result:
18351 
  """
18352 
  Attributes:
18353 
   - success
18354 
  """
18355 
 
18356 
  thrift_spec = (
18357 
    (0, TType.I64, 'success', None, None, ), # 0
18358 
  )
18359 
 
18360 
  def __init__(self, success=None,):
18361 
    self.success = success
18362 
 
18363 
  def read(self, iprot):
18364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18366 
      return
18367 
    iprot.readStructBegin()
18368 
    while True:
18369 
      (fname, ftype, fid) = iprot.readFieldBegin()
18370 
      if ftype == TType.STOP:
18371 
        break
18372 
      if fid == 0:
18373 
        if ftype == TType.I64:
18374 
          self.success = iprot.readI64();
18375 
        else:
18376 
          iprot.skip(ftype)
18377 
      else:
18378 
        iprot.skip(ftype)
18379 
      iprot.readFieldEnd()
18380 
    iprot.readStructEnd()
18381 
 
18382 
  def write(self, oprot):
18383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18385 
      return
18386 
    oprot.writeStructBegin('getInsuranceAmount_result')
18387 
    if self.success is not None:
18388 
      oprot.writeFieldBegin('success', TType.I64, 0)
18389 
      oprot.writeI64(self.success)
18390 
      oprot.writeFieldEnd()
18391 
    oprot.writeFieldStop()
18392 
    oprot.writeStructEnd()
18393 
 
18394 
  def validate(self):
18395 
    return
18396 
 
18397 
 
18398 
  def __repr__(self):
18399 
    L = ['%s=%r' % (key, value)
18400 
      for key, value in self.__dict__.iteritems()]
18401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18402 
 
18403 
  def __eq__(self, other):
18404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18405 
 
18406 
  def __ne__(self, other):
18407 
    return not (self == other)
18408 
 
18409 
class getInsurer_args:
18410 
  """
18411 
  Attributes:
18412 
   - insurerId
18413 
  """
18414 
 
18415 
  thrift_spec = (
18416 
    None, # 0
18417 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18418 
  )
18419 
 
18420 
  def __init__(self, insurerId=None,):
18421 
    self.insurerId = insurerId
18422 
 
18423 
  def read(self, iprot):
18424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18426 
      return
18427 
    iprot.readStructBegin()
18428 
    while True:
18429 
      (fname, ftype, fid) = iprot.readFieldBegin()
18430 
      if ftype == TType.STOP:
18431 
        break
18432 
      if fid == 1:
18433 
        if ftype == TType.I64:
18434 
          self.insurerId = iprot.readI64();
18435 
        else:
18436 
          iprot.skip(ftype)
18437 
      else:
18438 
        iprot.skip(ftype)
18439 
      iprot.readFieldEnd()
18440 
    iprot.readStructEnd()
18441 
 
18442 
  def write(self, oprot):
18443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18445 
      return
18446 
    oprot.writeStructBegin('getInsurer_args')
18447 
    if self.insurerId is not None:
18448 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18449 
      oprot.writeI64(self.insurerId)
18450 
      oprot.writeFieldEnd()
18451 
    oprot.writeFieldStop()
18452 
    oprot.writeStructEnd()
18453 
 
18454 
  def validate(self):
18455 
    return
18456 
 
18457 
 
18458 
  def __repr__(self):
18459 
    L = ['%s=%r' % (key, value)
18460 
      for key, value in self.__dict__.iteritems()]
18461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18462 
 
18463 
  def __eq__(self, other):
18464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18465 
 
18466 
  def __ne__(self, other):
18467 
    return not (self == other)
18468 
 
18469 
class getInsurer_result:
18470 
  """
18471 
  Attributes:
18472 
   - success
18473 
  """
18474 
 
18475 
  thrift_spec = (
18476 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
18477 
  )
18478 
 
18479 
  def __init__(self, success=None,):
18480 
    self.success = success
18481 
 
18482 
  def read(self, iprot):
18483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18485 
      return
18486 
    iprot.readStructBegin()
18487 
    while True:
18488 
      (fname, ftype, fid) = iprot.readFieldBegin()
18489 
      if ftype == TType.STOP:
18490 
        break
18491 
      if fid == 0:
18492 
        if ftype == TType.STRUCT:
18493 
          self.success = Insurer()
18494 
          self.success.read(iprot)
18495 
        else:
18496 
          iprot.skip(ftype)
18497 
      else:
18498 
        iprot.skip(ftype)
18499 
      iprot.readFieldEnd()
18500 
    iprot.readStructEnd()
18501 
 
18502 
  def write(self, oprot):
18503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18505 
      return
18506 
    oprot.writeStructBegin('getInsurer_result')
18507 
    if self.success is not None:
18508 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18509 
      self.success.write(oprot)
18510 
      oprot.writeFieldEnd()
18511 
    oprot.writeFieldStop()
18512 
    oprot.writeStructEnd()
18513 
 
18514 
  def validate(self):
18515 
    return
18516 
 
18517 
 
18518 
  def __repr__(self):
18519 
    L = ['%s=%r' % (key, value)
18520 
      for key, value in self.__dict__.iteritems()]
18521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18522 
 
18523 
  def __eq__(self, other):
18524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18525 
 
18526 
  def __ne__(self, other):
18527 
    return not (self == other)
6838 vikram.rag 18528 
 
18529 
class getAllInsurers_args:
18530 
 
18531 
  thrift_spec = (
18532 
  )
18533 
 
18534 
  def read(self, iprot):
18535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18537 
      return
18538 
    iprot.readStructBegin()
18539 
    while True:
18540 
      (fname, ftype, fid) = iprot.readFieldBegin()
18541 
      if ftype == TType.STOP:
18542 
        break
18543 
      else:
18544 
        iprot.skip(ftype)
18545 
      iprot.readFieldEnd()
18546 
    iprot.readStructEnd()
18547 
 
18548 
  def write(self, oprot):
18549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18551 
      return
18552 
    oprot.writeStructBegin('getAllInsurers_args')
18553 
    oprot.writeFieldStop()
18554 
    oprot.writeStructEnd()
18555 
 
18556 
  def validate(self):
18557 
    return
18558 
 
18559 
 
18560 
  def __repr__(self):
18561 
    L = ['%s=%r' % (key, value)
18562 
      for key, value in self.__dict__.iteritems()]
18563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18564 
 
18565 
  def __eq__(self, other):
18566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18567 
 
18568 
  def __ne__(self, other):
18569 
    return not (self == other)
18570 
 
18571 
class getAllInsurers_result:
18572 
  """
18573 
  Attributes:
18574 
   - success
18575 
  """
18576 
 
18577 
  thrift_spec = (
18578 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
18579 
  )
18580 
 
18581 
  def __init__(self, success=None,):
18582 
    self.success = success
18583 
 
18584 
  def read(self, iprot):
18585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18587 
      return
18588 
    iprot.readStructBegin()
18589 
    while True:
18590 
      (fname, ftype, fid) = iprot.readFieldBegin()
18591 
      if ftype == TType.STOP:
18592 
        break
18593 
      if fid == 0:
18594 
        if ftype == TType.LIST:
18595 
          self.success = []
9155 kshitij.so 18596 
          (_etype384, _size381) = iprot.readListBegin()
18597 
          for _i385 in xrange(_size381):
18598 
            _elem386 = Insurer()
18599 
            _elem386.read(iprot)
18600 
            self.success.append(_elem386)
6838 vikram.rag 18601 
          iprot.readListEnd()
18602 
        else:
18603 
          iprot.skip(ftype)
18604 
      else:
18605 
        iprot.skip(ftype)
18606 
      iprot.readFieldEnd()
18607 
    iprot.readStructEnd()
18608 
 
18609 
  def write(self, oprot):
18610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18612 
      return
18613 
    oprot.writeStructBegin('getAllInsurers_result')
18614 
    if self.success is not None:
18615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 18617 
      for iter387 in self.success:
18618 
        iter387.write(oprot)
6838 vikram.rag 18619 
      oprot.writeListEnd()
18620 
      oprot.writeFieldEnd()
18621 
    oprot.writeFieldStop()
18622 
    oprot.writeStructEnd()
18623 
 
18624 
  def validate(self):
18625 
    return
18626 
 
18627 
 
18628 
  def __repr__(self):
18629 
    L = ['%s=%r' % (key, value)
18630 
      for key, value in self.__dict__.iteritems()]
18631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18632 
 
18633 
  def __eq__(self, other):
18634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18635 
 
18636 
  def __ne__(self, other):
18637 
    return not (self == other)
6962 rajveer 18638 
 
18639 
class updateInsuranceDeclaredAmount_args:
18640 
  """
18641 
  Attributes:
18642 
   - insurerId
18643 
   - amount
18644 
  """
18645 
 
18646 
  thrift_spec = (
18647 
    None, # 0
18648 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18649 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
18650 
  )
18651 
 
18652 
  def __init__(self, insurerId=None, amount=None,):
18653 
    self.insurerId = insurerId
18654 
    self.amount = amount
18655 
 
18656 
  def read(self, iprot):
18657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18659 
      return
18660 
    iprot.readStructBegin()
18661 
    while True:
18662 
      (fname, ftype, fid) = iprot.readFieldBegin()
18663 
      if ftype == TType.STOP:
18664 
        break
18665 
      if fid == 1:
18666 
        if ftype == TType.I64:
18667 
          self.insurerId = iprot.readI64();
18668 
        else:
18669 
          iprot.skip(ftype)
18670 
      elif fid == 2:
18671 
        if ftype == TType.DOUBLE:
18672 
          self.amount = iprot.readDouble();
18673 
        else:
18674 
          iprot.skip(ftype)
18675 
      else:
18676 
        iprot.skip(ftype)
18677 
      iprot.readFieldEnd()
18678 
    iprot.readStructEnd()
18679 
 
18680 
  def write(self, oprot):
18681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18683 
      return
18684 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
18685 
    if self.insurerId is not None:
18686 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18687 
      oprot.writeI64(self.insurerId)
18688 
      oprot.writeFieldEnd()
18689 
    if self.amount is not None:
18690 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
18691 
      oprot.writeDouble(self.amount)
18692 
      oprot.writeFieldEnd()
18693 
    oprot.writeFieldStop()
18694 
    oprot.writeStructEnd()
18695 
 
18696 
  def validate(self):
18697 
    return
18698 
 
18699 
 
18700 
  def __repr__(self):
18701 
    L = ['%s=%r' % (key, value)
18702 
      for key, value in self.__dict__.iteritems()]
18703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18704 
 
18705 
  def __eq__(self, other):
18706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18707 
 
18708 
  def __ne__(self, other):
18709 
    return not (self == other)
18710 
 
18711 
class updateInsuranceDeclaredAmount_result:
18712 
 
18713 
  thrift_spec = (
18714 
  )
18715 
 
18716 
  def read(self, iprot):
18717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18719 
      return
18720 
    iprot.readStructBegin()
18721 
    while True:
18722 
      (fname, ftype, fid) = iprot.readFieldBegin()
18723 
      if ftype == TType.STOP:
18724 
        break
18725 
      else:
18726 
        iprot.skip(ftype)
18727 
      iprot.readFieldEnd()
18728 
    iprot.readStructEnd()
18729 
 
18730 
  def write(self, oprot):
18731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18733 
      return
18734 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
18735 
    oprot.writeFieldStop()
18736 
    oprot.writeStructEnd()
18737 
 
18738 
  def validate(self):
18739 
    return
18740 
 
18741 
 
18742 
  def __repr__(self):
18743 
    L = ['%s=%r' % (key, value)
18744 
      for key, value in self.__dict__.iteritems()]
18745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18746 
 
18747 
  def __eq__(self, other):
18748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18749 
 
18750 
  def __ne__(self, other):
18751 
    return not (self == other)
7190 amar.kumar 18752 
 
18753 
class getFreebieForItem_args:
18754 
  """
18755 
  Attributes:
18756 
   - itemId
18757 
  """
18758 
 
18759 
  thrift_spec = (
18760 
    None, # 0
18761 
    (1, TType.I64, 'itemId', None, None, ), # 1
18762 
  )
18763 
 
18764 
  def __init__(self, itemId=None,):
18765 
    self.itemId = itemId
18766 
 
18767 
  def read(self, iprot):
18768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18770 
      return
18771 
    iprot.readStructBegin()
18772 
    while True:
18773 
      (fname, ftype, fid) = iprot.readFieldBegin()
18774 
      if ftype == TType.STOP:
18775 
        break
18776 
      if fid == 1:
18777 
        if ftype == TType.I64:
18778 
          self.itemId = iprot.readI64();
18779 
        else:
18780 
          iprot.skip(ftype)
18781 
      else:
18782 
        iprot.skip(ftype)
18783 
      iprot.readFieldEnd()
18784 
    iprot.readStructEnd()
18785 
 
18786 
  def write(self, oprot):
18787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18789 
      return
18790 
    oprot.writeStructBegin('getFreebieForItem_args')
18791 
    if self.itemId is not None:
18792 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18793 
      oprot.writeI64(self.itemId)
18794 
      oprot.writeFieldEnd()
18795 
    oprot.writeFieldStop()
18796 
    oprot.writeStructEnd()
18797 
 
18798 
  def validate(self):
18799 
    return
18800 
 
18801 
 
18802 
  def __repr__(self):
18803 
    L = ['%s=%r' % (key, value)
18804 
      for key, value in self.__dict__.iteritems()]
18805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18806 
 
18807 
  def __eq__(self, other):
18808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18809 
 
18810 
  def __ne__(self, other):
18811 
    return not (self == other)
18812 
 
18813 
class getFreebieForItem_result:
18814 
  """
18815 
  Attributes:
18816 
   - success
18817 
  """
18818 
 
18819 
  thrift_spec = (
18820 
    (0, TType.I64, 'success', None, None, ), # 0
18821 
  )
18822 
 
18823 
  def __init__(self, success=None,):
18824 
    self.success = success
18825 
 
18826 
  def read(self, iprot):
18827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18829 
      return
18830 
    iprot.readStructBegin()
18831 
    while True:
18832 
      (fname, ftype, fid) = iprot.readFieldBegin()
18833 
      if ftype == TType.STOP:
18834 
        break
18835 
      if fid == 0:
18836 
        if ftype == TType.I64:
18837 
          self.success = iprot.readI64();
18838 
        else:
18839 
          iprot.skip(ftype)
18840 
      else:
18841 
        iprot.skip(ftype)
18842 
      iprot.readFieldEnd()
18843 
    iprot.readStructEnd()
18844 
 
18845 
  def write(self, oprot):
18846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18848 
      return
18849 
    oprot.writeStructBegin('getFreebieForItem_result')
18850 
    if self.success is not None:
18851 
      oprot.writeFieldBegin('success', TType.I64, 0)
18852 
      oprot.writeI64(self.success)
18853 
      oprot.writeFieldEnd()
18854 
    oprot.writeFieldStop()
18855 
    oprot.writeStructEnd()
18856 
 
18857 
  def validate(self):
18858 
    return
18859 
 
18860 
 
18861 
  def __repr__(self):
18862 
    L = ['%s=%r' % (key, value)
18863 
      for key, value in self.__dict__.iteritems()]
18864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18865 
 
18866 
  def __eq__(self, other):
18867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18868 
 
18869 
  def __ne__(self, other):
18870 
    return not (self == other)
18871 
 
18872 
class addOrUpdateFreebieForItem_args:
18873 
  """
18874 
  Attributes:
18875 
   - freebieItem
18876 
  """
18877 
 
18878 
  thrift_spec = (
18879 
    None, # 0
18880 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18881 
  )
18882 
 
18883 
  def __init__(self, freebieItem=None,):
18884 
    self.freebieItem = freebieItem
18885 
 
18886 
  def read(self, iprot):
18887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18889 
      return
18890 
    iprot.readStructBegin()
18891 
    while True:
18892 
      (fname, ftype, fid) = iprot.readFieldBegin()
18893 
      if ftype == TType.STOP:
18894 
        break
18895 
      if fid == 1:
18896 
        if ftype == TType.STRUCT:
18897 
          self.freebieItem = FreebieItem()
18898 
          self.freebieItem.read(iprot)
18899 
        else:
18900 
          iprot.skip(ftype)
18901 
      else:
18902 
        iprot.skip(ftype)
18903 
      iprot.readFieldEnd()
18904 
    iprot.readStructEnd()
18905 
 
18906 
  def write(self, oprot):
18907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18909 
      return
18910 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18911 
    if self.freebieItem is not None:
18912 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18913 
      self.freebieItem.write(oprot)
18914 
      oprot.writeFieldEnd()
18915 
    oprot.writeFieldStop()
18916 
    oprot.writeStructEnd()
18917 
 
18918 
  def validate(self):
18919 
    return
18920 
 
18921 
 
18922 
  def __repr__(self):
18923 
    L = ['%s=%r' % (key, value)
18924 
      for key, value in self.__dict__.iteritems()]
18925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18926 
 
18927 
  def __eq__(self, other):
18928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18929 
 
18930 
  def __ne__(self, other):
18931 
    return not (self == other)
18932 
 
18933 
class addOrUpdateFreebieForItem_result:
18934 
 
18935 
  thrift_spec = (
18936 
  )
18937 
 
18938 
  def read(self, iprot):
18939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18941 
      return
18942 
    iprot.readStructBegin()
18943 
    while True:
18944 
      (fname, ftype, fid) = iprot.readFieldBegin()
18945 
      if ftype == TType.STOP:
18946 
        break
18947 
      else:
18948 
        iprot.skip(ftype)
18949 
      iprot.readFieldEnd()
18950 
    iprot.readStructEnd()
18951 
 
18952 
  def write(self, oprot):
18953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18955 
      return
18956 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18957 
    oprot.writeFieldStop()
18958 
    oprot.writeStructEnd()
18959 
 
18960 
  def validate(self):
18961 
    return
18962 
 
18963 
 
18964 
  def __repr__(self):
18965 
    L = ['%s=%r' % (key, value)
18966 
      for key, value in self.__dict__.iteritems()]
18967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18968 
 
18969 
  def __eq__(self, other):
18970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18971 
 
18972 
  def __ne__(self, other):
18973 
    return not (self == other)
7256 rajveer 18974 
 
7272 amit.gupta 18975 
class addOrUpdateBrandInfo_args:
18976 
  """
18977 
  Attributes:
18978 
   - brandInfo
18979 
  """
18980 
 
18981 
  thrift_spec = (
18982 
    None, # 0
18983 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18984 
  )
18985 
 
18986 
  def __init__(self, brandInfo=None,):
18987 
    self.brandInfo = brandInfo
18988 
 
18989 
  def read(self, iprot):
18990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18992 
      return
18993 
    iprot.readStructBegin()
18994 
    while True:
18995 
      (fname, ftype, fid) = iprot.readFieldBegin()
18996 
      if ftype == TType.STOP:
18997 
        break
18998 
      if fid == 1:
18999 
        if ftype == TType.STRUCT:
19000 
          self.brandInfo = BrandInfo()
19001 
          self.brandInfo.read(iprot)
19002 
        else:
19003 
          iprot.skip(ftype)
19004 
      else:
19005 
        iprot.skip(ftype)
19006 
      iprot.readFieldEnd()
19007 
    iprot.readStructEnd()
19008 
 
19009 
  def write(self, oprot):
19010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19012 
      return
19013 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
19014 
    if self.brandInfo is not None:
19015 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
19016 
      self.brandInfo.write(oprot)
19017 
      oprot.writeFieldEnd()
19018 
    oprot.writeFieldStop()
19019 
    oprot.writeStructEnd()
19020 
 
19021 
  def validate(self):
19022 
    return
19023 
 
19024 
 
19025 
  def __repr__(self):
19026 
    L = ['%s=%r' % (key, value)
19027 
      for key, value in self.__dict__.iteritems()]
19028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19029 
 
19030 
  def __eq__(self, other):
19031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19032 
 
19033 
  def __ne__(self, other):
19034 
    return not (self == other)
19035 
 
19036 
class addOrUpdateBrandInfo_result:
19037 
 
19038 
  thrift_spec = (
19039 
  )
19040 
 
19041 
  def read(self, iprot):
19042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19044 
      return
19045 
    iprot.readStructBegin()
19046 
    while True:
19047 
      (fname, ftype, fid) = iprot.readFieldBegin()
19048 
      if ftype == TType.STOP:
19049 
        break
19050 
      else:
19051 
        iprot.skip(ftype)
19052 
      iprot.readFieldEnd()
19053 
    iprot.readStructEnd()
19054 
 
19055 
  def write(self, oprot):
19056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19058 
      return
19059 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
19060 
    oprot.writeFieldStop()
19061 
    oprot.writeStructEnd()
19062 
 
19063 
  def validate(self):
19064 
    return
19065 
 
19066 
 
19067 
  def __repr__(self):
19068 
    L = ['%s=%r' % (key, value)
19069 
      for key, value in self.__dict__.iteritems()]
19070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19071 
 
19072 
  def __eq__(self, other):
19073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19074 
 
19075 
  def __ne__(self, other):
19076 
    return not (self == other)
19077 
 
19078 
class getBrandInfo_args:
19079 
 
19080 
  thrift_spec = (
19081 
  )
19082 
 
19083 
  def read(self, iprot):
19084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19086 
      return
19087 
    iprot.readStructBegin()
19088 
    while True:
19089 
      (fname, ftype, fid) = iprot.readFieldBegin()
19090 
      if ftype == TType.STOP:
19091 
        break
19092 
      else:
19093 
        iprot.skip(ftype)
19094 
      iprot.readFieldEnd()
19095 
    iprot.readStructEnd()
19096 
 
19097 
  def write(self, oprot):
19098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19100 
      return
19101 
    oprot.writeStructBegin('getBrandInfo_args')
19102 
    oprot.writeFieldStop()
19103 
    oprot.writeStructEnd()
19104 
 
19105 
  def validate(self):
19106 
    return
19107 
 
19108 
 
19109 
  def __repr__(self):
19110 
    L = ['%s=%r' % (key, value)
19111 
      for key, value in self.__dict__.iteritems()]
19112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19113 
 
19114 
  def __eq__(self, other):
19115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19116 
 
19117 
  def __ne__(self, other):
19118 
    return not (self == other)
19119 
 
19120 
class getBrandInfo_result:
19121 
  """
19122 
  Attributes:
19123 
   - success
19124 
  """
19125 
 
19126 
  thrift_spec = (
19127 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
19128 
  )
19129 
 
19130 
  def __init__(self, success=None,):
19131 
    self.success = success
19132 
 
19133 
  def read(self, iprot):
19134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19136 
      return
19137 
    iprot.readStructBegin()
19138 
    while True:
19139 
      (fname, ftype, fid) = iprot.readFieldBegin()
19140 
      if ftype == TType.STOP:
19141 
        break
19142 
      if fid == 0:
19143 
        if ftype == TType.MAP:
19144 
          self.success = {}
9155 kshitij.so 19145 
          (_ktype389, _vtype390, _size388 ) = iprot.readMapBegin()
19146 
          for _i392 in xrange(_size388):
19147 
            _key393 = iprot.readString();
19148 
            _val394 = BrandInfo()
19149 
            _val394.read(iprot)
19150 
            self.success[_key393] = _val394
7272 amit.gupta 19151 
          iprot.readMapEnd()
19152 
        else:
19153 
          iprot.skip(ftype)
19154 
      else:
19155 
        iprot.skip(ftype)
19156 
      iprot.readFieldEnd()
19157 
    iprot.readStructEnd()
19158 
 
19159 
  def write(self, oprot):
19160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19162 
      return
19163 
    oprot.writeStructBegin('getBrandInfo_result')
19164 
    if self.success is not None:
19165 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19166 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
9155 kshitij.so 19167 
      for kiter395,viter396 in self.success.items():
19168 
        oprot.writeString(kiter395)
19169 
        viter396.write(oprot)
7272 amit.gupta 19170 
      oprot.writeMapEnd()
19171 
      oprot.writeFieldEnd()
19172 
    oprot.writeFieldStop()
19173 
    oprot.writeStructEnd()
19174 
 
19175 
  def validate(self):
19176 
    return
19177 
 
19178 
 
19179 
  def __repr__(self):
19180 
    L = ['%s=%r' % (key, value)
19181 
      for key, value in self.__dict__.iteritems()]
19182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19183 
 
19184 
  def __eq__(self, other):
19185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19186 
 
19187 
  def __ne__(self, other):
19188 
    return not (self == other)
19189 
 
7256 rajveer 19190 
class getStorePricing_args:
19191 
  """
19192 
  Attributes:
19193 
   - itemId
19194 
  """
19195 
 
19196 
  thrift_spec = (
19197 
    None, # 0
19198 
    (1, TType.I64, 'itemId', None, None, ), # 1
19199 
  )
19200 
 
19201 
  def __init__(self, itemId=None,):
19202 
    self.itemId = itemId
19203 
 
19204 
  def read(self, iprot):
19205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19207 
      return
19208 
    iprot.readStructBegin()
19209 
    while True:
19210 
      (fname, ftype, fid) = iprot.readFieldBegin()
19211 
      if ftype == TType.STOP:
19212 
        break
19213 
      if fid == 1:
19214 
        if ftype == TType.I64:
19215 
          self.itemId = iprot.readI64();
19216 
        else:
19217 
          iprot.skip(ftype)
19218 
      else:
19219 
        iprot.skip(ftype)
19220 
      iprot.readFieldEnd()
19221 
    iprot.readStructEnd()
19222 
 
19223 
  def write(self, oprot):
19224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19226 
      return
19227 
    oprot.writeStructBegin('getStorePricing_args')
19228 
    if self.itemId is not None:
19229 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19230 
      oprot.writeI64(self.itemId)
19231 
      oprot.writeFieldEnd()
19232 
    oprot.writeFieldStop()
19233 
    oprot.writeStructEnd()
19234 
 
19235 
  def validate(self):
19236 
    return
19237 
 
19238 
 
19239 
  def __repr__(self):
19240 
    L = ['%s=%r' % (key, value)
19241 
      for key, value in self.__dict__.iteritems()]
19242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19243 
 
19244 
  def __eq__(self, other):
19245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19246 
 
19247 
  def __ne__(self, other):
19248 
    return not (self == other)
19249 
 
19250 
class getStorePricing_result:
19251 
  """
19252 
  Attributes:
19253 
   - success
19254 
  """
19255 
 
19256 
  thrift_spec = (
19257 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
19258 
  )
19259 
 
19260 
  def __init__(self, success=None,):
19261 
    self.success = success
19262 
 
19263 
  def read(self, iprot):
19264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19266 
      return
19267 
    iprot.readStructBegin()
19268 
    while True:
19269 
      (fname, ftype, fid) = iprot.readFieldBegin()
19270 
      if ftype == TType.STOP:
19271 
        break
19272 
      if fid == 0:
19273 
        if ftype == TType.STRUCT:
19274 
          self.success = StorePricing()
19275 
          self.success.read(iprot)
19276 
        else:
19277 
          iprot.skip(ftype)
19278 
      else:
19279 
        iprot.skip(ftype)
19280 
      iprot.readFieldEnd()
19281 
    iprot.readStructEnd()
19282 
 
19283 
  def write(self, oprot):
19284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19286 
      return
19287 
    oprot.writeStructBegin('getStorePricing_result')
19288 
    if self.success is not None:
19289 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19290 
      self.success.write(oprot)
19291 
      oprot.writeFieldEnd()
19292 
    oprot.writeFieldStop()
19293 
    oprot.writeStructEnd()
19294 
 
19295 
  def validate(self):
19296 
    return
19297 
 
19298 
 
19299 
  def __repr__(self):
19300 
    L = ['%s=%r' % (key, value)
19301 
      for key, value in self.__dict__.iteritems()]
19302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19303 
 
19304 
  def __eq__(self, other):
19305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19306 
 
19307 
  def __ne__(self, other):
19308 
    return not (self == other)
7265 rajveer 19309 
 
7306 rajveer 19310 
class getStorePricings_args:
19311 
  """
19312 
  Attributes:
19313 
   - itemIds
19314 
  """
19315 
 
19316 
  thrift_spec = (
19317 
    None, # 0
19318 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19319 
  )
19320 
 
19321 
  def __init__(self, itemIds=None,):
19322 
    self.itemIds = itemIds
19323 
 
19324 
  def read(self, iprot):
19325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19327 
      return
19328 
    iprot.readStructBegin()
19329 
    while True:
19330 
      (fname, ftype, fid) = iprot.readFieldBegin()
19331 
      if ftype == TType.STOP:
19332 
        break
19333 
      if fid == 1:
19334 
        if ftype == TType.LIST:
19335 
          self.itemIds = []
9155 kshitij.so 19336 
          (_etype400, _size397) = iprot.readListBegin()
19337 
          for _i401 in xrange(_size397):
19338 
            _elem402 = iprot.readI64();
19339 
            self.itemIds.append(_elem402)
7306 rajveer 19340 
          iprot.readListEnd()
19341 
        else:
19342 
          iprot.skip(ftype)
19343 
      else:
19344 
        iprot.skip(ftype)
19345 
      iprot.readFieldEnd()
19346 
    iprot.readStructEnd()
19347 
 
19348 
  def write(self, oprot):
19349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19351 
      return
19352 
    oprot.writeStructBegin('getStorePricings_args')
19353 
    if self.itemIds is not None:
19354 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19355 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
9155 kshitij.so 19356 
      for iter403 in self.itemIds:
19357 
        oprot.writeI64(iter403)
7306 rajveer 19358 
      oprot.writeListEnd()
19359 
      oprot.writeFieldEnd()
19360 
    oprot.writeFieldStop()
19361 
    oprot.writeStructEnd()
19362 
 
19363 
  def validate(self):
19364 
    return
19365 
 
19366 
 
19367 
  def __repr__(self):
19368 
    L = ['%s=%r' % (key, value)
19369 
      for key, value in self.__dict__.iteritems()]
19370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19371 
 
19372 
  def __eq__(self, other):
19373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19374 
 
19375 
  def __ne__(self, other):
19376 
    return not (self == other)
19377 
 
19378 
class getStorePricings_result:
19379 
  """
19380 
  Attributes:
19381 
   - success
19382 
  """
19383 
 
19384 
  thrift_spec = (
19385 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
19386 
  )
19387 
 
19388 
  def __init__(self, success=None,):
19389 
    self.success = success
19390 
 
19391 
  def read(self, iprot):
19392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19394 
      return
19395 
    iprot.readStructBegin()
19396 
    while True:
19397 
      (fname, ftype, fid) = iprot.readFieldBegin()
19398 
      if ftype == TType.STOP:
19399 
        break
19400 
      if fid == 0:
19401 
        if ftype == TType.LIST:
19402 
          self.success = []
9155 kshitij.so 19403 
          (_etype407, _size404) = iprot.readListBegin()
19404 
          for _i408 in xrange(_size404):
19405 
            _elem409 = StorePricing()
19406 
            _elem409.read(iprot)
19407 
            self.success.append(_elem409)
7306 rajveer 19408 
          iprot.readListEnd()
19409 
        else:
19410 
          iprot.skip(ftype)
19411 
      else:
19412 
        iprot.skip(ftype)
19413 
      iprot.readFieldEnd()
19414 
    iprot.readStructEnd()
19415 
 
19416 
  def write(self, oprot):
19417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19419 
      return
19420 
    oprot.writeStructBegin('getStorePricings_result')
19421 
    if self.success is not None:
19422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19423 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19424 
      for iter410 in self.success:
19425 
        iter410.write(oprot)
7306 rajveer 19426 
      oprot.writeListEnd()
19427 
      oprot.writeFieldEnd()
19428 
    oprot.writeFieldStop()
19429 
    oprot.writeStructEnd()
19430 
 
19431 
  def validate(self):
19432 
    return
19433 
 
19434 
 
19435 
  def __repr__(self):
19436 
    L = ['%s=%r' % (key, value)
19437 
      for key, value in self.__dict__.iteritems()]
19438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19439 
 
19440 
  def __eq__(self, other):
19441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19442 
 
19443 
  def __ne__(self, other):
19444 
    return not (self == other)
19445 
 
7265 rajveer 19446 
class updateStorePricing_args:
19447 
  """
19448 
  Attributes:
19449 
   - sp
7382 rajveer 19450 
   - allColors
7265 rajveer 19451 
  """
19452 
 
19453 
  thrift_spec = (
19454 
    None, # 0
19455 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 19456 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 19457 
  )
19458 
 
7382 rajveer 19459 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 19460 
    self.sp = sp
7382 rajveer 19461 
    self.allColors = allColors
7265 rajveer 19462 
 
19463 
  def read(self, iprot):
19464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19466 
      return
19467 
    iprot.readStructBegin()
19468 
    while True:
19469 
      (fname, ftype, fid) = iprot.readFieldBegin()
19470 
      if ftype == TType.STOP:
19471 
        break
19472 
      if fid == 1:
19473 
        if ftype == TType.STRUCT:
19474 
          self.sp = StorePricing()
19475 
          self.sp.read(iprot)
19476 
        else:
19477 
          iprot.skip(ftype)
7382 rajveer 19478 
      elif fid == 2:
19479 
        if ftype == TType.BOOL:
19480 
          self.allColors = iprot.readBool();
19481 
        else:
19482 
          iprot.skip(ftype)
7265 rajveer 19483 
      else:
19484 
        iprot.skip(ftype)
19485 
      iprot.readFieldEnd()
19486 
    iprot.readStructEnd()
19487 
 
19488 
  def write(self, oprot):
19489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19491 
      return
19492 
    oprot.writeStructBegin('updateStorePricing_args')
19493 
    if self.sp is not None:
19494 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
19495 
      self.sp.write(oprot)
19496 
      oprot.writeFieldEnd()
7382 rajveer 19497 
    if self.allColors is not None:
19498 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
19499 
      oprot.writeBool(self.allColors)
19500 
      oprot.writeFieldEnd()
7265 rajveer 19501 
    oprot.writeFieldStop()
19502 
    oprot.writeStructEnd()
19503 
 
19504 
  def validate(self):
19505 
    return
19506 
 
19507 
 
19508 
  def __repr__(self):
19509 
    L = ['%s=%r' % (key, value)
19510 
      for key, value in self.__dict__.iteritems()]
19511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19512 
 
19513 
  def __eq__(self, other):
19514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19515 
 
19516 
  def __ne__(self, other):
19517 
    return not (self == other)
19518 
 
19519 
class updateStorePricing_result:
19520 
 
19521 
  thrift_spec = (
19522 
  )
19523 
 
19524 
  def read(self, iprot):
19525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19527 
      return
19528 
    iprot.readStructBegin()
19529 
    while True:
19530 
      (fname, ftype, fid) = iprot.readFieldBegin()
19531 
      if ftype == TType.STOP:
19532 
        break
19533 
      else:
19534 
        iprot.skip(ftype)
19535 
      iprot.readFieldEnd()
19536 
    iprot.readStructEnd()
19537 
 
19538 
  def write(self, oprot):
19539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19541 
      return
19542 
    oprot.writeStructBegin('updateStorePricing_result')
19543 
    oprot.writeFieldStop()
19544 
    oprot.writeStructEnd()
19545 
 
19546 
  def validate(self):
19547 
    return
19548 
 
19549 
 
19550 
  def __repr__(self):
19551 
    L = ['%s=%r' % (key, value)
19552 
      for key, value in self.__dict__.iteritems()]
19553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19554 
 
19555 
  def __eq__(self, other):
19556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19557 
 
19558 
  def __ne__(self, other):
19559 
    return not (self == other)
7281 kshitij.so 19560 
 
19561 
class getAllAmazonListedItems_args:
19562 
 
19563 
  thrift_spec = (
19564 
  )
19565 
 
19566 
  def read(self, iprot):
19567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19569 
      return
19570 
    iprot.readStructBegin()
19571 
    while True:
19572 
      (fname, ftype, fid) = iprot.readFieldBegin()
19573 
      if ftype == TType.STOP:
19574 
        break
19575 
      else:
19576 
        iprot.skip(ftype)
19577 
      iprot.readFieldEnd()
19578 
    iprot.readStructEnd()
19579 
 
19580 
  def write(self, oprot):
19581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19583 
      return
19584 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
19585 
    oprot.writeFieldStop()
19586 
    oprot.writeStructEnd()
19587 
 
19588 
  def validate(self):
19589 
    return
19590 
 
19591 
 
19592 
  def __repr__(self):
19593 
    L = ['%s=%r' % (key, value)
19594 
      for key, value in self.__dict__.iteritems()]
19595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19596 
 
19597 
  def __eq__(self, other):
19598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19599 
 
19600 
  def __ne__(self, other):
19601 
    return not (self == other)
19602 
 
19603 
class getAllAmazonListedItems_result:
19604 
  """
19605 
  Attributes:
19606 
   - success
19607 
  """
19608 
 
19609 
  thrift_spec = (
19610 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19611 
  )
19612 
 
19613 
  def __init__(self, success=None,):
19614 
    self.success = success
19615 
 
19616 
  def read(self, iprot):
19617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19619 
      return
19620 
    iprot.readStructBegin()
19621 
    while True:
19622 
      (fname, ftype, fid) = iprot.readFieldBegin()
19623 
      if ftype == TType.STOP:
19624 
        break
19625 
      if fid == 0:
19626 
        if ftype == TType.LIST:
19627 
          self.success = []
9155 kshitij.so 19628 
          (_etype414, _size411) = iprot.readListBegin()
19629 
          for _i415 in xrange(_size411):
19630 
            _elem416 = Amazonlisted()
19631 
            _elem416.read(iprot)
19632 
            self.success.append(_elem416)
7281 kshitij.so 19633 
          iprot.readListEnd()
19634 
        else:
19635 
          iprot.skip(ftype)
19636 
      else:
19637 
        iprot.skip(ftype)
19638 
      iprot.readFieldEnd()
19639 
    iprot.readStructEnd()
19640 
 
19641 
  def write(self, oprot):
19642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19644 
      return
19645 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
19646 
    if self.success is not None:
19647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19649 
      for iter417 in self.success:
19650 
        iter417.write(oprot)
7281 kshitij.so 19651 
      oprot.writeListEnd()
19652 
      oprot.writeFieldEnd()
19653 
    oprot.writeFieldStop()
19654 
    oprot.writeStructEnd()
19655 
 
19656 
  def validate(self):
19657 
    return
19658 
 
19659 
 
19660 
  def __repr__(self):
19661 
    L = ['%s=%r' % (key, value)
19662 
      for key, value in self.__dict__.iteritems()]
19663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19664 
 
19665 
  def __eq__(self, other):
19666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19667 
 
19668 
  def __ne__(self, other):
19669 
    return not (self == other)
19670 
 
8619 kshitij.so 19671 
class searchAmazonItems_args:
19672 
  """
19673 
  Attributes:
19674 
   - searchTerm
19675 
   - offset
19676 
   - limit
19677 
  """
19678 
 
19679 
  thrift_spec = (
19680 
    None, # 0
19681 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19682 
    (2, TType.I64, 'offset', None, None, ), # 2
19683 
    (3, TType.I64, 'limit', None, None, ), # 3
19684 
  )
19685 
 
19686 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
19687 
    self.searchTerm = searchTerm
19688 
    self.offset = offset
19689 
    self.limit = limit
19690 
 
19691 
  def read(self, iprot):
19692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19694 
      return
19695 
    iprot.readStructBegin()
19696 
    while True:
19697 
      (fname, ftype, fid) = iprot.readFieldBegin()
19698 
      if ftype == TType.STOP:
19699 
        break
19700 
      if fid == 1:
19701 
        if ftype == TType.LIST:
19702 
          self.searchTerm = []
9155 kshitij.so 19703 
          (_etype421, _size418) = iprot.readListBegin()
19704 
          for _i422 in xrange(_size418):
19705 
            _elem423 = iprot.readString();
19706 
            self.searchTerm.append(_elem423)
8619 kshitij.so 19707 
          iprot.readListEnd()
19708 
        else:
19709 
          iprot.skip(ftype)
19710 
      elif fid == 2:
19711 
        if ftype == TType.I64:
19712 
          self.offset = iprot.readI64();
19713 
        else:
19714 
          iprot.skip(ftype)
19715 
      elif fid == 3:
19716 
        if ftype == TType.I64:
19717 
          self.limit = iprot.readI64();
19718 
        else:
19719 
          iprot.skip(ftype)
19720 
      else:
19721 
        iprot.skip(ftype)
19722 
      iprot.readFieldEnd()
19723 
    iprot.readStructEnd()
19724 
 
19725 
  def write(self, oprot):
19726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19728 
      return
19729 
    oprot.writeStructBegin('searchAmazonItems_args')
19730 
    if self.searchTerm is not None:
19731 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19732 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19733 
      for iter424 in self.searchTerm:
19734 
        oprot.writeString(iter424)
8619 kshitij.so 19735 
      oprot.writeListEnd()
19736 
      oprot.writeFieldEnd()
19737 
    if self.offset is not None:
19738 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19739 
      oprot.writeI64(self.offset)
19740 
      oprot.writeFieldEnd()
19741 
    if self.limit is not None:
19742 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19743 
      oprot.writeI64(self.limit)
19744 
      oprot.writeFieldEnd()
19745 
    oprot.writeFieldStop()
19746 
    oprot.writeStructEnd()
19747 
 
19748 
  def validate(self):
19749 
    return
19750 
 
19751 
 
19752 
  def __repr__(self):
19753 
    L = ['%s=%r' % (key, value)
19754 
      for key, value in self.__dict__.iteritems()]
19755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19756 
 
19757 
  def __eq__(self, other):
19758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19759 
 
19760 
  def __ne__(self, other):
19761 
    return not (self == other)
19762 
 
19763 
class searchAmazonItems_result:
19764 
  """
19765 
  Attributes:
19766 
   - success
19767 
  """
19768 
 
19769 
  thrift_spec = (
19770 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19771 
  )
19772 
 
19773 
  def __init__(self, success=None,):
19774 
    self.success = success
19775 
 
19776 
  def read(self, iprot):
19777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19779 
      return
19780 
    iprot.readStructBegin()
19781 
    while True:
19782 
      (fname, ftype, fid) = iprot.readFieldBegin()
19783 
      if ftype == TType.STOP:
19784 
        break
19785 
      if fid == 0:
19786 
        if ftype == TType.LIST:
19787 
          self.success = []
9155 kshitij.so 19788 
          (_etype428, _size425) = iprot.readListBegin()
19789 
          for _i429 in xrange(_size425):
19790 
            _elem430 = Amazonlisted()
19791 
            _elem430.read(iprot)
19792 
            self.success.append(_elem430)
8619 kshitij.so 19793 
          iprot.readListEnd()
19794 
        else:
19795 
          iprot.skip(ftype)
19796 
      else:
19797 
        iprot.skip(ftype)
19798 
      iprot.readFieldEnd()
19799 
    iprot.readStructEnd()
19800 
 
19801 
  def write(self, oprot):
19802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19804 
      return
19805 
    oprot.writeStructBegin('searchAmazonItems_result')
19806 
    if self.success is not None:
19807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19808 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 19809 
      for iter431 in self.success:
19810 
        iter431.write(oprot)
8619 kshitij.so 19811 
      oprot.writeListEnd()
19812 
      oprot.writeFieldEnd()
19813 
    oprot.writeFieldStop()
19814 
    oprot.writeStructEnd()
19815 
 
19816 
  def validate(self):
19817 
    return
19818 
 
19819 
 
19820 
  def __repr__(self):
19821 
    L = ['%s=%r' % (key, value)
19822 
      for key, value in self.__dict__.iteritems()]
19823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19824 
 
19825 
  def __eq__(self, other):
19826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19827 
 
19828 
  def __ne__(self, other):
19829 
    return not (self == other)
19830 
 
19831 
class getAmazonSearchResultCount_args:
19832 
  """
19833 
  Attributes:
19834 
   - searchTerm
19835 
  """
19836 
 
19837 
  thrift_spec = (
19838 
    None, # 0
19839 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19840 
  )
19841 
 
19842 
  def __init__(self, searchTerm=None,):
19843 
    self.searchTerm = searchTerm
19844 
 
19845 
  def read(self, iprot):
19846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19848 
      return
19849 
    iprot.readStructBegin()
19850 
    while True:
19851 
      (fname, ftype, fid) = iprot.readFieldBegin()
19852 
      if ftype == TType.STOP:
19853 
        break
19854 
      if fid == 1:
19855 
        if ftype == TType.LIST:
19856 
          self.searchTerm = []
9155 kshitij.so 19857 
          (_etype435, _size432) = iprot.readListBegin()
19858 
          for _i436 in xrange(_size432):
19859 
            _elem437 = iprot.readString();
19860 
            self.searchTerm.append(_elem437)
8619 kshitij.so 19861 
          iprot.readListEnd()
19862 
        else:
19863 
          iprot.skip(ftype)
19864 
      else:
19865 
        iprot.skip(ftype)
19866 
      iprot.readFieldEnd()
19867 
    iprot.readStructEnd()
19868 
 
19869 
  def write(self, oprot):
19870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19872 
      return
19873 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
19874 
    if self.searchTerm is not None:
19875 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19876 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
9155 kshitij.so 19877 
      for iter438 in self.searchTerm:
19878 
        oprot.writeString(iter438)
8619 kshitij.so 19879 
      oprot.writeListEnd()
19880 
      oprot.writeFieldEnd()
19881 
    oprot.writeFieldStop()
19882 
    oprot.writeStructEnd()
19883 
 
19884 
  def validate(self):
19885 
    return
19886 
 
19887 
 
19888 
  def __repr__(self):
19889 
    L = ['%s=%r' % (key, value)
19890 
      for key, value in self.__dict__.iteritems()]
19891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19892 
 
19893 
  def __eq__(self, other):
19894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19895 
 
19896 
  def __ne__(self, other):
19897 
    return not (self == other)
19898 
 
19899 
class getAmazonSearchResultCount_result:
19900 
  """
19901 
  Attributes:
19902 
   - success
19903 
  """
19904 
 
19905 
  thrift_spec = (
19906 
    (0, TType.I64, 'success', None, None, ), # 0
19907 
  )
19908 
 
19909 
  def __init__(self, success=None,):
19910 
    self.success = success
19911 
 
19912 
  def read(self, iprot):
19913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19915 
      return
19916 
    iprot.readStructBegin()
19917 
    while True:
19918 
      (fname, ftype, fid) = iprot.readFieldBegin()
19919 
      if ftype == TType.STOP:
19920 
        break
19921 
      if fid == 0:
19922 
        if ftype == TType.I64:
19923 
          self.success = iprot.readI64();
19924 
        else:
19925 
          iprot.skip(ftype)
19926 
      else:
19927 
        iprot.skip(ftype)
19928 
      iprot.readFieldEnd()
19929 
    iprot.readStructEnd()
19930 
 
19931 
  def write(self, oprot):
19932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19934 
      return
19935 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
19936 
    if self.success is not None:
19937 
      oprot.writeFieldBegin('success', TType.I64, 0)
19938 
      oprot.writeI64(self.success)
19939 
      oprot.writeFieldEnd()
19940 
    oprot.writeFieldStop()
19941 
    oprot.writeStructEnd()
19942 
 
19943 
  def validate(self):
19944 
    return
19945 
 
19946 
 
19947 
  def __repr__(self):
19948 
    L = ['%s=%r' % (key, value)
19949 
      for key, value in self.__dict__.iteritems()]
19950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19951 
 
19952 
  def __eq__(self, other):
19953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19954 
 
19955 
  def __ne__(self, other):
19956 
    return not (self == other)
19957 
 
19958 
class getCountForAmazonlistedItems_args:
19959 
 
19960 
  thrift_spec = (
19961 
  )
19962 
 
19963 
  def read(self, iprot):
19964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19966 
      return
19967 
    iprot.readStructBegin()
19968 
    while True:
19969 
      (fname, ftype, fid) = iprot.readFieldBegin()
19970 
      if ftype == TType.STOP:
19971 
        break
19972 
      else:
19973 
        iprot.skip(ftype)
19974 
      iprot.readFieldEnd()
19975 
    iprot.readStructEnd()
19976 
 
19977 
  def write(self, oprot):
19978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19980 
      return
19981 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
19982 
    oprot.writeFieldStop()
19983 
    oprot.writeStructEnd()
19984 
 
19985 
  def validate(self):
19986 
    return
19987 
 
19988 
 
19989 
  def __repr__(self):
19990 
    L = ['%s=%r' % (key, value)
19991 
      for key, value in self.__dict__.iteritems()]
19992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19993 
 
19994 
  def __eq__(self, other):
19995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19996 
 
19997 
  def __ne__(self, other):
19998 
    return not (self == other)
19999 
 
20000 
class getCountForAmazonlistedItems_result:
20001 
  """
20002 
  Attributes:
20003 
   - success
20004 
  """
20005 
 
20006 
  thrift_spec = (
20007 
    (0, TType.I64, 'success', None, None, ), # 0
20008 
  )
20009 
 
20010 
  def __init__(self, success=None,):
20011 
    self.success = success
20012 
 
20013 
  def read(self, iprot):
20014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20016 
      return
20017 
    iprot.readStructBegin()
20018 
    while True:
20019 
      (fname, ftype, fid) = iprot.readFieldBegin()
20020 
      if ftype == TType.STOP:
20021 
        break
20022 
      if fid == 0:
20023 
        if ftype == TType.I64:
20024 
          self.success = iprot.readI64();
20025 
        else:
20026 
          iprot.skip(ftype)
20027 
      else:
20028 
        iprot.skip(ftype)
20029 
      iprot.readFieldEnd()
20030 
    iprot.readStructEnd()
20031 
 
20032 
  def write(self, oprot):
20033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20035 
      return
20036 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
20037 
    if self.success is not None:
20038 
      oprot.writeFieldBegin('success', TType.I64, 0)
20039 
      oprot.writeI64(self.success)
20040 
      oprot.writeFieldEnd()
20041 
    oprot.writeFieldStop()
20042 
    oprot.writeStructEnd()
20043 
 
20044 
  def validate(self):
20045 
    return
20046 
 
20047 
 
20048 
  def __repr__(self):
20049 
    L = ['%s=%r' % (key, value)
20050 
      for key, value in self.__dict__.iteritems()]
20051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20052 
 
20053 
  def __eq__(self, other):
20054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20055 
 
20056 
  def __ne__(self, other):
20057 
    return not (self == other)
20058 
 
7281 kshitij.so 20059 
class getAmazonItemDetails_args:
20060 
  """
20061 
  Attributes:
20062 
   - itemId
20063 
  """
20064 
 
20065 
  thrift_spec = (
20066 
    None, # 0
20067 
    (1, TType.I64, 'itemId', None, None, ), # 1
20068 
  )
20069 
 
20070 
  def __init__(self, itemId=None,):
20071 
    self.itemId = itemId
20072 
 
20073 
  def read(self, iprot):
20074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20076 
      return
20077 
    iprot.readStructBegin()
20078 
    while True:
20079 
      (fname, ftype, fid) = iprot.readFieldBegin()
20080 
      if ftype == TType.STOP:
20081 
        break
20082 
      if fid == 1:
20083 
        if ftype == TType.I64:
20084 
          self.itemId = iprot.readI64();
20085 
        else:
20086 
          iprot.skip(ftype)
20087 
      else:
20088 
        iprot.skip(ftype)
20089 
      iprot.readFieldEnd()
20090 
    iprot.readStructEnd()
20091 
 
20092 
  def write(self, oprot):
20093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20095 
      return
20096 
    oprot.writeStructBegin('getAmazonItemDetails_args')
20097 
    if self.itemId is not None:
20098 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20099 
      oprot.writeI64(self.itemId)
20100 
      oprot.writeFieldEnd()
20101 
    oprot.writeFieldStop()
20102 
    oprot.writeStructEnd()
20103 
 
20104 
  def validate(self):
20105 
    return
20106 
 
20107 
 
20108 
  def __repr__(self):
20109 
    L = ['%s=%r' % (key, value)
20110 
      for key, value in self.__dict__.iteritems()]
20111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20112 
 
20113 
  def __eq__(self, other):
20114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20115 
 
20116 
  def __ne__(self, other):
20117 
    return not (self == other)
20118 
 
20119 
class getAmazonItemDetails_result:
20120 
  """
20121 
  Attributes:
20122 
   - success
20123 
  """
20124 
 
20125 
  thrift_spec = (
20126 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
20127 
  )
20128 
 
20129 
  def __init__(self, success=None,):
20130 
    self.success = success
20131 
 
20132 
  def read(self, iprot):
20133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20135 
      return
20136 
    iprot.readStructBegin()
20137 
    while True:
20138 
      (fname, ftype, fid) = iprot.readFieldBegin()
20139 
      if ftype == TType.STOP:
20140 
        break
20141 
      if fid == 0:
20142 
        if ftype == TType.STRUCT:
20143 
          self.success = Amazonlisted()
20144 
          self.success.read(iprot)
20145 
        else:
20146 
          iprot.skip(ftype)
20147 
      else:
20148 
        iprot.skip(ftype)
20149 
      iprot.readFieldEnd()
20150 
    iprot.readStructEnd()
20151 
 
20152 
  def write(self, oprot):
20153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20155 
      return
20156 
    oprot.writeStructBegin('getAmazonItemDetails_result')
20157 
    if self.success is not None:
20158 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20159 
      self.success.write(oprot)
20160 
      oprot.writeFieldEnd()
20161 
    oprot.writeFieldStop()
20162 
    oprot.writeStructEnd()
20163 
 
20164 
  def validate(self):
20165 
    return
20166 
 
20167 
 
20168 
  def __repr__(self):
20169 
    L = ['%s=%r' % (key, value)
20170 
      for key, value in self.__dict__.iteritems()]
20171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20172 
 
20173 
  def __eq__(self, other):
20174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20175 
 
20176 
  def __ne__(self, other):
20177 
    return not (self == other)
20178 
 
20179 
class updateAmazonItemDetails_args:
20180 
  """
20181 
  Attributes:
8168 kshitij.so 20182 
   - amazonlisted
7281 kshitij.so 20183 
  """
20184 
 
20185 
  thrift_spec = (
20186 
    None, # 0
8168 kshitij.so 20187 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 20188 
  )
20189 
 
8168 kshitij.so 20190 
  def __init__(self, amazonlisted=None,):
20191 
    self.amazonlisted = amazonlisted
7281 kshitij.so 20192 
 
20193 
  def read(self, iprot):
20194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20196 
      return
20197 
    iprot.readStructBegin()
20198 
    while True:
20199 
      (fname, ftype, fid) = iprot.readFieldBegin()
20200 
      if ftype == TType.STOP:
20201 
        break
20202 
      if fid == 1:
8168 kshitij.so 20203 
        if ftype == TType.STRUCT:
20204 
          self.amazonlisted = Amazonlisted()
20205 
          self.amazonlisted.read(iprot)
7281 kshitij.so 20206 
        else:
20207 
          iprot.skip(ftype)
20208 
      else:
20209 
        iprot.skip(ftype)
20210 
      iprot.readFieldEnd()
20211 
    iprot.readStructEnd()
20212 
 
20213 
  def write(self, oprot):
20214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20216 
      return
20217 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 20218 
    if self.amazonlisted is not None:
20219 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20220 
      self.amazonlisted.write(oprot)
7281 kshitij.so 20221 
      oprot.writeFieldEnd()
20222 
    oprot.writeFieldStop()
20223 
    oprot.writeStructEnd()
20224 
 
20225 
  def validate(self):
20226 
    return
20227 
 
20228 
 
20229 
  def __repr__(self):
20230 
    L = ['%s=%r' % (key, value)
20231 
      for key, value in self.__dict__.iteritems()]
20232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20233 
 
20234 
  def __eq__(self, other):
20235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20236 
 
20237 
  def __ne__(self, other):
20238 
    return not (self == other)
20239 
 
20240 
class updateAmazonItemDetails_result:
20241 
 
20242 
  thrift_spec = (
20243 
  )
20244 
 
20245 
  def read(self, iprot):
20246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20248 
      return
20249 
    iprot.readStructBegin()
20250 
    while True:
20251 
      (fname, ftype, fid) = iprot.readFieldBegin()
20252 
      if ftype == TType.STOP:
20253 
        break
20254 
      else:
20255 
        iprot.skip(ftype)
20256 
      iprot.readFieldEnd()
20257 
    iprot.readStructEnd()
20258 
 
20259 
  def write(self, oprot):
20260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20262 
      return
20263 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
20264 
    oprot.writeFieldStop()
20265 
    oprot.writeStructEnd()
20266 
 
20267 
  def validate(self):
20268 
    return
20269 
 
20270 
 
20271 
  def __repr__(self):
20272 
    L = ['%s=%r' % (key, value)
20273 
      for key, value in self.__dict__.iteritems()]
20274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20275 
 
20276 
  def __eq__(self, other):
20277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20278 
 
20279 
  def __ne__(self, other):
20280 
    return not (self == other)
20281 
 
20282 
class addAmazonItem_args:
20283 
  """
20284 
  Attributes:
20285 
   - amazonlisted
20286 
  """
20287 
 
20288 
  thrift_spec = (
20289 
    None, # 0
20290 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
20291 
  )
20292 
 
20293 
  def __init__(self, amazonlisted=None,):
20294 
    self.amazonlisted = amazonlisted
20295 
 
20296 
  def read(self, iprot):
20297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20299 
      return
20300 
    iprot.readStructBegin()
20301 
    while True:
20302 
      (fname, ftype, fid) = iprot.readFieldBegin()
20303 
      if ftype == TType.STOP:
20304 
        break
20305 
      if fid == 1:
20306 
        if ftype == TType.STRUCT:
20307 
          self.amazonlisted = Amazonlisted()
20308 
          self.amazonlisted.read(iprot)
20309 
        else:
20310 
          iprot.skip(ftype)
20311 
      else:
20312 
        iprot.skip(ftype)
20313 
      iprot.readFieldEnd()
20314 
    iprot.readStructEnd()
20315 
 
20316 
  def write(self, oprot):
20317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20319 
      return
20320 
    oprot.writeStructBegin('addAmazonItem_args')
20321 
    if self.amazonlisted is not None:
20322 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
20323 
      self.amazonlisted.write(oprot)
20324 
      oprot.writeFieldEnd()
20325 
    oprot.writeFieldStop()
20326 
    oprot.writeStructEnd()
20327 
 
20328 
  def validate(self):
20329 
    return
20330 
 
20331 
 
20332 
  def __repr__(self):
20333 
    L = ['%s=%r' % (key, value)
20334 
      for key, value in self.__dict__.iteritems()]
20335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20336 
 
20337 
  def __eq__(self, other):
20338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20339 
 
20340 
  def __ne__(self, other):
20341 
    return not (self == other)
20342 
 
20343 
class addAmazonItem_result:
20344 
 
20345 
  thrift_spec = (
20346 
  )
20347 
 
20348 
  def read(self, iprot):
20349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20351 
      return
20352 
    iprot.readStructBegin()
20353 
    while True:
20354 
      (fname, ftype, fid) = iprot.readFieldBegin()
20355 
      if ftype == TType.STOP:
20356 
        break
20357 
      else:
20358 
        iprot.skip(ftype)
20359 
      iprot.readFieldEnd()
20360 
    iprot.readStructEnd()
20361 
 
20362 
  def write(self, oprot):
20363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20365 
      return
20366 
    oprot.writeStructBegin('addAmazonItem_result')
20367 
    oprot.writeFieldStop()
20368 
    oprot.writeStructEnd()
20369 
 
20370 
  def validate(self):
20371 
    return
20372 
 
20373 
 
20374 
  def __repr__(self):
20375 
    L = ['%s=%r' % (key, value)
20376 
      for key, value in self.__dict__.iteritems()]
20377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20378 
 
20379 
  def __eq__(self, other):
20380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20381 
 
20382 
  def __ne__(self, other):
20383 
    return not (self == other)
7291 vikram.rag 20384 
 
20385 
class getAsinItems_args:
20386 
 
20387 
  thrift_spec = (
20388 
  )
20389 
 
20390 
  def read(self, iprot):
20391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20393 
      return
20394 
    iprot.readStructBegin()
20395 
    while True:
20396 
      (fname, ftype, fid) = iprot.readFieldBegin()
20397 
      if ftype == TType.STOP:
20398 
        break
20399 
      else:
20400 
        iprot.skip(ftype)
20401 
      iprot.readFieldEnd()
20402 
    iprot.readStructEnd()
20403 
 
20404 
  def write(self, oprot):
20405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20407 
      return
20408 
    oprot.writeStructBegin('getAsinItems_args')
20409 
    oprot.writeFieldStop()
20410 
    oprot.writeStructEnd()
20411 
 
20412 
  def validate(self):
20413 
    return
20414 
 
20415 
 
20416 
  def __repr__(self):
20417 
    L = ['%s=%r' % (key, value)
20418 
      for key, value in self.__dict__.iteritems()]
20419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20420 
 
20421 
  def __eq__(self, other):
20422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20423 
 
20424 
  def __ne__(self, other):
20425 
    return not (self == other)
20426 
 
20427 
class getAsinItems_result:
20428 
  """
20429 
  Attributes:
20430 
   - success
20431 
  """
20432 
 
20433 
  thrift_spec = (
20434 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
20435 
  )
20436 
 
20437 
  def __init__(self, success=None,):
20438 
    self.success = success
20439 
 
20440 
  def read(self, iprot):
20441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20443 
      return
20444 
    iprot.readStructBegin()
20445 
    while True:
20446 
      (fname, ftype, fid) = iprot.readFieldBegin()
20447 
      if ftype == TType.STOP:
20448 
        break
20449 
      if fid == 0:
20450 
        if ftype == TType.LIST:
20451 
          self.success = []
9155 kshitij.so 20452 
          (_etype442, _size439) = iprot.readListBegin()
20453 
          for _i443 in xrange(_size439):
20454 
            _elem444 = Item()
20455 
            _elem444.read(iprot)
20456 
            self.success.append(_elem444)
7291 vikram.rag 20457 
          iprot.readListEnd()
20458 
        else:
20459 
          iprot.skip(ftype)
20460 
      else:
20461 
        iprot.skip(ftype)
20462 
      iprot.readFieldEnd()
20463 
    iprot.readStructEnd()
20464 
 
20465 
  def write(self, oprot):
20466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20468 
      return
20469 
    oprot.writeStructBegin('getAsinItems_result')
20470 
    if self.success is not None:
20471 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20472 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20473 
      for iter445 in self.success:
20474 
        iter445.write(oprot)
7291 vikram.rag 20475 
      oprot.writeListEnd()
20476 
      oprot.writeFieldEnd()
20477 
    oprot.writeFieldStop()
20478 
    oprot.writeStructEnd()
20479 
 
20480 
  def validate(self):
20481 
    return
20482 
 
20483 
 
20484 
  def __repr__(self):
20485 
    L = ['%s=%r' % (key, value)
20486 
      for key, value in self.__dict__.iteritems()]
20487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20488 
 
20489 
  def __eq__(self, other):
20490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20491 
 
20492 
  def __ne__(self, other):
20493 
    return not (self == other)
20494 
 
20495 
class getAllFbaListedItems_args:
20496 
 
20497 
  thrift_spec = (
20498 
  )
20499 
 
20500 
  def read(self, iprot):
20501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20503 
      return
20504 
    iprot.readStructBegin()
20505 
    while True:
20506 
      (fname, ftype, fid) = iprot.readFieldBegin()
20507 
      if ftype == TType.STOP:
20508 
        break
20509 
      else:
20510 
        iprot.skip(ftype)
20511 
      iprot.readFieldEnd()
20512 
    iprot.readStructEnd()
20513 
 
20514 
  def write(self, oprot):
20515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20517 
      return
20518 
    oprot.writeStructBegin('getAllFbaListedItems_args')
20519 
    oprot.writeFieldStop()
20520 
    oprot.writeStructEnd()
20521 
 
20522 
  def validate(self):
20523 
    return
20524 
 
20525 
 
20526 
  def __repr__(self):
20527 
    L = ['%s=%r' % (key, value)
20528 
      for key, value in self.__dict__.iteritems()]
20529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20530 
 
20531 
  def __eq__(self, other):
20532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20533 
 
20534 
  def __ne__(self, other):
20535 
    return not (self == other)
20536 
 
20537 
class getAllFbaListedItems_result:
20538 
  """
20539 
  Attributes:
20540 
   - success
20541 
  """
20542 
 
20543 
  thrift_spec = (
20544 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20545 
  )
20546 
 
20547 
  def __init__(self, success=None,):
20548 
    self.success = success
20549 
 
20550 
  def read(self, iprot):
20551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20553 
      return
20554 
    iprot.readStructBegin()
20555 
    while True:
20556 
      (fname, ftype, fid) = iprot.readFieldBegin()
20557 
      if ftype == TType.STOP:
20558 
        break
20559 
      if fid == 0:
20560 
        if ftype == TType.LIST:
20561 
          self.success = []
9155 kshitij.so 20562 
          (_etype449, _size446) = iprot.readListBegin()
20563 
          for _i450 in xrange(_size446):
20564 
            _elem451 = Amazonlisted()
20565 
            _elem451.read(iprot)
20566 
            self.success.append(_elem451)
7291 vikram.rag 20567 
          iprot.readListEnd()
20568 
        else:
20569 
          iprot.skip(ftype)
20570 
      else:
20571 
        iprot.skip(ftype)
20572 
      iprot.readFieldEnd()
20573 
    iprot.readStructEnd()
20574 
 
20575 
  def write(self, oprot):
20576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20578 
      return
20579 
    oprot.writeStructBegin('getAllFbaListedItems_result')
20580 
    if self.success is not None:
20581 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20582 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20583 
      for iter452 in self.success:
20584 
        iter452.write(oprot)
7291 vikram.rag 20585 
      oprot.writeListEnd()
20586 
      oprot.writeFieldEnd()
20587 
    oprot.writeFieldStop()
20588 
    oprot.writeStructEnd()
20589 
 
20590 
  def validate(self):
20591 
    return
20592 
 
20593 
 
20594 
  def __repr__(self):
20595 
    L = ['%s=%r' % (key, value)
20596 
      for key, value in self.__dict__.iteritems()]
20597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20598 
 
20599 
  def __eq__(self, other):
20600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20601 
 
20602 
  def __ne__(self, other):
20603 
    return not (self == other)
20604 
 
20605 
class getAllNonFbaListedItems_args:
20606 
 
20607 
  thrift_spec = (
20608 
  )
20609 
 
20610 
  def read(self, iprot):
20611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20613 
      return
20614 
    iprot.readStructBegin()
20615 
    while True:
20616 
      (fname, ftype, fid) = iprot.readFieldBegin()
20617 
      if ftype == TType.STOP:
20618 
        break
20619 
      else:
20620 
        iprot.skip(ftype)
20621 
      iprot.readFieldEnd()
20622 
    iprot.readStructEnd()
20623 
 
20624 
  def write(self, oprot):
20625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20627 
      return
20628 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
20629 
    oprot.writeFieldStop()
20630 
    oprot.writeStructEnd()
20631 
 
20632 
  def validate(self):
20633 
    return
20634 
 
20635 
 
20636 
  def __repr__(self):
20637 
    L = ['%s=%r' % (key, value)
20638 
      for key, value in self.__dict__.iteritems()]
20639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20640 
 
20641 
  def __eq__(self, other):
20642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20643 
 
20644 
  def __ne__(self, other):
20645 
    return not (self == other)
20646 
 
20647 
class getAllNonFbaListedItems_result:
20648 
  """
20649 
  Attributes:
20650 
   - success
20651 
  """
20652 
 
20653 
  thrift_spec = (
20654 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20655 
  )
20656 
 
20657 
  def __init__(self, success=None,):
20658 
    self.success = success
20659 
 
20660 
  def read(self, iprot):
20661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20663 
      return
20664 
    iprot.readStructBegin()
20665 
    while True:
20666 
      (fname, ftype, fid) = iprot.readFieldBegin()
20667 
      if ftype == TType.STOP:
20668 
        break
20669 
      if fid == 0:
20670 
        if ftype == TType.LIST:
20671 
          self.success = []
9155 kshitij.so 20672 
          (_etype456, _size453) = iprot.readListBegin()
20673 
          for _i457 in xrange(_size453):
20674 
            _elem458 = Amazonlisted()
20675 
            _elem458.read(iprot)
20676 
            self.success.append(_elem458)
7291 vikram.rag 20677 
          iprot.readListEnd()
20678 
        else:
20679 
          iprot.skip(ftype)
20680 
      else:
20681 
        iprot.skip(ftype)
20682 
      iprot.readFieldEnd()
20683 
    iprot.readStructEnd()
20684 
 
20685 
  def write(self, oprot):
20686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20688 
      return
20689 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
20690 
    if self.success is not None:
20691 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20692 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 20693 
      for iter459 in self.success:
20694 
        iter459.write(oprot)
7291 vikram.rag 20695 
      oprot.writeListEnd()
20696 
      oprot.writeFieldEnd()
20697 
    oprot.writeFieldStop()
20698 
    oprot.writeStructEnd()
20699 
 
20700 
  def validate(self):
20701 
    return
20702 
 
20703 
 
20704 
  def __repr__(self):
20705 
    L = ['%s=%r' % (key, value)
20706 
      for key, value in self.__dict__.iteritems()]
20707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20708 
 
20709 
  def __eq__(self, other):
20710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20711 
 
20712 
  def __ne__(self, other):
20713 
    return not (self == other)
7460 kshitij.so 20714 
 
20715 
class updateItemInventory_args:
20716 
  """
20717 
  Attributes:
20718 
   - itemId
20719 
   - holdInventory
20720 
   - defaultInventory
20721 
  """
20722 
 
20723 
  thrift_spec = (
20724 
    None, # 0
20725 
    (1, TType.I64, 'itemId', None, None, ), # 1
20726 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
20727 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
20728 
  )
20729 
 
20730 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
20731 
    self.itemId = itemId
20732 
    self.holdInventory = holdInventory
20733 
    self.defaultInventory = defaultInventory
20734 
 
20735 
  def read(self, iprot):
20736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20738 
      return
20739 
    iprot.readStructBegin()
20740 
    while True:
20741 
      (fname, ftype, fid) = iprot.readFieldBegin()
20742 
      if ftype == TType.STOP:
20743 
        break
20744 
      if fid == 1:
20745 
        if ftype == TType.I64:
20746 
          self.itemId = iprot.readI64();
20747 
        else:
20748 
          iprot.skip(ftype)
20749 
      elif fid == 2:
20750 
        if ftype == TType.I64:
20751 
          self.holdInventory = iprot.readI64();
20752 
        else:
20753 
          iprot.skip(ftype)
20754 
      elif fid == 3:
20755 
        if ftype == TType.I64:
20756 
          self.defaultInventory = iprot.readI64();
20757 
        else:
20758 
          iprot.skip(ftype)
20759 
      else:
20760 
        iprot.skip(ftype)
20761 
      iprot.readFieldEnd()
20762 
    iprot.readStructEnd()
20763 
 
20764 
  def write(self, oprot):
20765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20767 
      return
20768 
    oprot.writeStructBegin('updateItemInventory_args')
20769 
    if self.itemId is not None:
20770 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20771 
      oprot.writeI64(self.itemId)
20772 
      oprot.writeFieldEnd()
20773 
    if self.holdInventory is not None:
20774 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
20775 
      oprot.writeI64(self.holdInventory)
20776 
      oprot.writeFieldEnd()
20777 
    if self.defaultInventory is not None:
20778 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
20779 
      oprot.writeI64(self.defaultInventory)
20780 
      oprot.writeFieldEnd()
20781 
    oprot.writeFieldStop()
20782 
    oprot.writeStructEnd()
20783 
 
20784 
  def validate(self):
20785 
    return
20786 
 
20787 
 
20788 
  def __repr__(self):
20789 
    L = ['%s=%r' % (key, value)
20790 
      for key, value in self.__dict__.iteritems()]
20791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20792 
 
20793 
  def __eq__(self, other):
20794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20795 
 
20796 
  def __ne__(self, other):
20797 
    return not (self == other)
20798 
 
20799 
class updateItemInventory_result:
20800 
  """
20801 
  Attributes:
20802 
   - success
20803 
  """
20804 
 
20805 
  thrift_spec = (
20806 
    (0, TType.BOOL, 'success', None, None, ), # 0
20807 
  )
20808 
 
20809 
  def __init__(self, success=None,):
20810 
    self.success = success
20811 
 
20812 
  def read(self, iprot):
20813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20815 
      return
20816 
    iprot.readStructBegin()
20817 
    while True:
20818 
      (fname, ftype, fid) = iprot.readFieldBegin()
20819 
      if ftype == TType.STOP:
20820 
        break
20821 
      if fid == 0:
20822 
        if ftype == TType.BOOL:
20823 
          self.success = iprot.readBool();
20824 
        else:
20825 
          iprot.skip(ftype)
20826 
      else:
20827 
        iprot.skip(ftype)
20828 
      iprot.readFieldEnd()
20829 
    iprot.readStructEnd()
20830 
 
20831 
  def write(self, oprot):
20832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20834 
      return
20835 
    oprot.writeStructBegin('updateItemInventory_result')
20836 
    if self.success is not None:
20837 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20838 
      oprot.writeBool(self.success)
20839 
      oprot.writeFieldEnd()
20840 
    oprot.writeFieldStop()
20841 
    oprot.writeStructEnd()
20842 
 
20843 
  def validate(self):
20844 
    return
20845 
 
20846 
 
20847 
  def __repr__(self):
20848 
    L = ['%s=%r' % (key, value)
20849 
      for key, value in self.__dict__.iteritems()]
20850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20851 
 
20852 
  def __eq__(self, other):
20853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20854 
 
20855 
  def __ne__(self, other):
20856 
    return not (self == other)
7770 kshitij.so 20857 
 
20858 
class updateTimestampForAmazonFeeds_args:
20859 
  """
20860 
  Attributes:
20861 
   - type
20862 
   - sku
20863 
   - timestamp
20864 
  """
20865 
 
20866 
  thrift_spec = (
20867 
    None, # 0
20868 
    (1, TType.STRING, 'type', None, None, ), # 1
20869 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
20870 
    (3, TType.I64, 'timestamp', None, None, ), # 3
20871 
  )
20872 
 
20873 
  def __init__(self, type=None, sku=None, timestamp=None,):
20874 
    self.type = type
20875 
    self.sku = sku
20876 
    self.timestamp = timestamp
20877 
 
20878 
  def read(self, iprot):
20879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20881 
      return
20882 
    iprot.readStructBegin()
20883 
    while True:
20884 
      (fname, ftype, fid) = iprot.readFieldBegin()
20885 
      if ftype == TType.STOP:
20886 
        break
20887 
      if fid == 1:
20888 
        if ftype == TType.STRING:
20889 
          self.type = iprot.readString();
20890 
        else:
20891 
          iprot.skip(ftype)
20892 
      elif fid == 2:
20893 
        if ftype == TType.LIST:
20894 
          self.sku = []
9155 kshitij.so 20895 
          (_etype463, _size460) = iprot.readListBegin()
20896 
          for _i464 in xrange(_size460):
20897 
            _elem465 = iprot.readI64();
20898 
            self.sku.append(_elem465)
7770 kshitij.so 20899 
          iprot.readListEnd()
20900 
        else:
20901 
          iprot.skip(ftype)
20902 
      elif fid == 3:
20903 
        if ftype == TType.I64:
20904 
          self.timestamp = iprot.readI64();
20905 
        else:
20906 
          iprot.skip(ftype)
20907 
      else:
20908 
        iprot.skip(ftype)
20909 
      iprot.readFieldEnd()
20910 
    iprot.readStructEnd()
20911 
 
20912 
  def write(self, oprot):
20913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20915 
      return
20916 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
20917 
    if self.type is not None:
20918 
      oprot.writeFieldBegin('type', TType.STRING, 1)
20919 
      oprot.writeString(self.type)
20920 
      oprot.writeFieldEnd()
20921 
    if self.sku is not None:
20922 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
20923 
      oprot.writeListBegin(TType.I64, len(self.sku))
9155 kshitij.so 20924 
      for iter466 in self.sku:
20925 
        oprot.writeI64(iter466)
7770 kshitij.so 20926 
      oprot.writeListEnd()
20927 
      oprot.writeFieldEnd()
20928 
    if self.timestamp is not None:
20929 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
20930 
      oprot.writeI64(self.timestamp)
20931 
      oprot.writeFieldEnd()
20932 
    oprot.writeFieldStop()
20933 
    oprot.writeStructEnd()
20934 
 
20935 
  def validate(self):
20936 
    return
20937 
 
20938 
 
20939 
  def __repr__(self):
20940 
    L = ['%s=%r' % (key, value)
20941 
      for key, value in self.__dict__.iteritems()]
20942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20943 
 
20944 
  def __eq__(self, other):
20945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20946 
 
20947 
  def __ne__(self, other):
20948 
    return not (self == other)
20949 
 
20950 
class updateTimestampForAmazonFeeds_result:
20951 
  """
20952 
  Attributes:
20953 
   - success
20954 
  """
20955 
 
20956 
  thrift_spec = (
20957 
    (0, TType.BOOL, 'success', None, None, ), # 0
20958 
  )
20959 
 
20960 
  def __init__(self, success=None,):
20961 
    self.success = success
20962 
 
20963 
  def read(self, iprot):
20964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20966 
      return
20967 
    iprot.readStructBegin()
20968 
    while True:
20969 
      (fname, ftype, fid) = iprot.readFieldBegin()
20970 
      if ftype == TType.STOP:
20971 
        break
20972 
      if fid == 0:
20973 
        if ftype == TType.BOOL:
20974 
          self.success = iprot.readBool();
20975 
        else:
20976 
          iprot.skip(ftype)
20977 
      else:
20978 
        iprot.skip(ftype)
20979 
      iprot.readFieldEnd()
20980 
    iprot.readStructEnd()
20981 
 
20982 
  def write(self, oprot):
20983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20985 
      return
20986 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
20987 
    if self.success is not None:
20988 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20989 
      oprot.writeBool(self.success)
20990 
      oprot.writeFieldEnd()
20991 
    oprot.writeFieldStop()
20992 
    oprot.writeStructEnd()
20993 
 
20994 
  def validate(self):
20995 
    return
20996 
 
20997 
 
20998 
  def __repr__(self):
20999 
    L = ['%s=%r' % (key, value)
21000 
      for key, value in self.__dict__.iteritems()]
21001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21002 
 
21003 
  def __eq__(self, other):
21004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21005 
 
21006 
  def __ne__(self, other):
21007 
    return not (self == other)
7897 amar.kumar 21008 
 
21009 
class getAllParentCategories_args:
21010 
 
21011 
  thrift_spec = (
21012 
  )
21013 
 
21014 
  def read(self, iprot):
21015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21017 
      return
21018 
    iprot.readStructBegin()
21019 
    while True:
21020 
      (fname, ftype, fid) = iprot.readFieldBegin()
21021 
      if ftype == TType.STOP:
21022 
        break
21023 
      else:
21024 
        iprot.skip(ftype)
21025 
      iprot.readFieldEnd()
21026 
    iprot.readStructEnd()
21027 
 
21028 
  def write(self, oprot):
21029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21031 
      return
21032 
    oprot.writeStructBegin('getAllParentCategories_args')
21033 
    oprot.writeFieldStop()
21034 
    oprot.writeStructEnd()
21035 
 
21036 
  def validate(self):
21037 
    return
21038 
 
21039 
 
21040 
  def __repr__(self):
21041 
    L = ['%s=%r' % (key, value)
21042 
      for key, value in self.__dict__.iteritems()]
21043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21044 
 
21045 
  def __eq__(self, other):
21046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21047 
 
21048 
  def __ne__(self, other):
21049 
    return not (self == other)
21050 
 
21051 
class getAllParentCategories_result:
21052 
  """
21053 
  Attributes:
21054 
   - success
21055 
  """
21056 
 
21057 
  thrift_spec = (
21058 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
21059 
  )
21060 
 
21061 
  def __init__(self, success=None,):
21062 
    self.success = success
21063 
 
21064 
  def read(self, iprot):
21065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21067 
      return
21068 
    iprot.readStructBegin()
21069 
    while True:
21070 
      (fname, ftype, fid) = iprot.readFieldBegin()
21071 
      if ftype == TType.STOP:
21072 
        break
21073 
      if fid == 0:
21074 
        if ftype == TType.LIST:
21075 
          self.success = []
9155 kshitij.so 21076 
          (_etype470, _size467) = iprot.readListBegin()
21077 
          for _i471 in xrange(_size467):
21078 
            _elem472 = Category()
21079 
            _elem472.read(iprot)
21080 
            self.success.append(_elem472)
7897 amar.kumar 21081 
          iprot.readListEnd()
21082 
        else:
21083 
          iprot.skip(ftype)
21084 
      else:
21085 
        iprot.skip(ftype)
21086 
      iprot.readFieldEnd()
21087 
    iprot.readStructEnd()
21088 
 
21089 
  def write(self, oprot):
21090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21092 
      return
21093 
    oprot.writeStructBegin('getAllParentCategories_result')
21094 
    if self.success is not None:
21095 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21096 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21097 
      for iter473 in self.success:
21098 
        iter473.write(oprot)
7897 amar.kumar 21099 
      oprot.writeListEnd()
21100 
      oprot.writeFieldEnd()
21101 
    oprot.writeFieldStop()
21102 
    oprot.writeStructEnd()
21103 
 
21104 
  def validate(self):
21105 
    return
21106 
 
21107 
 
21108 
  def __repr__(self):
21109 
    L = ['%s=%r' % (key, value)
21110 
      for key, value in self.__dict__.iteritems()]
21111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21112 
 
21113 
  def __eq__(self, other):
21114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21115 
 
21116 
  def __ne__(self, other):
21117 
    return not (self == other)
7977 kshitij.so 21118 
 
21119 
class addPageViewEvent_args:
21120 
  """
21121 
  Attributes:
21122 
   - pageViewEvents
21123 
  """
21124 
 
21125 
  thrift_spec = (
21126 
    None, # 0
21127 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
21128 
  )
21129 
 
21130 
  def __init__(self, pageViewEvents=None,):
21131 
    self.pageViewEvents = pageViewEvents
21132 
 
21133 
  def read(self, iprot):
21134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21136 
      return
21137 
    iprot.readStructBegin()
21138 
    while True:
21139 
      (fname, ftype, fid) = iprot.readFieldBegin()
21140 
      if ftype == TType.STOP:
21141 
        break
21142 
      if fid == 1:
21143 
        if ftype == TType.STRUCT:
21144 
          self.pageViewEvents = PageViewEvents()
21145 
          self.pageViewEvents.read(iprot)
21146 
        else:
21147 
          iprot.skip(ftype)
21148 
      else:
21149 
        iprot.skip(ftype)
21150 
      iprot.readFieldEnd()
21151 
    iprot.readStructEnd()
21152 
 
21153 
  def write(self, oprot):
21154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21156 
      return
21157 
    oprot.writeStructBegin('addPageViewEvent_args')
21158 
    if self.pageViewEvents is not None:
21159 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
21160 
      self.pageViewEvents.write(oprot)
21161 
      oprot.writeFieldEnd()
21162 
    oprot.writeFieldStop()
21163 
    oprot.writeStructEnd()
21164 
 
21165 
  def validate(self):
21166 
    return
21167 
 
21168 
 
21169 
  def __repr__(self):
21170 
    L = ['%s=%r' % (key, value)
21171 
      for key, value in self.__dict__.iteritems()]
21172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21173 
 
21174 
  def __eq__(self, other):
21175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21176 
 
21177 
  def __ne__(self, other):
21178 
    return not (self == other)
21179 
 
21180 
class addPageViewEvent_result:
21181 
 
21182 
  thrift_spec = (
21183 
  )
21184 
 
21185 
  def read(self, iprot):
21186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21188 
      return
21189 
    iprot.readStructBegin()
21190 
    while True:
21191 
      (fname, ftype, fid) = iprot.readFieldBegin()
21192 
      if ftype == TType.STOP:
21193 
        break
21194 
      else:
21195 
        iprot.skip(ftype)
21196 
      iprot.readFieldEnd()
21197 
    iprot.readStructEnd()
21198 
 
21199 
  def write(self, oprot):
21200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21202 
      return
21203 
    oprot.writeStructBegin('addPageViewEvent_result')
21204 
    oprot.writeFieldStop()
21205 
    oprot.writeStructEnd()
21206 
 
21207 
  def validate(self):
21208 
    return
21209 
 
21210 
 
21211 
  def __repr__(self):
21212 
    L = ['%s=%r' % (key, value)
21213 
      for key, value in self.__dict__.iteritems()]
21214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21215 
 
21216 
  def __eq__(self, other):
21217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21218 
 
21219 
  def __ne__(self, other):
21220 
    return not (self == other)
21221 
 
21222 
class addCartEvent_args:
21223 
  """
21224 
  Attributes:
21225 
   - cartEvents
21226 
  """
21227 
 
21228 
  thrift_spec = (
21229 
    None, # 0
21230 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
21231 
  )
21232 
 
21233 
  def __init__(self, cartEvents=None,):
21234 
    self.cartEvents = cartEvents
21235 
 
21236 
  def read(self, iprot):
21237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21239 
      return
21240 
    iprot.readStructBegin()
21241 
    while True:
21242 
      (fname, ftype, fid) = iprot.readFieldBegin()
21243 
      if ftype == TType.STOP:
21244 
        break
21245 
      if fid == 1:
21246 
        if ftype == TType.STRUCT:
21247 
          self.cartEvents = CartEvents()
21248 
          self.cartEvents.read(iprot)
21249 
        else:
21250 
          iprot.skip(ftype)
21251 
      else:
21252 
        iprot.skip(ftype)
21253 
      iprot.readFieldEnd()
21254 
    iprot.readStructEnd()
21255 
 
21256 
  def write(self, oprot):
21257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21259 
      return
21260 
    oprot.writeStructBegin('addCartEvent_args')
21261 
    if self.cartEvents is not None:
21262 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
21263 
      self.cartEvents.write(oprot)
21264 
      oprot.writeFieldEnd()
21265 
    oprot.writeFieldStop()
21266 
    oprot.writeStructEnd()
21267 
 
21268 
  def validate(self):
21269 
    return
21270 
 
21271 
 
21272 
  def __repr__(self):
21273 
    L = ['%s=%r' % (key, value)
21274 
      for key, value in self.__dict__.iteritems()]
21275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21276 
 
21277 
  def __eq__(self, other):
21278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21279 
 
21280 
  def __ne__(self, other):
21281 
    return not (self == other)
21282 
 
21283 
class addCartEvent_result:
21284 
 
21285 
  thrift_spec = (
21286 
  )
21287 
 
21288 
  def read(self, iprot):
21289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21291 
      return
21292 
    iprot.readStructBegin()
21293 
    while True:
21294 
      (fname, ftype, fid) = iprot.readFieldBegin()
21295 
      if ftype == TType.STOP:
21296 
        break
21297 
      else:
21298 
        iprot.skip(ftype)
21299 
      iprot.readFieldEnd()
21300 
    iprot.readStructEnd()
21301 
 
21302 
  def write(self, oprot):
21303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21305 
      return
21306 
    oprot.writeStructBegin('addCartEvent_result')
21307 
    oprot.writeFieldStop()
21308 
    oprot.writeStructEnd()
21309 
 
21310 
  def validate(self):
21311 
    return
21312 
 
21313 
 
21314 
  def __repr__(self):
21315 
    L = ['%s=%r' % (key, value)
21316 
      for key, value in self.__dict__.iteritems()]
21317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21318 
 
21319 
  def __eq__(self, other):
21320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21321 
 
21322 
  def __ne__(self, other):
21323 
    return not (self == other)
8139 kshitij.so 21324 
 
8182 amar.kumar 21325 
class addEbayItem_args:
21326 
  """
21327 
  Attributes:
21328 
   - ebayItem
21329 
  """
21330 
 
21331 
  thrift_spec = (
21332 
    None, # 0
21333 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21334 
  )
21335 
 
21336 
  def __init__(self, ebayItem=None,):
21337 
    self.ebayItem = ebayItem
21338 
 
21339 
  def read(self, iprot):
21340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21342 
      return
21343 
    iprot.readStructBegin()
21344 
    while True:
21345 
      (fname, ftype, fid) = iprot.readFieldBegin()
21346 
      if ftype == TType.STOP:
21347 
        break
21348 
      if fid == 1:
21349 
        if ftype == TType.STRUCT:
21350 
          self.ebayItem = EbayItem()
21351 
          self.ebayItem.read(iprot)
21352 
        else:
21353 
          iprot.skip(ftype)
21354 
      else:
21355 
        iprot.skip(ftype)
21356 
      iprot.readFieldEnd()
21357 
    iprot.readStructEnd()
21358 
 
21359 
  def write(self, oprot):
21360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21362 
      return
21363 
    oprot.writeStructBegin('addEbayItem_args')
21364 
    if self.ebayItem is not None:
21365 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21366 
      self.ebayItem.write(oprot)
21367 
      oprot.writeFieldEnd()
21368 
    oprot.writeFieldStop()
21369 
    oprot.writeStructEnd()
21370 
 
21371 
  def validate(self):
21372 
    return
21373 
 
21374 
 
21375 
  def __repr__(self):
21376 
    L = ['%s=%r' % (key, value)
21377 
      for key, value in self.__dict__.iteritems()]
21378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21379 
 
21380 
  def __eq__(self, other):
21381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21382 
 
21383 
  def __ne__(self, other):
21384 
    return not (self == other)
21385 
 
21386 
class addEbayItem_result:
21387 
 
21388 
  thrift_spec = (
21389 
  )
21390 
 
21391 
  def read(self, iprot):
21392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21394 
      return
21395 
    iprot.readStructBegin()
21396 
    while True:
21397 
      (fname, ftype, fid) = iprot.readFieldBegin()
21398 
      if ftype == TType.STOP:
21399 
        break
21400 
      else:
21401 
        iprot.skip(ftype)
21402 
      iprot.readFieldEnd()
21403 
    iprot.readStructEnd()
21404 
 
21405 
  def write(self, oprot):
21406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21408 
      return
21409 
    oprot.writeStructBegin('addEbayItem_result')
21410 
    oprot.writeFieldStop()
21411 
    oprot.writeStructEnd()
21412 
 
21413 
  def validate(self):
21414 
    return
21415 
 
21416 
 
21417 
  def __repr__(self):
21418 
    L = ['%s=%r' % (key, value)
21419 
      for key, value in self.__dict__.iteritems()]
21420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21421 
 
21422 
  def __eq__(self, other):
21423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21424 
 
21425 
  def __ne__(self, other):
21426 
    return not (self == other)
21427 
 
21428 
class getEbayItem_args:
21429 
  """
21430 
  Attributes:
21431 
   - listingId
21432 
  """
21433 
 
21434 
  thrift_spec = (
21435 
    None, # 0
21436 
    (1, TType.STRING, 'listingId', None, None, ), # 1
21437 
  )
21438 
 
21439 
  def __init__(self, listingId=None,):
21440 
    self.listingId = listingId
21441 
 
21442 
  def read(self, iprot):
21443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21445 
      return
21446 
    iprot.readStructBegin()
21447 
    while True:
21448 
      (fname, ftype, fid) = iprot.readFieldBegin()
21449 
      if ftype == TType.STOP:
21450 
        break
21451 
      if fid == 1:
21452 
        if ftype == TType.STRING:
21453 
          self.listingId = iprot.readString();
21454 
        else:
21455 
          iprot.skip(ftype)
21456 
      else:
21457 
        iprot.skip(ftype)
21458 
      iprot.readFieldEnd()
21459 
    iprot.readStructEnd()
21460 
 
21461 
  def write(self, oprot):
21462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21464 
      return
21465 
    oprot.writeStructBegin('getEbayItem_args')
21466 
    if self.listingId is not None:
21467 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
21468 
      oprot.writeString(self.listingId)
21469 
      oprot.writeFieldEnd()
21470 
    oprot.writeFieldStop()
21471 
    oprot.writeStructEnd()
21472 
 
21473 
  def validate(self):
21474 
    return
21475 
 
21476 
 
21477 
  def __repr__(self):
21478 
    L = ['%s=%r' % (key, value)
21479 
      for key, value in self.__dict__.iteritems()]
21480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21481 
 
21482 
  def __eq__(self, other):
21483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21484 
 
21485 
  def __ne__(self, other):
21486 
    return not (self == other)
21487 
 
21488 
class getEbayItem_result:
21489 
  """
21490 
  Attributes:
21491 
   - success
21492 
  """
21493 
 
21494 
  thrift_spec = (
21495 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
21496 
  )
21497 
 
21498 
  def __init__(self, success=None,):
21499 
    self.success = success
21500 
 
21501 
  def read(self, iprot):
21502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21504 
      return
21505 
    iprot.readStructBegin()
21506 
    while True:
21507 
      (fname, ftype, fid) = iprot.readFieldBegin()
21508 
      if ftype == TType.STOP:
21509 
        break
21510 
      if fid == 0:
21511 
        if ftype == TType.STRUCT:
21512 
          self.success = EbayItem()
21513 
          self.success.read(iprot)
21514 
        else:
21515 
          iprot.skip(ftype)
21516 
      else:
21517 
        iprot.skip(ftype)
21518 
      iprot.readFieldEnd()
21519 
    iprot.readStructEnd()
21520 
 
21521 
  def write(self, oprot):
21522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21524 
      return
21525 
    oprot.writeStructBegin('getEbayItem_result')
21526 
    if self.success is not None:
21527 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21528 
      self.success.write(oprot)
21529 
      oprot.writeFieldEnd()
21530 
    oprot.writeFieldStop()
21531 
    oprot.writeStructEnd()
21532 
 
21533 
  def validate(self):
21534 
    return
21535 
 
21536 
 
21537 
  def __repr__(self):
21538 
    L = ['%s=%r' % (key, value)
21539 
      for key, value in self.__dict__.iteritems()]
21540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21541 
 
21542 
  def __eq__(self, other):
21543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21544 
 
21545 
  def __ne__(self, other):
21546 
    return not (self == other)
21547 
 
21548 
class updateEbayItem_args:
21549 
  """
21550 
  Attributes:
21551 
   - ebayItem
21552 
  """
21553 
 
21554 
  thrift_spec = (
21555 
    None, # 0
21556 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21557 
  )
21558 
 
21559 
  def __init__(self, ebayItem=None,):
21560 
    self.ebayItem = ebayItem
21561 
 
21562 
  def read(self, iprot):
21563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21565 
      return
21566 
    iprot.readStructBegin()
21567 
    while True:
21568 
      (fname, ftype, fid) = iprot.readFieldBegin()
21569 
      if ftype == TType.STOP:
21570 
        break
21571 
      if fid == 1:
21572 
        if ftype == TType.STRUCT:
21573 
          self.ebayItem = EbayItem()
21574 
          self.ebayItem.read(iprot)
21575 
        else:
21576 
          iprot.skip(ftype)
21577 
      else:
21578 
        iprot.skip(ftype)
21579 
      iprot.readFieldEnd()
21580 
    iprot.readStructEnd()
21581 
 
21582 
  def write(self, oprot):
21583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21585 
      return
21586 
    oprot.writeStructBegin('updateEbayItem_args')
21587 
    if self.ebayItem is not None:
21588 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21589 
      self.ebayItem.write(oprot)
21590 
      oprot.writeFieldEnd()
21591 
    oprot.writeFieldStop()
21592 
    oprot.writeStructEnd()
21593 
 
21594 
  def validate(self):
21595 
    return
21596 
 
21597 
 
21598 
  def __repr__(self):
21599 
    L = ['%s=%r' % (key, value)
21600 
      for key, value in self.__dict__.iteritems()]
21601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21602 
 
21603 
  def __eq__(self, other):
21604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21605 
 
21606 
  def __ne__(self, other):
21607 
    return not (self == other)
21608 
 
21609 
class updateEbayItem_result:
21610 
 
21611 
  thrift_spec = (
21612 
  )
21613 
 
21614 
  def read(self, iprot):
21615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21617 
      return
21618 
    iprot.readStructBegin()
21619 
    while True:
21620 
      (fname, ftype, fid) = iprot.readFieldBegin()
21621 
      if ftype == TType.STOP:
21622 
        break
21623 
      else:
21624 
        iprot.skip(ftype)
21625 
      iprot.readFieldEnd()
21626 
    iprot.readStructEnd()
21627 
 
21628 
  def write(self, oprot):
21629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21631 
      return
21632 
    oprot.writeStructBegin('updateEbayItem_result')
21633 
    oprot.writeFieldStop()
21634 
    oprot.writeStructEnd()
21635 
 
21636 
  def validate(self):
21637 
    return
21638 
 
21639 
 
21640 
  def __repr__(self):
21641 
    L = ['%s=%r' % (key, value)
21642 
      for key, value in self.__dict__.iteritems()]
21643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21644 
 
21645 
  def __eq__(self, other):
21646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21647 
 
21648 
  def __ne__(self, other):
21649 
    return not (self == other)
21650 
 
8139 kshitij.so 21651 
class getAmazonListedItems_args:
21652 
  """
21653 
  Attributes:
21654 
   - offset
21655 
   - limit
21656 
  """
21657 
 
21658 
  thrift_spec = (
21659 
    None, # 0
21660 
    (1, TType.I64, 'offset', None, None, ), # 1
21661 
    (2, TType.I64, 'limit', None, None, ), # 2
21662 
  )
21663 
 
21664 
  def __init__(self, offset=None, limit=None,):
21665 
    self.offset = offset
21666 
    self.limit = limit
21667 
 
21668 
  def read(self, iprot):
21669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21671 
      return
21672 
    iprot.readStructBegin()
21673 
    while True:
21674 
      (fname, ftype, fid) = iprot.readFieldBegin()
21675 
      if ftype == TType.STOP:
21676 
        break
21677 
      if fid == 1:
21678 
        if ftype == TType.I64:
21679 
          self.offset = iprot.readI64();
21680 
        else:
21681 
          iprot.skip(ftype)
21682 
      elif fid == 2:
21683 
        if ftype == TType.I64:
21684 
          self.limit = iprot.readI64();
21685 
        else:
21686 
          iprot.skip(ftype)
21687 
      else:
21688 
        iprot.skip(ftype)
21689 
      iprot.readFieldEnd()
21690 
    iprot.readStructEnd()
21691 
 
21692 
  def write(self, oprot):
21693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21695 
      return
21696 
    oprot.writeStructBegin('getAmazonListedItems_args')
21697 
    if self.offset is not None:
21698 
      oprot.writeFieldBegin('offset', TType.I64, 1)
21699 
      oprot.writeI64(self.offset)
21700 
      oprot.writeFieldEnd()
21701 
    if self.limit is not None:
21702 
      oprot.writeFieldBegin('limit', TType.I64, 2)
21703 
      oprot.writeI64(self.limit)
21704 
      oprot.writeFieldEnd()
21705 
    oprot.writeFieldStop()
21706 
    oprot.writeStructEnd()
21707 
 
21708 
  def validate(self):
21709 
    return
21710 
 
21711 
 
21712 
  def __repr__(self):
21713 
    L = ['%s=%r' % (key, value)
21714 
      for key, value in self.__dict__.iteritems()]
21715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21716 
 
21717 
  def __eq__(self, other):
21718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21719 
 
21720 
  def __ne__(self, other):
21721 
    return not (self == other)
21722 
 
21723 
class getAmazonListedItems_result:
21724 
  """
21725 
  Attributes:
21726 
   - success
21727 
  """
21728 
 
21729 
  thrift_spec = (
21730 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21731 
  )
21732 
 
21733 
  def __init__(self, success=None,):
21734 
    self.success = success
21735 
 
21736 
  def read(self, iprot):
21737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21739 
      return
21740 
    iprot.readStructBegin()
21741 
    while True:
21742 
      (fname, ftype, fid) = iprot.readFieldBegin()
21743 
      if ftype == TType.STOP:
21744 
        break
21745 
      if fid == 0:
21746 
        if ftype == TType.LIST:
21747 
          self.success = []
9155 kshitij.so 21748 
          (_etype477, _size474) = iprot.readListBegin()
21749 
          for _i478 in xrange(_size474):
21750 
            _elem479 = Amazonlisted()
21751 
            _elem479.read(iprot)
21752 
            self.success.append(_elem479)
8139 kshitij.so 21753 
          iprot.readListEnd()
21754 
        else:
21755 
          iprot.skip(ftype)
21756 
      else:
21757 
        iprot.skip(ftype)
21758 
      iprot.readFieldEnd()
21759 
    iprot.readStructEnd()
21760 
 
21761 
  def write(self, oprot):
21762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21764 
      return
21765 
    oprot.writeStructBegin('getAmazonListedItems_result')
21766 
    if self.success is not None:
21767 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21768 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 21769 
      for iter480 in self.success:
21770 
        iter480.write(oprot)
8139 kshitij.so 21771 
      oprot.writeListEnd()
21772 
      oprot.writeFieldEnd()
21773 
    oprot.writeFieldStop()
21774 
    oprot.writeStructEnd()
21775 
 
21776 
  def validate(self):
21777 
    return
21778 
 
21779 
 
21780 
  def __repr__(self):
21781 
    L = ['%s=%r' % (key, value)
21782 
      for key, value in self.__dict__.iteritems()]
21783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21784 
 
21785 
  def __eq__(self, other):
21786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21787 
 
21788 
  def __ne__(self, other):
21789 
    return not (self == other)
8168 kshitij.so 21790 
 
21791 
class updateAmazonAttributesInBulk_args:
21792 
  """
21793 
  Attributes:
21794 
   - amazonlisted
21795 
  """
21796 
 
21797 
  thrift_spec = (
21798 
    None, # 0
21799 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
21800 
  )
21801 
 
21802 
  def __init__(self, amazonlisted=None,):
21803 
    self.amazonlisted = amazonlisted
21804 
 
21805 
  def read(self, iprot):
21806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21808 
      return
21809 
    iprot.readStructBegin()
21810 
    while True:
21811 
      (fname, ftype, fid) = iprot.readFieldBegin()
21812 
      if ftype == TType.STOP:
21813 
        break
21814 
      if fid == 1:
21815 
        if ftype == TType.MAP:
21816 
          self.amazonlisted = {}
9155 kshitij.so 21817 
          (_ktype482, _vtype483, _size481 ) = iprot.readMapBegin()
21818 
          for _i485 in xrange(_size481):
21819 
            _key486 = iprot.readI64();
21820 
            _val487 = Amazonlisted()
21821 
            _val487.read(iprot)
21822 
            self.amazonlisted[_key486] = _val487
8168 kshitij.so 21823 
          iprot.readMapEnd()
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('updateAmazonAttributesInBulk_args')
21836 
    if self.amazonlisted is not None:
21837 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
21838 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
9155 kshitij.so 21839 
      for kiter488,viter489 in self.amazonlisted.items():
21840 
        oprot.writeI64(kiter488)
21841 
        viter489.write(oprot)
8168 kshitij.so 21842 
      oprot.writeMapEnd()
21843 
      oprot.writeFieldEnd()
21844 
    oprot.writeFieldStop()
21845 
    oprot.writeStructEnd()
21846 
 
21847 
  def validate(self):
21848 
    return
21849 
 
21850 
 
21851 
  def __repr__(self):
21852 
    L = ['%s=%r' % (key, value)
21853 
      for key, value in self.__dict__.iteritems()]
21854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21855 
 
21856 
  def __eq__(self, other):
21857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21858 
 
21859 
  def __ne__(self, other):
21860 
    return not (self == other)
21861 
 
21862 
class updateAmazonAttributesInBulk_result:
21863 
  """
21864 
  Attributes:
21865 
   - success
21866 
  """
21867 
 
21868 
  thrift_spec = (
21869 
    (0, TType.BOOL, 'success', None, None, ), # 0
21870 
  )
21871 
 
21872 
  def __init__(self, success=None,):
21873 
    self.success = success
21874 
 
21875 
  def read(self, iprot):
21876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21878 
      return
21879 
    iprot.readStructBegin()
21880 
    while True:
21881 
      (fname, ftype, fid) = iprot.readFieldBegin()
21882 
      if ftype == TType.STOP:
21883 
        break
21884 
      if fid == 0:
21885 
        if ftype == TType.BOOL:
21886 
          self.success = iprot.readBool();
21887 
        else:
21888 
          iprot.skip(ftype)
21889 
      else:
21890 
        iprot.skip(ftype)
21891 
      iprot.readFieldEnd()
21892 
    iprot.readStructEnd()
21893 
 
21894 
  def write(self, oprot):
21895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21897 
      return
21898 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
21899 
    if self.success is not None:
21900 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21901 
      oprot.writeBool(self.success)
21902 
      oprot.writeFieldEnd()
21903 
    oprot.writeFieldStop()
21904 
    oprot.writeStructEnd()
21905 
 
21906 
  def validate(self):
21907 
    return
21908 
 
21909 
 
21910 
  def __repr__(self):
21911 
    L = ['%s=%r' % (key, value)
21912 
      for key, value in self.__dict__.iteritems()]
21913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21914 
 
21915 
  def __eq__(self, other):
21916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21917 
 
21918 
  def __ne__(self, other):
21919 
    return not (self == other)
8379 vikram.rag 21920 
 
21921 
class getAllItemstoListOnFba_args:
21922 
 
21923 
  thrift_spec = (
21924 
  )
21925 
 
21926 
  def read(self, iprot):
21927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21929 
      return
21930 
    iprot.readStructBegin()
21931 
    while True:
21932 
      (fname, ftype, fid) = iprot.readFieldBegin()
21933 
      if ftype == TType.STOP:
21934 
        break
21935 
      else:
21936 
        iprot.skip(ftype)
21937 
      iprot.readFieldEnd()
21938 
    iprot.readStructEnd()
21939 
 
21940 
  def write(self, oprot):
21941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21943 
      return
21944 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
21945 
    oprot.writeFieldStop()
21946 
    oprot.writeStructEnd()
21947 
 
21948 
  def validate(self):
21949 
    return
21950 
 
21951 
 
21952 
  def __repr__(self):
21953 
    L = ['%s=%r' % (key, value)
21954 
      for key, value in self.__dict__.iteritems()]
21955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21956 
 
21957 
  def __eq__(self, other):
21958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21959 
 
21960 
  def __ne__(self, other):
21961 
    return not (self == other)
21962 
 
21963 
class getAllItemstoListOnFba_result:
21964 
  """
21965 
  Attributes:
21966 
   - success
21967 
  """
21968 
 
21969 
  thrift_spec = (
21970 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21971 
  )
21972 
 
21973 
  def __init__(self, success=None,):
21974 
    self.success = success
21975 
 
21976 
  def read(self, iprot):
21977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21979 
      return
21980 
    iprot.readStructBegin()
21981 
    while True:
21982 
      (fname, ftype, fid) = iprot.readFieldBegin()
21983 
      if ftype == TType.STOP:
21984 
        break
21985 
      if fid == 0:
21986 
        if ftype == TType.LIST:
21987 
          self.success = []
9155 kshitij.so 21988 
          (_etype493, _size490) = iprot.readListBegin()
21989 
          for _i494 in xrange(_size490):
21990 
            _elem495 = Amazonlisted()
21991 
            _elem495.read(iprot)
21992 
            self.success.append(_elem495)
8379 vikram.rag 21993 
          iprot.readListEnd()
21994 
        else:
21995 
          iprot.skip(ftype)
21996 
      else:
21997 
        iprot.skip(ftype)
21998 
      iprot.readFieldEnd()
21999 
    iprot.readStructEnd()
22000 
 
22001 
  def write(self, oprot):
22002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22004 
      return
22005 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
22006 
    if self.success is not None:
22007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22008 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22009 
      for iter496 in self.success:
22010 
        iter496.write(oprot)
8379 vikram.rag 22011 
      oprot.writeListEnd()
22012 
      oprot.writeFieldEnd()
22013 
    oprot.writeFieldStop()
22014 
    oprot.writeStructEnd()
22015 
 
22016 
  def validate(self):
22017 
    return
22018 
 
22019 
 
22020 
  def __repr__(self):
22021 
    L = ['%s=%r' % (key, value)
22022 
      for key, value in self.__dict__.iteritems()]
22023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22024 
 
22025 
  def __eq__(self, other):
22026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22027 
 
22028 
  def __ne__(self, other):
22029 
    return not (self == other)
22030 
 
22031 
class getAllItemstoListOnNonFba_args:
22032 
 
22033 
  thrift_spec = (
22034 
  )
22035 
 
22036 
  def read(self, iprot):
22037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22039 
      return
22040 
    iprot.readStructBegin()
22041 
    while True:
22042 
      (fname, ftype, fid) = iprot.readFieldBegin()
22043 
      if ftype == TType.STOP:
22044 
        break
22045 
      else:
22046 
        iprot.skip(ftype)
22047 
      iprot.readFieldEnd()
22048 
    iprot.readStructEnd()
22049 
 
22050 
  def write(self, oprot):
22051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22053 
      return
22054 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
22055 
    oprot.writeFieldStop()
22056 
    oprot.writeStructEnd()
22057 
 
22058 
  def validate(self):
22059 
    return
22060 
 
22061 
 
22062 
  def __repr__(self):
22063 
    L = ['%s=%r' % (key, value)
22064 
      for key, value in self.__dict__.iteritems()]
22065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22066 
 
22067 
  def __eq__(self, other):
22068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22069 
 
22070 
  def __ne__(self, other):
22071 
    return not (self == other)
22072 
 
22073 
class getAllItemstoListOnNonFba_result:
22074 
  """
22075 
  Attributes:
22076 
   - success
22077 
  """
22078 
 
22079 
  thrift_spec = (
22080 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
22081 
  )
22082 
 
22083 
  def __init__(self, success=None,):
22084 
    self.success = success
22085 
 
22086 
  def read(self, iprot):
22087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22089 
      return
22090 
    iprot.readStructBegin()
22091 
    while True:
22092 
      (fname, ftype, fid) = iprot.readFieldBegin()
22093 
      if ftype == TType.STOP:
22094 
        break
22095 
      if fid == 0:
22096 
        if ftype == TType.LIST:
22097 
          self.success = []
9155 kshitij.so 22098 
          (_etype500, _size497) = iprot.readListBegin()
22099 
          for _i501 in xrange(_size497):
22100 
            _elem502 = Amazonlisted()
22101 
            _elem502.read(iprot)
22102 
            self.success.append(_elem502)
8379 vikram.rag 22103 
          iprot.readListEnd()
22104 
        else:
22105 
          iprot.skip(ftype)
22106 
      else:
22107 
        iprot.skip(ftype)
22108 
      iprot.readFieldEnd()
22109 
    iprot.readStructEnd()
22110 
 
22111 
  def write(self, oprot):
22112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22114 
      return
22115 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
22116 
    if self.success is not None:
22117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22118 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22119 
      for iter503 in self.success:
22120 
        iter503.write(oprot)
8379 vikram.rag 22121 
      oprot.writeListEnd()
22122 
      oprot.writeFieldEnd()
22123 
    oprot.writeFieldStop()
22124 
    oprot.writeStructEnd()
22125 
 
22126 
  def validate(self):
22127 
    return
22128 
 
22129 
 
22130 
  def __repr__(self):
22131 
    L = ['%s=%r' % (key, value)
22132 
      for key, value in self.__dict__.iteritems()]
22133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22134 
 
22135 
  def __eq__(self, other):
22136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22137 
 
22138 
  def __ne__(self, other):
22139 
    return not (self == other)
8616 vikram.rag 22140 
 
9242 kshitij.so 22141 
class updateAsin_args:
22142 
  """
22143 
  Attributes:
22144 
   - item
22145 
  """
8616 vikram.rag 22146 
 
22147 
  thrift_spec = (
9242 kshitij.so 22148 
    None, # 0
22149 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
8616 vikram.rag 22150 
  )
22151 
 
9242 kshitij.so 22152 
  def __init__(self, item=None,):
22153 
    self.item = item
22154 
 
8616 vikram.rag 22155 
  def read(self, iprot):
22156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22158 
      return
22159 
    iprot.readStructBegin()
22160 
    while True:
22161 
      (fname, ftype, fid) = iprot.readFieldBegin()
22162 
      if ftype == TType.STOP:
22163 
        break
9242 kshitij.so 22164 
      if fid == 1:
22165 
        if ftype == TType.MAP:
22166 
          self.item = {}
22167 
          (_ktype505, _vtype506, _size504 ) = iprot.readMapBegin()
22168 
          for _i508 in xrange(_size504):
22169 
            _key509 = iprot.readI64();
22170 
            _val510 = Item()
22171 
            _val510.read(iprot)
22172 
            self.item[_key509] = _val510
22173 
          iprot.readMapEnd()
22174 
        else:
22175 
          iprot.skip(ftype)
8616 vikram.rag 22176 
      else:
22177 
        iprot.skip(ftype)
22178 
      iprot.readFieldEnd()
22179 
    iprot.readStructEnd()
22180 
 
22181 
  def write(self, oprot):
22182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22184 
      return
9242 kshitij.so 22185 
    oprot.writeStructBegin('updateAsin_args')
22186 
    if self.item is not None:
22187 
      oprot.writeFieldBegin('item', TType.MAP, 1)
22188 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
22189 
      for kiter511,viter512 in self.item.items():
22190 
        oprot.writeI64(kiter511)
22191 
        viter512.write(oprot)
22192 
      oprot.writeMapEnd()
22193 
      oprot.writeFieldEnd()
8616 vikram.rag 22194 
    oprot.writeFieldStop()
22195 
    oprot.writeStructEnd()
22196 
 
22197 
  def validate(self):
22198 
    return
22199 
 
22200 
 
22201 
  def __repr__(self):
22202 
    L = ['%s=%r' % (key, value)
22203 
      for key, value in self.__dict__.iteritems()]
22204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22205 
 
22206 
  def __eq__(self, other):
22207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22208 
 
22209 
  def __ne__(self, other):
22210 
    return not (self == other)
22211 
 
9242 kshitij.so 22212 
class updateAsin_result:
8616 vikram.rag 22213 
 
22214 
  thrift_spec = (
22215 
  )
22216 
 
22217 
  def read(self, iprot):
22218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22220 
      return
22221 
    iprot.readStructBegin()
22222 
    while True:
22223 
      (fname, ftype, fid) = iprot.readFieldBegin()
22224 
      if ftype == TType.STOP:
22225 
        break
22226 
      else:
22227 
        iprot.skip(ftype)
22228 
      iprot.readFieldEnd()
22229 
    iprot.readStructEnd()
22230 
 
22231 
  def write(self, oprot):
22232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22234 
      return
9242 kshitij.so 22235 
    oprot.writeStructBegin('updateAsin_result')
8616 vikram.rag 22236 
    oprot.writeFieldStop()
22237 
    oprot.writeStructEnd()
22238 
 
22239 
  def validate(self):
22240 
    return
22241 
 
22242 
 
22243 
  def __repr__(self):
22244 
    L = ['%s=%r' % (key, value)
22245 
      for key, value in self.__dict__.iteritems()]
22246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22247 
 
22248 
  def __eq__(self, other):
22249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22250 
 
22251 
  def __ne__(self, other):
22252 
    return not (self == other)
8619 kshitij.so 22253 
 
9242 kshitij.so 22254 
class addOrUpdateSnapdealItem_args:
8619 kshitij.so 22255 
  """
22256 
  Attributes:
9242 kshitij.so 22257 
   - snapdealitem
8619 kshitij.so 22258 
  """
22259 
 
9242 kshitij.so 22260 
  thrift_spec = None
22261 
  def __init__(self, snapdealitem=None,):
22262 
    self.snapdealitem = snapdealitem
8619 kshitij.so 22263 
 
22264 
  def read(self, iprot):
22265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22267 
      return
22268 
    iprot.readStructBegin()
22269 
    while True:
22270 
      (fname, ftype, fid) = iprot.readFieldBegin()
22271 
      if ftype == TType.STOP:
22272 
        break
9242 kshitij.so 22273 
      if fid == -1:
22274 
        if ftype == TType.STRUCT:
22275 
          self.snapdealitem = SnapdealItem()
22276 
          self.snapdealitem.read(iprot)
8619 kshitij.so 22277 
        else:
22278 
          iprot.skip(ftype)
22279 
      else:
22280 
        iprot.skip(ftype)
22281 
      iprot.readFieldEnd()
22282 
    iprot.readStructEnd()
22283 
 
22284 
  def write(self, oprot):
22285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22287 
      return
9242 kshitij.so 22288 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
22289 
    if self.snapdealitem is not None:
22290 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
22291 
      self.snapdealitem.write(oprot)
8619 kshitij.so 22292 
      oprot.writeFieldEnd()
22293 
    oprot.writeFieldStop()
22294 
    oprot.writeStructEnd()
22295 
 
22296 
  def validate(self):
22297 
    return
22298 
 
22299 
 
22300 
  def __repr__(self):
22301 
    L = ['%s=%r' % (key, value)
22302 
      for key, value in self.__dict__.iteritems()]
22303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22304 
 
22305 
  def __eq__(self, other):
22306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22307 
 
22308 
  def __ne__(self, other):
22309 
    return not (self == other)
22310 
 
9242 kshitij.so 22311 
class addOrUpdateSnapdealItem_result:
22312 
  """
22313 
  Attributes:
22314 
   - success
22315 
  """
8619 kshitij.so 22316 
 
22317 
  thrift_spec = (
9242 kshitij.so 22318 
    (0, TType.BOOL, 'success', None, None, ), # 0
8619 kshitij.so 22319 
  )
22320 
 
9242 kshitij.so 22321 
  def __init__(self, success=None,):
22322 
    self.success = success
22323 
 
8619 kshitij.so 22324 
  def read(self, iprot):
22325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22327 
      return
22328 
    iprot.readStructBegin()
22329 
    while True:
22330 
      (fname, ftype, fid) = iprot.readFieldBegin()
22331 
      if ftype == TType.STOP:
22332 
        break
9242 kshitij.so 22333 
      if fid == 0:
22334 
        if ftype == TType.BOOL:
22335 
          self.success = iprot.readBool();
22336 
        else:
22337 
          iprot.skip(ftype)
8619 kshitij.so 22338 
      else:
22339 
        iprot.skip(ftype)
22340 
      iprot.readFieldEnd()
22341 
    iprot.readStructEnd()
22342 
 
22343 
  def write(self, oprot):
22344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22346 
      return
9242 kshitij.so 22347 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
22348 
    if self.success is not None:
22349 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22350 
      oprot.writeBool(self.success)
22351 
      oprot.writeFieldEnd()
8619 kshitij.so 22352 
    oprot.writeFieldStop()
22353 
    oprot.writeStructEnd()
22354 
 
22355 
  def validate(self):
22356 
    return
22357 
 
22358 
 
22359 
  def __repr__(self):
22360 
    L = ['%s=%r' % (key, value)
22361 
      for key, value in self.__dict__.iteritems()]
22362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22363 
 
22364 
  def __eq__(self, other):
22365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22366 
 
22367 
  def __ne__(self, other):
22368 
    return not (self == other)
8739 vikram.rag 22369 
 
9242 kshitij.so 22370 
class getSnapdealItem_args:
8739 vikram.rag 22371 
  """
22372 
  Attributes:
9242 kshitij.so 22373 
   - item_id
8739 vikram.rag 22374 
  """
22375 
 
9242 kshitij.so 22376 
  thrift_spec = (
22377 
    None, # 0
22378 
    (1, TType.I64, 'item_id', None, None, ), # 1
22379 
  )
8739 vikram.rag 22380 
 
9242 kshitij.so 22381 
  def __init__(self, item_id=None,):
22382 
    self.item_id = item_id
22383 
 
8739 vikram.rag 22384 
  def read(self, iprot):
22385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22387 
      return
22388 
    iprot.readStructBegin()
22389 
    while True:
22390 
      (fname, ftype, fid) = iprot.readFieldBegin()
22391 
      if ftype == TType.STOP:
22392 
        break
9242 kshitij.so 22393 
      if fid == 1:
22394 
        if ftype == TType.I64:
22395 
          self.item_id = iprot.readI64();
8739 vikram.rag 22396 
        else:
22397 
          iprot.skip(ftype)
22398 
      else:
22399 
        iprot.skip(ftype)
22400 
      iprot.readFieldEnd()
22401 
    iprot.readStructEnd()
22402 
 
22403 
  def write(self, oprot):
22404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22406 
      return
9242 kshitij.so 22407 
    oprot.writeStructBegin('getSnapdealItem_args')
22408 
    if self.item_id is not None:
22409 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22410 
      oprot.writeI64(self.item_id)
8739 vikram.rag 22411 
      oprot.writeFieldEnd()
22412 
    oprot.writeFieldStop()
22413 
    oprot.writeStructEnd()
22414 
 
22415 
  def validate(self):
22416 
    return
22417 
 
22418 
 
22419 
  def __repr__(self):
22420 
    L = ['%s=%r' % (key, value)
22421 
      for key, value in self.__dict__.iteritems()]
22422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22423 
 
22424 
  def __eq__(self, other):
22425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22426 
 
22427 
  def __ne__(self, other):
22428 
    return not (self == other)
22429 
 
9242 kshitij.so 22430 
class getSnapdealItem_result:
8739 vikram.rag 22431 
  """
22432 
  Attributes:
22433 
   - success
22434 
  """
22435 
 
22436 
  thrift_spec = (
9242 kshitij.so 22437 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
8739 vikram.rag 22438 
  )
22439 
 
22440 
  def __init__(self, success=None,):
22441 
    self.success = success
22442 
 
22443 
  def read(self, iprot):
22444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22446 
      return
22447 
    iprot.readStructBegin()
22448 
    while True:
22449 
      (fname, ftype, fid) = iprot.readFieldBegin()
22450 
      if ftype == TType.STOP:
22451 
        break
22452 
      if fid == 0:
9242 kshitij.so 22453 
        if ftype == TType.STRUCT:
22454 
          self.success = SnapdealItem()
22455 
          self.success.read(iprot)
8739 vikram.rag 22456 
        else:
22457 
          iprot.skip(ftype)
22458 
      else:
22459 
        iprot.skip(ftype)
22460 
      iprot.readFieldEnd()
22461 
    iprot.readStructEnd()
22462 
 
22463 
  def write(self, oprot):
22464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22466 
      return
9242 kshitij.so 22467 
    oprot.writeStructBegin('getSnapdealItem_result')
8739 vikram.rag 22468 
    if self.success is not None:
9242 kshitij.so 22469 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22470 
      self.success.write(oprot)
8739 vikram.rag 22471 
      oprot.writeFieldEnd()
22472 
    oprot.writeFieldStop()
22473 
    oprot.writeStructEnd()
22474 
 
22475 
  def validate(self):
22476 
    return
22477 
 
22478 
 
22479 
  def __repr__(self):
22480 
    L = ['%s=%r' % (key, value)
22481 
      for key, value in self.__dict__.iteritems()]
22482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22483 
 
22484 
  def __eq__(self, other):
22485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22486 
 
22487 
  def __ne__(self, other):
22488 
    return not (self == other)
22489 
 
9242 kshitij.so 22490 
class getSnapdealItemDetails_args:
8739 vikram.rag 22491 
  """
22492 
  Attributes:
22493 
   - item_id
22494 
  """
22495 
 
22496 
  thrift_spec = (
22497 
    None, # 0
22498 
    (1, TType.I64, 'item_id', None, None, ), # 1
22499 
  )
22500 
 
22501 
  def __init__(self, item_id=None,):
22502 
    self.item_id = item_id
22503 
 
22504 
  def read(self, iprot):
22505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22507 
      return
22508 
    iprot.readStructBegin()
22509 
    while True:
22510 
      (fname, ftype, fid) = iprot.readFieldBegin()
22511 
      if ftype == TType.STOP:
22512 
        break
22513 
      if fid == 1:
22514 
        if ftype == TType.I64:
22515 
          self.item_id = iprot.readI64();
22516 
        else:
22517 
          iprot.skip(ftype)
22518 
      else:
22519 
        iprot.skip(ftype)
22520 
      iprot.readFieldEnd()
22521 
    iprot.readStructEnd()
22522 
 
22523 
  def write(self, oprot):
22524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22526 
      return
9242 kshitij.so 22527 
    oprot.writeStructBegin('getSnapdealItemDetails_args')
8739 vikram.rag 22528 
    if self.item_id is not None:
22529 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22530 
      oprot.writeI64(self.item_id)
22531 
      oprot.writeFieldEnd()
22532 
    oprot.writeFieldStop()
22533 
    oprot.writeStructEnd()
22534 
 
22535 
  def validate(self):
22536 
    return
22537 
 
22538 
 
22539 
  def __repr__(self):
22540 
    L = ['%s=%r' % (key, value)
22541 
      for key, value in self.__dict__.iteritems()]
22542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22543 
 
22544 
  def __eq__(self, other):
22545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22546 
 
22547 
  def __ne__(self, other):
22548 
    return not (self == other)
22549 
 
9242 kshitij.so 22550 
class getSnapdealItemDetails_result:
8739 vikram.rag 22551 
  """
22552 
  Attributes:
22553 
   - success
22554 
  """
22555 
 
22556 
  thrift_spec = (
9242 kshitij.so 22557 
    (0, TType.STRUCT, 'success', (SnapdealItemDetails, SnapdealItemDetails.thrift_spec), None, ), # 0
8739 vikram.rag 22558 
  )
22559 
 
22560 
  def __init__(self, success=None,):
22561 
    self.success = success
22562 
 
22563 
  def read(self, iprot):
22564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22566 
      return
22567 
    iprot.readStructBegin()
22568 
    while True:
22569 
      (fname, ftype, fid) = iprot.readFieldBegin()
22570 
      if ftype == TType.STOP:
22571 
        break
22572 
      if fid == 0:
22573 
        if ftype == TType.STRUCT:
9242 kshitij.so 22574 
          self.success = SnapdealItemDetails()
8739 vikram.rag 22575 
          self.success.read(iprot)
22576 
        else:
22577 
          iprot.skip(ftype)
22578 
      else:
22579 
        iprot.skip(ftype)
22580 
      iprot.readFieldEnd()
22581 
    iprot.readStructEnd()
22582 
 
22583 
  def write(self, oprot):
22584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22586 
      return
9242 kshitij.so 22587 
    oprot.writeStructBegin('getSnapdealItemDetails_result')
8739 vikram.rag 22588 
    if self.success is not None:
22589 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22590 
      self.success.write(oprot)
22591 
      oprot.writeFieldEnd()
22592 
    oprot.writeFieldStop()
22593 
    oprot.writeStructEnd()
22594 
 
22595 
  def validate(self):
22596 
    return
22597 
 
22598 
 
22599 
  def __repr__(self):
22600 
    L = ['%s=%r' % (key, value)
22601 
      for key, value in self.__dict__.iteritems()]
22602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22603 
 
22604 
  def __eq__(self, other):
22605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22606 
 
22607 
  def __ne__(self, other):
22608 
    return not (self == other)
22609 
 
22610 
class getAllSnapdealItems_args:
22611 
 
22612 
  thrift_spec = (
22613 
  )
22614 
 
22615 
  def read(self, iprot):
22616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22618 
      return
22619 
    iprot.readStructBegin()
22620 
    while True:
22621 
      (fname, ftype, fid) = iprot.readFieldBegin()
22622 
      if ftype == TType.STOP:
22623 
        break
22624 
      else:
22625 
        iprot.skip(ftype)
22626 
      iprot.readFieldEnd()
22627 
    iprot.readStructEnd()
22628 
 
22629 
  def write(self, oprot):
22630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22632 
      return
22633 
    oprot.writeStructBegin('getAllSnapdealItems_args')
22634 
    oprot.writeFieldStop()
22635 
    oprot.writeStructEnd()
22636 
 
22637 
  def validate(self):
22638 
    return
22639 
 
22640 
 
22641 
  def __repr__(self):
22642 
    L = ['%s=%r' % (key, value)
22643 
      for key, value in self.__dict__.iteritems()]
22644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22645 
 
22646 
  def __eq__(self, other):
22647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22648 
 
22649 
  def __ne__(self, other):
22650 
    return not (self == other)
22651 
 
22652 
class getAllSnapdealItems_result:
22653 
  """
22654 
  Attributes:
22655 
   - success
22656 
  """
22657 
 
22658 
  thrift_spec = (
9242 kshitij.so 22659 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
8739 vikram.rag 22660 
  )
22661 
 
22662 
  def __init__(self, success=None,):
22663 
    self.success = success
22664 
 
22665 
  def read(self, iprot):
22666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22668 
      return
22669 
    iprot.readStructBegin()
22670 
    while True:
22671 
      (fname, ftype, fid) = iprot.readFieldBegin()
22672 
      if ftype == TType.STOP:
22673 
        break
22674 
      if fid == 0:
22675 
        if ftype == TType.LIST:
22676 
          self.success = []
9242 kshitij.so 22677 
          (_etype516, _size513) = iprot.readListBegin()
22678 
          for _i517 in xrange(_size513):
22679 
            _elem518 = SnapdealItemDetails()
22680 
            _elem518.read(iprot)
22681 
            self.success.append(_elem518)
22682 
          iprot.readListEnd()
22683 
        else:
22684 
          iprot.skip(ftype)
22685 
      else:
22686 
        iprot.skip(ftype)
22687 
      iprot.readFieldEnd()
22688 
    iprot.readStructEnd()
22689 
 
22690 
  def write(self, oprot):
22691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22693 
      return
22694 
    oprot.writeStructBegin('getAllSnapdealItems_result')
22695 
    if self.success is not None:
22696 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22697 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22698 
      for iter519 in self.success:
22699 
        iter519.write(oprot)
22700 
      oprot.writeListEnd()
22701 
      oprot.writeFieldEnd()
22702 
    oprot.writeFieldStop()
22703 
    oprot.writeStructEnd()
22704 
 
22705 
  def validate(self):
22706 
    return
22707 
 
22708 
 
22709 
  def __repr__(self):
22710 
    L = ['%s=%r' % (key, value)
22711 
      for key, value in self.__dict__.iteritems()]
22712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22713 
 
22714 
  def __eq__(self, other):
22715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22716 
 
22717 
  def __ne__(self, other):
22718 
    return not (self == other)
22719 
 
22720 
class getSnapdealItems_args:
22721 
  """
22722 
  Attributes:
22723 
   - offset
22724 
   - limit
22725 
  """
22726 
 
22727 
  thrift_spec = (
22728 
    None, # 0
22729 
    (1, TType.I64, 'offset', None, None, ), # 1
22730 
    (2, TType.I64, 'limit', None, None, ), # 2
22731 
  )
22732 
 
22733 
  def __init__(self, offset=None, limit=None,):
22734 
    self.offset = offset
22735 
    self.limit = limit
22736 
 
22737 
  def read(self, iprot):
22738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22740 
      return
22741 
    iprot.readStructBegin()
22742 
    while True:
22743 
      (fname, ftype, fid) = iprot.readFieldBegin()
22744 
      if ftype == TType.STOP:
22745 
        break
22746 
      if fid == 1:
22747 
        if ftype == TType.I64:
22748 
          self.offset = iprot.readI64();
22749 
        else:
22750 
          iprot.skip(ftype)
22751 
      elif fid == 2:
22752 
        if ftype == TType.I64:
22753 
          self.limit = iprot.readI64();
22754 
        else:
22755 
          iprot.skip(ftype)
22756 
      else:
22757 
        iprot.skip(ftype)
22758 
      iprot.readFieldEnd()
22759 
    iprot.readStructEnd()
22760 
 
22761 
  def write(self, oprot):
22762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22764 
      return
22765 
    oprot.writeStructBegin('getSnapdealItems_args')
22766 
    if self.offset is not None:
22767 
      oprot.writeFieldBegin('offset', TType.I64, 1)
22768 
      oprot.writeI64(self.offset)
22769 
      oprot.writeFieldEnd()
22770 
    if self.limit is not None:
22771 
      oprot.writeFieldBegin('limit', TType.I64, 2)
22772 
      oprot.writeI64(self.limit)
22773 
      oprot.writeFieldEnd()
22774 
    oprot.writeFieldStop()
22775 
    oprot.writeStructEnd()
22776 
 
22777 
  def validate(self):
22778 
    return
22779 
 
22780 
 
22781 
  def __repr__(self):
22782 
    L = ['%s=%r' % (key, value)
22783 
      for key, value in self.__dict__.iteritems()]
22784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22785 
 
22786 
  def __eq__(self, other):
22787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22788 
 
22789 
  def __ne__(self, other):
22790 
    return not (self == other)
22791 
 
22792 
class getSnapdealItems_result:
22793 
  """
22794 
  Attributes:
22795 
   - success
22796 
  """
22797 
 
22798 
  thrift_spec = (
22799 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
22800 
  )
22801 
 
22802 
  def __init__(self, success=None,):
22803 
    self.success = success
22804 
 
22805 
  def read(self, iprot):
22806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22808 
      return
22809 
    iprot.readStructBegin()
22810 
    while True:
22811 
      (fname, ftype, fid) = iprot.readFieldBegin()
22812 
      if ftype == TType.STOP:
22813 
        break
22814 
      if fid == 0:
22815 
        if ftype == TType.LIST:
22816 
          self.success = []
9155 kshitij.so 22817 
          (_etype523, _size520) = iprot.readListBegin()
22818 
          for _i524 in xrange(_size520):
9242 kshitij.so 22819 
            _elem525 = SnapdealItemDetails()
9155 kshitij.so 22820 
            _elem525.read(iprot)
22821 
            self.success.append(_elem525)
8739 vikram.rag 22822 
          iprot.readListEnd()
22823 
        else:
22824 
          iprot.skip(ftype)
22825 
      else:
22826 
        iprot.skip(ftype)
22827 
      iprot.readFieldEnd()
22828 
    iprot.readStructEnd()
22829 
 
22830 
  def write(self, oprot):
22831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22833 
      return
9242 kshitij.so 22834 
    oprot.writeStructBegin('getSnapdealItems_result')
8739 vikram.rag 22835 
    if self.success is not None:
22836 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22837 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9155 kshitij.so 22838 
      for iter526 in self.success:
22839 
        iter526.write(oprot)
8739 vikram.rag 22840 
      oprot.writeListEnd()
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)
9242 kshitij.so 22859 
 
22860 
class searchSnapdealItems_args:
22861 
  """
22862 
  Attributes:
22863 
   - searchTerm
22864 
   - offset
22865 
   - limit
22866 
  """
22867 
 
22868 
  thrift_spec = (
22869 
    None, # 0
22870 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
22871 
    (2, TType.I64, 'offset', None, None, ), # 2
22872 
    (3, TType.I64, 'limit', None, None, ), # 3
22873 
  )
22874 
 
22875 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
22876 
    self.searchTerm = searchTerm
22877 
    self.offset = offset
22878 
    self.limit = limit
22879 
 
22880 
  def read(self, iprot):
22881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22883 
      return
22884 
    iprot.readStructBegin()
22885 
    while True:
22886 
      (fname, ftype, fid) = iprot.readFieldBegin()
22887 
      if ftype == TType.STOP:
22888 
        break
22889 
      if fid == 1:
22890 
        if ftype == TType.LIST:
22891 
          self.searchTerm = []
22892 
          (_etype530, _size527) = iprot.readListBegin()
22893 
          for _i531 in xrange(_size527):
22894 
            _elem532 = iprot.readString();
22895 
            self.searchTerm.append(_elem532)
22896 
          iprot.readListEnd()
22897 
        else:
22898 
          iprot.skip(ftype)
22899 
      elif fid == 2:
22900 
        if ftype == TType.I64:
22901 
          self.offset = iprot.readI64();
22902 
        else:
22903 
          iprot.skip(ftype)
22904 
      elif fid == 3:
22905 
        if ftype == TType.I64:
22906 
          self.limit = iprot.readI64();
22907 
        else:
22908 
          iprot.skip(ftype)
22909 
      else:
22910 
        iprot.skip(ftype)
22911 
      iprot.readFieldEnd()
22912 
    iprot.readStructEnd()
22913 
 
22914 
  def write(self, oprot):
22915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22917 
      return
22918 
    oprot.writeStructBegin('searchSnapdealItems_args')
22919 
    if self.searchTerm is not None:
22920 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
22921 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
22922 
      for iter533 in self.searchTerm:
22923 
        oprot.writeString(iter533)
22924 
      oprot.writeListEnd()
22925 
      oprot.writeFieldEnd()
22926 
    if self.offset is not None:
22927 
      oprot.writeFieldBegin('offset', TType.I64, 2)
22928 
      oprot.writeI64(self.offset)
22929 
      oprot.writeFieldEnd()
22930 
    if self.limit is not None:
22931 
      oprot.writeFieldBegin('limit', TType.I64, 3)
22932 
      oprot.writeI64(self.limit)
22933 
      oprot.writeFieldEnd()
22934 
    oprot.writeFieldStop()
22935 
    oprot.writeStructEnd()
22936 
 
22937 
  def validate(self):
22938 
    return
22939 
 
22940 
 
22941 
  def __repr__(self):
22942 
    L = ['%s=%r' % (key, value)
22943 
      for key, value in self.__dict__.iteritems()]
22944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22945 
 
22946 
  def __eq__(self, other):
22947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22948 
 
22949 
  def __ne__(self, other):
22950 
    return not (self == other)
22951 
 
22952 
class searchSnapdealItems_result:
22953 
  """
22954 
  Attributes:
22955 
   - success
22956 
  """
22957 
 
22958 
  thrift_spec = (
22959 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItemDetails, SnapdealItemDetails.thrift_spec)), None, ), # 0
22960 
  )
22961 
 
22962 
  def __init__(self, success=None,):
22963 
    self.success = success
22964 
 
22965 
  def read(self, iprot):
22966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22968 
      return
22969 
    iprot.readStructBegin()
22970 
    while True:
22971 
      (fname, ftype, fid) = iprot.readFieldBegin()
22972 
      if ftype == TType.STOP:
22973 
        break
22974 
      if fid == 0:
22975 
        if ftype == TType.LIST:
22976 
          self.success = []
22977 
          (_etype537, _size534) = iprot.readListBegin()
22978 
          for _i538 in xrange(_size534):
22979 
            _elem539 = SnapdealItemDetails()
22980 
            _elem539.read(iprot)
22981 
            self.success.append(_elem539)
22982 
          iprot.readListEnd()
22983 
        else:
22984 
          iprot.skip(ftype)
22985 
      else:
22986 
        iprot.skip(ftype)
22987 
      iprot.readFieldEnd()
22988 
    iprot.readStructEnd()
22989 
 
22990 
  def write(self, oprot):
22991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22993 
      return
22994 
    oprot.writeStructBegin('searchSnapdealItems_result')
22995 
    if self.success is not None:
22996 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22997 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22998 
      for iter540 in self.success:
22999 
        iter540.write(oprot)
23000 
      oprot.writeListEnd()
23001 
      oprot.writeFieldEnd()
23002 
    oprot.writeFieldStop()
23003 
    oprot.writeStructEnd()
23004 
 
23005 
  def validate(self):
23006 
    return
23007 
 
23008 
 
23009 
  def __repr__(self):
23010 
    L = ['%s=%r' % (key, value)
23011 
      for key, value in self.__dict__.iteritems()]
23012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23013 
 
23014 
  def __eq__(self, other):
23015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23016 
 
23017 
  def __ne__(self, other):
23018 
    return not (self == other)
23019 
 
23020 
class getCountForSnapdealItems_args:
23021 
 
23022 
  thrift_spec = (
23023 
  )
23024 
 
23025 
  def read(self, iprot):
23026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23028 
      return
23029 
    iprot.readStructBegin()
23030 
    while True:
23031 
      (fname, ftype, fid) = iprot.readFieldBegin()
23032 
      if ftype == TType.STOP:
23033 
        break
23034 
      else:
23035 
        iprot.skip(ftype)
23036 
      iprot.readFieldEnd()
23037 
    iprot.readStructEnd()
23038 
 
23039 
  def write(self, oprot):
23040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23042 
      return
23043 
    oprot.writeStructBegin('getCountForSnapdealItems_args')
23044 
    oprot.writeFieldStop()
23045 
    oprot.writeStructEnd()
23046 
 
23047 
  def validate(self):
23048 
    return
23049 
 
23050 
 
23051 
  def __repr__(self):
23052 
    L = ['%s=%r' % (key, value)
23053 
      for key, value in self.__dict__.iteritems()]
23054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23055 
 
23056 
  def __eq__(self, other):
23057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23058 
 
23059 
  def __ne__(self, other):
23060 
    return not (self == other)
23061 
 
23062 
class getCountForSnapdealItems_result:
23063 
  """
23064 
  Attributes:
23065 
   - success
23066 
  """
23067 
 
23068 
  thrift_spec = (
23069 
    (0, TType.I64, 'success', None, None, ), # 0
23070 
  )
23071 
 
23072 
  def __init__(self, success=None,):
23073 
    self.success = success
23074 
 
23075 
  def read(self, iprot):
23076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23078 
      return
23079 
    iprot.readStructBegin()
23080 
    while True:
23081 
      (fname, ftype, fid) = iprot.readFieldBegin()
23082 
      if ftype == TType.STOP:
23083 
        break
23084 
      if fid == 0:
23085 
        if ftype == TType.I64:
23086 
          self.success = iprot.readI64();
23087 
        else:
23088 
          iprot.skip(ftype)
23089 
      else:
23090 
        iprot.skip(ftype)
23091 
      iprot.readFieldEnd()
23092 
    iprot.readStructEnd()
23093 
 
23094 
  def write(self, oprot):
23095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23097 
      return
23098 
    oprot.writeStructBegin('getCountForSnapdealItems_result')
23099 
    if self.success is not None:
23100 
      oprot.writeFieldBegin('success', TType.I64, 0)
23101 
      oprot.writeI64(self.success)
23102 
      oprot.writeFieldEnd()
23103 
    oprot.writeFieldStop()
23104 
    oprot.writeStructEnd()
23105 
 
23106 
  def validate(self):
23107 
    return
23108 
 
23109 
 
23110 
  def __repr__(self):
23111 
    L = ['%s=%r' % (key, value)
23112 
      for key, value in self.__dict__.iteritems()]
23113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23114 
 
23115 
  def __eq__(self, other):
23116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23117 
 
23118 
  def __ne__(self, other):
23119 
    return not (self == other)
23120 
 
23121 
class getSnapdealSearchResultCount_args:
23122 
  """
23123 
  Attributes:
23124 
   - searchTerm
23125 
  """
23126 
 
23127 
  thrift_spec = (
23128 
    None, # 0
23129 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
23130 
  )
23131 
 
23132 
  def __init__(self, searchTerm=None,):
23133 
    self.searchTerm = searchTerm
23134 
 
23135 
  def read(self, iprot):
23136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23138 
      return
23139 
    iprot.readStructBegin()
23140 
    while True:
23141 
      (fname, ftype, fid) = iprot.readFieldBegin()
23142 
      if ftype == TType.STOP:
23143 
        break
23144 
      if fid == 1:
23145 
        if ftype == TType.LIST:
23146 
          self.searchTerm = []
23147 
          (_etype544, _size541) = iprot.readListBegin()
23148 
          for _i545 in xrange(_size541):
23149 
            _elem546 = iprot.readString();
23150 
            self.searchTerm.append(_elem546)
23151 
          iprot.readListEnd()
23152 
        else:
23153 
          iprot.skip(ftype)
23154 
      else:
23155 
        iprot.skip(ftype)
23156 
      iprot.readFieldEnd()
23157 
    iprot.readStructEnd()
23158 
 
23159 
  def write(self, oprot):
23160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23162 
      return
23163 
    oprot.writeStructBegin('getSnapdealSearchResultCount_args')
23164 
    if self.searchTerm is not None:
23165 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
23166 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
23167 
      for iter547 in self.searchTerm:
23168 
        oprot.writeString(iter547)
23169 
      oprot.writeListEnd()
23170 
      oprot.writeFieldEnd()
23171 
    oprot.writeFieldStop()
23172 
    oprot.writeStructEnd()
23173 
 
23174 
  def validate(self):
23175 
    return
23176 
 
23177 
 
23178 
  def __repr__(self):
23179 
    L = ['%s=%r' % (key, value)
23180 
      for key, value in self.__dict__.iteritems()]
23181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23182 
 
23183 
  def __eq__(self, other):
23184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23185 
 
23186 
  def __ne__(self, other):
23187 
    return not (self == other)
23188 
 
23189 
class getSnapdealSearchResultCount_result:
23190 
  """
23191 
  Attributes:
23192 
   - success
23193 
  """
23194 
 
23195 
  thrift_spec = (
23196 
    (0, TType.I64, 'success', None, None, ), # 0
23197 
  )
23198 
 
23199 
  def __init__(self, success=None,):
23200 
    self.success = success
23201 
 
23202 
  def read(self, iprot):
23203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23205 
      return
23206 
    iprot.readStructBegin()
23207 
    while True:
23208 
      (fname, ftype, fid) = iprot.readFieldBegin()
23209 
      if ftype == TType.STOP:
23210 
        break
23211 
      if fid == 0:
23212 
        if ftype == TType.I64:
23213 
          self.success = iprot.readI64();
23214 
        else:
23215 
          iprot.skip(ftype)
23216 
      else:
23217 
        iprot.skip(ftype)
23218 
      iprot.readFieldEnd()
23219 
    iprot.readStructEnd()
23220 
 
23221 
  def write(self, oprot):
23222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23224 
      return
23225 
    oprot.writeStructBegin('getSnapdealSearchResultCount_result')
23226 
    if self.success is not None:
23227 
      oprot.writeFieldBegin('success', TType.I64, 0)
23228 
      oprot.writeI64(self.success)
23229 
      oprot.writeFieldEnd()
23230 
    oprot.writeFieldStop()
23231 
    oprot.writeStructEnd()
23232 
 
23233 
  def validate(self):
23234 
    return
23235 
 
23236 
 
23237 
  def __repr__(self):
23238 
    L = ['%s=%r' % (key, value)
23239 
      for key, value in self.__dict__.iteritems()]
23240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23241 
 
23242 
  def __eq__(self, other):
23243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23244 
 
23245 
  def __ne__(self, other):
23246 
    return not (self == other)
9299 kshitij.so 23247 
 
23248 
class getPrefferedInsurerForItem_args:
23249 
  """
23250 
  Attributes:
23251 
   - itemId
23252 
   - insurerType
23253 
  """
23254 
 
23255 
  thrift_spec = (
23256 
    None, # 0
23257 
    (1, TType.I64, 'itemId', None, None, ), # 1
23258 
    (2, TType.I32, 'insurerType', None, None, ), # 2
23259 
  )
23260 
 
23261 
  def __init__(self, itemId=None, insurerType=None,):
23262 
    self.itemId = itemId
23263 
    self.insurerType = insurerType
23264 
 
23265 
  def read(self, iprot):
23266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23268 
      return
23269 
    iprot.readStructBegin()
23270 
    while True:
23271 
      (fname, ftype, fid) = iprot.readFieldBegin()
23272 
      if ftype == TType.STOP:
23273 
        break
23274 
      if fid == 1:
23275 
        if ftype == TType.I64:
23276 
          self.itemId = iprot.readI64();
23277 
        else:
23278 
          iprot.skip(ftype)
23279 
      elif fid == 2:
23280 
        if ftype == TType.I32:
23281 
          self.insurerType = iprot.readI32();
23282 
        else:
23283 
          iprot.skip(ftype)
23284 
      else:
23285 
        iprot.skip(ftype)
23286 
      iprot.readFieldEnd()
23287 
    iprot.readStructEnd()
23288 
 
23289 
  def write(self, oprot):
23290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23292 
      return
23293 
    oprot.writeStructBegin('getPrefferedInsurerForItem_args')
23294 
    if self.itemId is not None:
23295 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
23296 
      oprot.writeI64(self.itemId)
23297 
      oprot.writeFieldEnd()
23298 
    if self.insurerType is not None:
23299 
      oprot.writeFieldBegin('insurerType', TType.I32, 2)
23300 
      oprot.writeI32(self.insurerType)
23301 
      oprot.writeFieldEnd()
23302 
    oprot.writeFieldStop()
23303 
    oprot.writeStructEnd()
23304 
 
23305 
  def validate(self):
23306 
    return
23307 
 
23308 
 
23309 
  def __repr__(self):
23310 
    L = ['%s=%r' % (key, value)
23311 
      for key, value in self.__dict__.iteritems()]
23312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23313 
 
23314 
  def __eq__(self, other):
23315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23316 
 
23317 
  def __ne__(self, other):
23318 
    return not (self == other)
23319 
 
23320 
class getPrefferedInsurerForItem_result:
23321 
  """
23322 
  Attributes:
23323 
   - success
23324 
  """
23325 
 
23326 
  thrift_spec = (
23327 
    (0, TType.I64, 'success', None, None, ), # 0
23328 
  )
23329 
 
23330 
  def __init__(self, success=None,):
23331 
    self.success = success
23332 
 
23333 
  def read(self, iprot):
23334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23336 
      return
23337 
    iprot.readStructBegin()
23338 
    while True:
23339 
      (fname, ftype, fid) = iprot.readFieldBegin()
23340 
      if ftype == TType.STOP:
23341 
        break
23342 
      if fid == 0:
23343 
        if ftype == TType.I64:
23344 
          self.success = iprot.readI64();
23345 
        else:
23346 
          iprot.skip(ftype)
23347 
      else:
23348 
        iprot.skip(ftype)
23349 
      iprot.readFieldEnd()
23350 
    iprot.readStructEnd()
23351 
 
23352 
  def write(self, oprot):
23353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23355 
      return
23356 
    oprot.writeStructBegin('getPrefferedInsurerForItem_result')
23357 
    if self.success is not None:
23358 
      oprot.writeFieldBegin('success', TType.I64, 0)
23359 
      oprot.writeI64(self.success)
23360 
      oprot.writeFieldEnd()
23361 
    oprot.writeFieldStop()
23362 
    oprot.writeStructEnd()
23363 
 
23364 
  def validate(self):
23365 
    return
23366 
 
23367 
 
23368 
  def __repr__(self):
23369 
    L = ['%s=%r' % (key, value)
23370 
      for key, value in self.__dict__.iteritems()]
23371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23372 
 
23373 
  def __eq__(self, other):
23374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23375 
 
23376 
  def __ne__(self, other):
23377 
    return not (self == other)