Subversion Repositories SmartDukaan

Rev

Rev 8379 | Rev 8590 | 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 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    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.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
8579 kshitij.so 316 
  def addBanner(self, banner):
6850 kshitij.so 317 
    """
8579 kshitij.so 318 
    Banner Related
319 
 
6850 kshitij.so 320 
    Parameters:
8579 kshitij.so 321 
     - banner
6850 kshitij.so 322 
    """
323 
    pass
324 
 
8579 kshitij.so 325 
  def updateBanner(self, banner):
326 
    """
327 
    Parameters:
328 
     - banner
329 
    """
330 
    pass
331 
 
6850 kshitij.so 332 
  def getAllBanners(self, ):
333 
    pass
334 
 
335 
  def deleteBanner(self, bannerName):
336 
    """
337 
    Parameters:
338 
     - bannerName
339 
    """
340 
    pass
341 
 
342 
  def getBannerDetails(self, bannerName):
343 
    """
344 
    Parameters:
345 
     - bannerName
346 
    """
347 
    pass
348 
 
349 
  def getActiveBanners(self, ):
350 
    pass
351 
 
8579 kshitij.so 352 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 353 
    """
354 
    Parameters:
8579 kshitij.so 355 
     - bannerMaps
6849 kshitij.so 356 
    """
357 
    pass
358 
 
8579 kshitij.so 359 
  def updateBannerMap(self, bannerMap):
360 
    """
361 
    Parameters:
362 
     - bannerMap
363 
    """
364 
    pass
365 
 
6849 kshitij.so 366 
  def deleteBannerMap(self, bannerName):
367 
    """
368 
    Parameters:
369 
     - bannerName
370 
    """
371 
    pass
372 
 
373 
  def getBannerMapDetails(self, bannerName):
374 
    """
375 
    Parameters:
376 
     - bannerName
377 
    """
378 
    pass
379 
 
8579 kshitij.so 380 
  def addBannerUri(self, bannerUriMappings):
381 
    """
382 
    Parameters:
383 
     - bannerUriMappings
384 
    """
385 
    pass
386 
 
387 
  def getUriMapping(self, bannerName):
388 
    """
389 
    Parameters:
390 
     - bannerName
391 
    """
392 
    pass
393 
 
394 
  def addCampaign(self, campaign):
395 
    """
396 
    Parameters:
397 
     - campaign
398 
    """
399 
    pass
400 
 
401 
  def getCampaigns(self, campaignName):
402 
    """
403 
    Parameters:
404 
     - campaignName
405 
    """
406 
    pass
407 
 
408 
  def deleteCampaign(self, campaignId):
409 
    """
410 
    Parameters:
411 
     - campaignId
412 
    """
413 
    pass
414 
 
415 
  def getAllCampaigns(self, ):
416 
    pass
417 
 
5944 mandeep.dh 418 
  def deleteSimilarItem(self, itemId, catalogItemId):
419 
    """
420 
    Delete similar item.
421 
 
422 
    Parameters:
423 
     - itemId
424 
     - catalogItemId
425 
    """
426 
    pass
427 
 
428 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
429 
    """
430 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
431 
    If yes, returns the itemId else returns 0
432 
 
433 
    Parameters:
434 
     - brand
435 
     - modelNumber
436 
     - modelName
437 
     - color
438 
    """
439 
    pass
440 
 
441 
  def validateRiskyStatus(self, itemId):
442 
    """
443 
    Check wether item is risky and change status if inventory is not available for risky items
444 
 
445 
    Parameters:
446 
     - itemId
447 
    """
448 
    pass
449 
 
450 
  def changeItemRiskyFlag(self, itemId, risky):
451 
    """
452 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
453 
 
454 
    Parameters:
455 
     - itemId
456 
     - risky
457 
    """
458 
    pass
459 
 
460 
  def getItemsByRiskyFlag(self, ):
461 
    """
462 
    Returns list of items marked as risky.
463 
    """
464 
    pass
465 
 
466 
  def getItemsForMasterSheet(self, category, brand):
467 
    """
468 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
469 
 
470 
    Parameters:
471 
     - category
472 
     - brand
473 
    """
474 
    pass
475 
 
476 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
477 
    """
478 
    Returns list of catalog ids of items with same similarity index as of the given itemId
479 
 
480 
    Parameters:
481 
     - beginIndex
482 
     - totalItems
483 
     - itemId
484 
    """
485 
    pass
486 
 
487 
  def addProductNotification(self, itemId, email):
488 
    """
489 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
490 
 
491 
    Parameters:
492 
     - itemId
493 
     - email
494 
    """
495 
    pass
496 
 
497 
  def sendProductNotifications(self, ):
498 
    """
499 
    Send the product notifications to the users for items which has stock.
500 
    """
501 
    pass
502 
 
503 
  def getAllBrandsByCategory(self, categoryId):
504 
    """
505 
    Returns list of brand names for a given category Id
506 
 
507 
    Parameters:
508 
     - categoryId
509 
    """
510 
    pass
511 
 
512 
  def getAllBrands(self, ):
513 
    """
514 
    Returns list of brand names
515 
    """
516 
    pass
517 
 
518 
  def getAllSources(self, ):
519 
    """
520 
    Return list of all sources
521 
    """
522 
    pass
523 
 
524 
  def getItemPricingBySource(self, itemId, sourceId):
525 
    """
526 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
527 
 
528 
    Parameters:
529 
     - itemId
530 
     - sourceId
531 
    """
532 
    pass
533 
 
534 
  def addSourceItemPricing(self, sourceItemPricing):
535 
    """
536 
    Adds prices to be displayed corresponding to the item if user comes from a source.
537 
    If item is not found or source is not found, it will throw exception.
538 
 
539 
    Parameters:
540 
     - sourceItemPricing
541 
    """
542 
    pass
543 
 
544 
  def getAllSourcePricing(self, itemId):
545 
    """
546 
    Returns the list of source pricing information of an item.
547 
    Raises an exception if item not found corresponding to itemId
548 
 
549 
    Parameters:
550 
     - itemId
551 
    """
552 
    pass
553 
 
554 
  def getItemForSource(self, item_id, sourceId):
555 
    """
556 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
557 
 
558 
    Parameters:
559 
     - item_id
560 
     - sourceId
561 
    """
562 
    pass
563 
 
564 
  def searchItemsInRange(self, searchTerms, offset, limit):
565 
    """
566 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
567 
 
568 
    Parameters:
569 
     - searchTerms
570 
     - offset
571 
     - limit
572 
    """
573 
    pass
574 
 
575 
  def getSearchResultCount(self, searchTerms):
576 
    """
577 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
578 
 
579 
    Parameters:
580 
     - searchTerms
581 
    """
582 
    pass
583 
 
584 
  def getProductNotifications(self, startDateTime):
585 
    """
586 
    Returns a list of product notifications added after a supplied datetime
587 
 
588 
    Parameters:
589 
     - startDateTime
590 
    """
591 
    pass
592 
 
7897 amar.kumar 593 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 594 
    """
595 
    Returns a list of count of requests for product notification against each item
596 
 
597 
    Parameters:
598 
     - startDateTime
7897 amar.kumar 599 
     - categoryId
5944 mandeep.dh 600 
    """
601 
    pass
602 
 
603 
  def addAuthorizationLog(self, itemId, username, reason):
604 
    """
605 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
606 
 
607 
    Parameters:
608 
     - itemId
609 
     - username
610 
     - reason
611 
    """
612 
    pass
613 
 
614 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
615 
    """
616 
    Parameters:
617 
     - catalog_item_id
618 
     - voucherType
619 
     - voucherAmount
620 
    """
621 
    pass
622 
 
623 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
624 
    """
625 
    Parameters:
626 
     - catalog_item_id
627 
     - voucherType
628 
    """
629 
    pass
630 
 
631 
  def getVoucherAmount(self, itemId, voucherType):
632 
    """
633 
    Parameters:
634 
     - itemId
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getAllItemVouchers(self, itemId):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
    """
644 
    pass
645 
 
646 
  def isValidCatalogItemId(self, catalog_item_id):
647 
    """
648 
    Parameters:
649 
     - catalog_item_id
650 
    """
651 
    pass
652 
 
7330 amit.gupta 653 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 654 
    """
655 
    Parameters:
656 
     - itemId
7330 amit.gupta 657 
     - stateId
6039 amit.gupta 658 
     - price
659 
    """
660 
    pass
5944 mandeep.dh 661 
 
6039 amit.gupta 662 
  def getVatAmountForItem(self, itemId, price):
663 
    """
664 
    Parameters:
665 
     - itemId
666 
     - price
667 
    """
668 
    pass
669 
 
6531 vikram.rag 670 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
671 
    """
672 
    Parameters:
673 
     - offset
674 
     - limit
675 
    """
676 
    pass
6039 amit.gupta 677 
 
6821 amar.kumar 678 
  def getAllAliveItems(self, ):
679 
    pass
680 
 
6921 anupam.sin 681 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 682 
    """
683 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 684 
 
6805 anupam.sin 685 
    Parameters:
686 
     - itemId
6921 anupam.sin 687 
     - price
6805 anupam.sin 688 
     - insurerId
689 
     - quantity
690 
    """
691 
    pass
692 
 
693 
  def getInsurer(self, insurerId):
694 
    """
695 
    Parameters:
696 
     - insurerId
697 
    """
698 
    pass
699 
 
6838 vikram.rag 700 
  def getAllInsurers(self, ):
701 
    pass
6805 anupam.sin 702 
 
6962 rajveer 703 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
704 
    """
705 
    Parameters:
706 
     - insurerId
707 
     - amount
708 
    """
709 
    pass
6838 vikram.rag 710 
 
7190 amar.kumar 711 
  def getFreebieForItem(self, itemId):
712 
    """
713 
    Parameters:
714 
     - itemId
715 
    """
716 
    pass
6962 rajveer 717 
 
7190 amar.kumar 718 
  def addOrUpdateFreebieForItem(self, freebieItem):
719 
    """
720 
    Parameters:
721 
     - freebieItem
722 
    """
723 
    pass
724 
 
7272 amit.gupta 725 
  def addOrUpdateBrandInfo(self, brandInfo):
726 
    """
727 
    Parameters:
728 
     - brandInfo
729 
    """
730 
    pass
731 
 
732 
  def getBrandInfo(self, ):
733 
    pass
734 
 
7256 rajveer 735 
  def getStorePricing(self, itemId):
736 
    """
737 
    Parameters:
738 
     - itemId
739 
    """
740 
    pass
7190 amar.kumar 741 
 
7306 rajveer 742 
  def getStorePricings(self, itemIds):
743 
    """
744 
    Parameters:
745 
     - itemIds
746 
    """
747 
    pass
748 
 
7382 rajveer 749 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 750 
    """
751 
    Parameters:
752 
     - sp
7382 rajveer 753 
     - allColors
7265 rajveer 754 
    """
755 
    pass
7256 rajveer 756 
 
7281 kshitij.so 757 
  def getAllAmazonListedItems(self, ):
758 
    pass
7265 rajveer 759 
 
7281 kshitij.so 760 
  def getAmazonItemDetails(self, itemId):
761 
    """
762 
    Parameters:
763 
     - itemId
764 
    """
765 
    pass
766 
 
8168 kshitij.so 767 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 768 
    """
769 
    Parameters:
8168 kshitij.so 770 
     - amazonlisted
7281 kshitij.so 771 
    """
772 
    pass
773 
 
774 
  def addAmazonItem(self, amazonlisted):
775 
    """
776 
    Parameters:
777 
     - amazonlisted
778 
    """
779 
    pass
780 
 
7291 vikram.rag 781 
  def getAsinItems(self, ):
782 
    pass
7281 kshitij.so 783 
 
7291 vikram.rag 784 
  def getAllFbaListedItems(self, ):
785 
    pass
786 
 
787 
  def getAllNonFbaListedItems(self, ):
788 
    pass
789 
 
7460 kshitij.so 790 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
791 
    """
792 
    Parameters:
793 
     - itemId
794 
     - holdInventory
795 
     - defaultInventory
796 
    """
797 
    pass
7291 vikram.rag 798 
 
7770 kshitij.so 799 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
800 
    """
801 
    Parameters:
802 
     - type
803 
     - sku
804 
     - timestamp
805 
    """
806 
    pass
7460 kshitij.so 807 
 
7897 amar.kumar 808 
  def getAllParentCategories(self, ):
809 
    pass
7770 kshitij.so 810 
 
7977 kshitij.so 811 
  def addPageViewEvent(self, pageViewEvents):
812 
    """
813 
    Parameters:
814 
     - pageViewEvents
815 
    """
816 
    pass
7897 amar.kumar 817 
 
7977 kshitij.so 818 
  def addCartEvent(self, cartEvents):
819 
    """
820 
    Parameters:
821 
     - cartEvents
822 
    """
823 
    pass
824 
 
8182 amar.kumar 825 
  def addEbayItem(self, ebayItem):
826 
    """
827 
    Parameters:
828 
     - ebayItem
829 
    """
830 
    pass
831 
 
832 
  def getEbayItem(self, listingId):
833 
    """
834 
    Parameters:
835 
     - listingId
836 
    """
837 
    pass
838 
 
839 
  def updateEbayItem(self, ebayItem):
840 
    """
841 
    Parameters:
842 
     - ebayItem
843 
    """
844 
    pass
845 
 
8139 kshitij.so 846 
  def getAmazonListedItems(self, offset, limit):
847 
    """
848 
    Parameters:
849 
     - offset
850 
     - limit
851 
    """
852 
    pass
7977 kshitij.so 853 
 
8168 kshitij.so 854 
  def updateAmazonAttributesInBulk(self, amazonlisted):
855 
    """
856 
    Parameters:
857 
     - amazonlisted
858 
    """
859 
    pass
8139 kshitij.so 860 
 
8379 vikram.rag 861 
  def getAllItemstoListOnFba(self, ):
862 
    pass
8168 kshitij.so 863 
 
8379 vikram.rag 864 
  def getAllItemstoListOnNonFba(self, ):
865 
    pass
866 
 
867 
 
5944 mandeep.dh 868 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
869 
  def __init__(self, iprot, oprot=None):
870 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
871 
 
872 
  def addItem(self, item):
873 
    """
874 
    Availability and inventory attributes
875 
 
876 
    Parameters:
877 
     - item
878 
    """
879 
    self.send_addItem(item)
880 
    return self.recv_addItem()
881 
 
882 
  def send_addItem(self, item):
883 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
884 
    args = addItem_args()
885 
    args.item = item
886 
    args.write(self._oprot)
887 
    self._oprot.writeMessageEnd()
888 
    self._oprot.trans.flush()
889 
 
890 
  def recv_addItem(self, ):
891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
892 
    if mtype == TMessageType.EXCEPTION:
893 
      x = TApplicationException()
894 
      x.read(self._iprot)
895 
      self._iprot.readMessageEnd()
896 
      raise x
897 
    result = addItem_result()
898 
    result.read(self._iprot)
899 
    self._iprot.readMessageEnd()
900 
    if result.success is not None:
901 
      return result.success
902 
    if result.cex is not None:
903 
      raise result.cex
904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
905 
 
906 
  def updateItem(self, item):
907 
    """
908 
    Parameters:
909 
     - item
910 
    """
911 
    self.send_updateItem(item)
912 
    return self.recv_updateItem()
913 
 
914 
  def send_updateItem(self, item):
915 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
916 
    args = updateItem_args()
917 
    args.item = item
918 
    args.write(self._oprot)
919 
    self._oprot.writeMessageEnd()
920 
    self._oprot.trans.flush()
921 
 
922 
  def recv_updateItem(self, ):
923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
924 
    if mtype == TMessageType.EXCEPTION:
925 
      x = TApplicationException()
926 
      x.read(self._iprot)
927 
      self._iprot.readMessageEnd()
928 
      raise x
929 
    result = updateItem_result()
930 
    result.read(self._iprot)
931 
    self._iprot.readMessageEnd()
932 
    if result.success is not None:
933 
      return result.success
934 
    if result.cex is not None:
935 
      raise result.cex
936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
937 
 
938 
  def isActive(self, itemId):
939 
    """
940 
    Checks if the item given to the corresponding itemId is active. If it's active,
941 
    whether it's risky and if it's risky, its inventory position.
942 
 
943 
    Parameters:
944 
     - itemId
945 
    """
946 
    self.send_isActive(itemId)
947 
    return self.recv_isActive()
948 
 
949 
  def send_isActive(self, itemId):
950 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
951 
    args = isActive_args()
952 
    args.itemId = itemId
953 
    args.write(self._oprot)
954 
    self._oprot.writeMessageEnd()
955 
    self._oprot.trans.flush()
956 
 
957 
  def recv_isActive(self, ):
958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
959 
    if mtype == TMessageType.EXCEPTION:
960 
      x = TApplicationException()
961 
      x.read(self._iprot)
962 
      self._iprot.readMessageEnd()
963 
      raise x
964 
    result = isActive_result()
965 
    result.read(self._iprot)
966 
    self._iprot.readMessageEnd()
967 
    if result.success is not None:
968 
      return result.success
969 
    if result.isex is not None:
970 
      raise result.isex
971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
972 
 
7438 amit.gupta 973 
  def getItemsStatus(self, itemIds):
974 
    """
975 
    Parameters:
976 
     - itemIds
977 
    """
978 
    self.send_getItemsStatus(itemIds)
979 
    return self.recv_getItemsStatus()
980 
 
981 
  def send_getItemsStatus(self, itemIds):
982 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
983 
    args = getItemsStatus_args()
984 
    args.itemIds = itemIds
985 
    args.write(self._oprot)
986 
    self._oprot.writeMessageEnd()
987 
    self._oprot.trans.flush()
988 
 
989 
  def recv_getItemsStatus(self, ):
990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
991 
    if mtype == TMessageType.EXCEPTION:
992 
      x = TApplicationException()
993 
      x.read(self._iprot)
994 
      self._iprot.readMessageEnd()
995 
      raise x
996 
    result = getItemsStatus_result()
997 
    result.read(self._iprot)
998 
    self._iprot.readMessageEnd()
999 
    if result.success is not None:
1000 
      return result.success
1001 
    if result.isex is not None:
1002 
      raise result.isex
1003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1004 
 
5944 mandeep.dh 1005 
  def getItemStatusDescription(self, itemId):
1006 
    """
1007 
    Parameters:
1008 
     - itemId
1009 
    """
1010 
    self.send_getItemStatusDescription(itemId)
1011 
    return self.recv_getItemStatusDescription()
1012 
 
1013 
  def send_getItemStatusDescription(self, itemId):
1014 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1015 
    args = getItemStatusDescription_args()
1016 
    args.itemId = itemId
1017 
    args.write(self._oprot)
1018 
    self._oprot.writeMessageEnd()
1019 
    self._oprot.trans.flush()
1020 
 
1021 
  def recv_getItemStatusDescription(self, ):
1022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1023 
    if mtype == TMessageType.EXCEPTION:
1024 
      x = TApplicationException()
1025 
      x.read(self._iprot)
1026 
      self._iprot.readMessageEnd()
1027 
      raise x
1028 
    result = getItemStatusDescription_result()
1029 
    result.read(self._iprot)
1030 
    self._iprot.readMessageEnd()
1031 
    if result.success is not None:
1032 
      return result.success
1033 
    if result.isex is not None:
1034 
      raise result.isex
1035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1036 
 
1037 
  def startItemOn(self, item_id, timestamp):
1038 
    """
1039 
    Parameters:
1040 
     - item_id
1041 
     - timestamp
1042 
    """
1043 
    self.send_startItemOn(item_id, timestamp)
1044 
    self.recv_startItemOn()
1045 
 
1046 
  def send_startItemOn(self, item_id, timestamp):
1047 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1048 
    args = startItemOn_args()
1049 
    args.item_id = item_id
1050 
    args.timestamp = timestamp
1051 
    args.write(self._oprot)
1052 
    self._oprot.writeMessageEnd()
1053 
    self._oprot.trans.flush()
1054 
 
1055 
  def recv_startItemOn(self, ):
1056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1057 
    if mtype == TMessageType.EXCEPTION:
1058 
      x = TApplicationException()
1059 
      x.read(self._iprot)
1060 
      self._iprot.readMessageEnd()
1061 
      raise x
1062 
    result = startItemOn_result()
1063 
    result.read(self._iprot)
1064 
    self._iprot.readMessageEnd()
1065 
    if result.cex is not None:
1066 
      raise result.cex
1067 
    return
1068 
 
1069 
  def retireItemOn(self, item_id, timestamp):
1070 
    """
1071 
    Parameters:
1072 
     - item_id
1073 
     - timestamp
1074 
    """
1075 
    self.send_retireItemOn(item_id, timestamp)
1076 
    self.recv_retireItemOn()
1077 
 
1078 
  def send_retireItemOn(self, item_id, timestamp):
1079 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1080 
    args = retireItemOn_args()
1081 
    args.item_id = item_id
1082 
    args.timestamp = timestamp
1083 
    args.write(self._oprot)
1084 
    self._oprot.writeMessageEnd()
1085 
    self._oprot.trans.flush()
1086 
 
1087 
  def recv_retireItemOn(self, ):
1088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1089 
    if mtype == TMessageType.EXCEPTION:
1090 
      x = TApplicationException()
1091 
      x.read(self._iprot)
1092 
      self._iprot.readMessageEnd()
1093 
      raise x
1094 
    result = retireItemOn_result()
1095 
    result.read(self._iprot)
1096 
    self._iprot.readMessageEnd()
1097 
    if result.cex is not None:
1098 
      raise result.cex
1099 
    return
1100 
 
1101 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1102 
    """
1103 
    Parameters:
1104 
     - item_id
1105 
     - timestamp
1106 
     - newstatus
1107 
    """
1108 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1109 
    self.recv_changeItemStatus()
1110 
 
1111 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1112 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1113 
    args = changeItemStatus_args()
1114 
    args.item_id = item_id
1115 
    args.timestamp = timestamp
1116 
    args.newstatus = newstatus
1117 
    args.write(self._oprot)
1118 
    self._oprot.writeMessageEnd()
1119 
    self._oprot.trans.flush()
1120 
 
1121 
  def recv_changeItemStatus(self, ):
1122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1123 
    if mtype == TMessageType.EXCEPTION:
1124 
      x = TApplicationException()
1125 
      x.read(self._iprot)
1126 
      self._iprot.readMessageEnd()
1127 
      raise x
1128 
    result = changeItemStatus_result()
1129 
    result.read(self._iprot)
1130 
    self._iprot.readMessageEnd()
1131 
    if result.cex is not None:
1132 
      raise result.cex
1133 
    return
1134 
 
1135 
  def getItem(self, item_id):
1136 
    """
1137 
    Parameters:
1138 
     - item_id
1139 
    """
1140 
    self.send_getItem(item_id)
1141 
    return self.recv_getItem()
1142 
 
1143 
  def send_getItem(self, item_id):
1144 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1145 
    args = getItem_args()
1146 
    args.item_id = item_id
1147 
    args.write(self._oprot)
1148 
    self._oprot.writeMessageEnd()
1149 
    self._oprot.trans.flush()
1150 
 
1151 
  def recv_getItem(self, ):
1152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1153 
    if mtype == TMessageType.EXCEPTION:
1154 
      x = TApplicationException()
1155 
      x.read(self._iprot)
1156 
      self._iprot.readMessageEnd()
1157 
      raise x
1158 
    result = getItem_result()
1159 
    result.read(self._iprot)
1160 
    self._iprot.readMessageEnd()
1161 
    if result.success is not None:
1162 
      return result.success
1163 
    if result.cex is not None:
1164 
      raise result.cex
1165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1166 
 
1167 
  def getItemsByCatalogId(self, catalog_item_id):
1168 
    """
1169 
    Parameters:
1170 
     - catalog_item_id
1171 
    """
1172 
    self.send_getItemsByCatalogId(catalog_item_id)
1173 
    return self.recv_getItemsByCatalogId()
1174 
 
1175 
  def send_getItemsByCatalogId(self, catalog_item_id):
1176 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1177 
    args = getItemsByCatalogId_args()
1178 
    args.catalog_item_id = catalog_item_id
1179 
    args.write(self._oprot)
1180 
    self._oprot.writeMessageEnd()
1181 
    self._oprot.trans.flush()
1182 
 
1183 
  def recv_getItemsByCatalogId(self, ):
1184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1185 
    if mtype == TMessageType.EXCEPTION:
1186 
      x = TApplicationException()
1187 
      x.read(self._iprot)
1188 
      self._iprot.readMessageEnd()
1189 
      raise x
1190 
    result = getItemsByCatalogId_result()
1191 
    result.read(self._iprot)
1192 
    self._iprot.readMessageEnd()
1193 
    if result.success is not None:
1194 
      return result.success
1195 
    if result.cex is not None:
1196 
      raise result.cex
1197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1198 
 
1199 
  def getValidItemsByCatalogId(self, catalog_item_id):
1200 
    """
1201 
    Parameters:
1202 
     - catalog_item_id
1203 
    """
1204 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1205 
    return self.recv_getValidItemsByCatalogId()
1206 
 
1207 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1208 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1209 
    args = getValidItemsByCatalogId_args()
1210 
    args.catalog_item_id = catalog_item_id
1211 
    args.write(self._oprot)
1212 
    self._oprot.writeMessageEnd()
1213 
    self._oprot.trans.flush()
1214 
 
1215 
  def recv_getValidItemsByCatalogId(self, ):
1216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1217 
    if mtype == TMessageType.EXCEPTION:
1218 
      x = TApplicationException()
1219 
      x.read(self._iprot)
1220 
      self._iprot.readMessageEnd()
1221 
      raise x
1222 
    result = getValidItemsByCatalogId_result()
1223 
    result.read(self._iprot)
1224 
    self._iprot.readMessageEnd()
1225 
    if result.success is not None:
1226 
      return result.success
1227 
    if result.cex is not None:
1228 
      raise result.cex
1229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1230 
 
1231 
  def getAllItems(self, isActive):
1232 
    """
1233 
    Parameters:
1234 
     - isActive
1235 
    """
1236 
    self.send_getAllItems(isActive)
1237 
    return self.recv_getAllItems()
1238 
 
1239 
  def send_getAllItems(self, isActive):
1240 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1241 
    args = getAllItems_args()
1242 
    args.isActive = isActive
1243 
    args.write(self._oprot)
1244 
    self._oprot.writeMessageEnd()
1245 
    self._oprot.trans.flush()
1246 
 
1247 
  def recv_getAllItems(self, ):
1248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1249 
    if mtype == TMessageType.EXCEPTION:
1250 
      x = TApplicationException()
1251 
      x.read(self._iprot)
1252 
      self._iprot.readMessageEnd()
1253 
      raise x
1254 
    result = getAllItems_result()
1255 
    result.read(self._iprot)
1256 
    self._iprot.readMessageEnd()
1257 
    if result.success is not None:
1258 
      return result.success
1259 
    if result.cex is not None:
1260 
      raise result.cex
1261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1262 
 
1263 
  def getAllItemsByStatus(self, itemStatus):
1264 
    """
1265 
    Parameters:
1266 
     - itemStatus
1267 
    """
1268 
    self.send_getAllItemsByStatus(itemStatus)
1269 
    return self.recv_getAllItemsByStatus()
1270 
 
1271 
  def send_getAllItemsByStatus(self, itemStatus):
1272 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1273 
    args = getAllItemsByStatus_args()
1274 
    args.itemStatus = itemStatus
1275 
    args.write(self._oprot)
1276 
    self._oprot.writeMessageEnd()
1277 
    self._oprot.trans.flush()
1278 
 
1279 
  def recv_getAllItemsByStatus(self, ):
1280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1281 
    if mtype == TMessageType.EXCEPTION:
1282 
      x = TApplicationException()
1283 
      x.read(self._iprot)
1284 
      self._iprot.readMessageEnd()
1285 
      raise x
1286 
    result = getAllItemsByStatus_result()
1287 
    result.read(self._iprot)
1288 
    self._iprot.readMessageEnd()
1289 
    if result.success is not None:
1290 
      return result.success
1291 
    if result.cex is not None:
1292 
      raise result.cex
1293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1294 
 
1295 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1296 
    """
1297 
    Parameters:
1298 
     - entityId
1299 
     - category
1300 
     - brand
1301 
     - modelName
1302 
     - modelNumber
1303 
    """
1304 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1305 
    return self.recv_markItemAsContentComplete()
1306 
 
1307 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1308 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1309 
    args = markItemAsContentComplete_args()
1310 
    args.entityId = entityId
1311 
    args.category = category
1312 
    args.brand = brand
1313 
    args.modelName = modelName
1314 
    args.modelNumber = modelNumber
1315 
    args.write(self._oprot)
1316 
    self._oprot.writeMessageEnd()
1317 
    self._oprot.trans.flush()
1318 
 
1319 
  def recv_markItemAsContentComplete(self, ):
1320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1321 
    if mtype == TMessageType.EXCEPTION:
1322 
      x = TApplicationException()
1323 
      x.read(self._iprot)
1324 
      self._iprot.readMessageEnd()
1325 
      raise x
1326 
    result = markItemAsContentComplete_result()
1327 
    result.read(self._iprot)
1328 
    self._iprot.readMessageEnd()
1329 
    if result.success is not None:
1330 
      return result.success
1331 
    if result.cex is not None:
1332 
      raise result.cex
1333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1334 
 
1335 
  def getAllItemsInRange(self, offset, limit):
1336 
    """
1337 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1338 
 
1339 
    Parameters:
1340 
     - offset
1341 
     - limit
1342 
    """
1343 
    self.send_getAllItemsInRange(offset, limit)
1344 
    return self.recv_getAllItemsInRange()
1345 
 
1346 
  def send_getAllItemsInRange(self, offset, limit):
1347 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1348 
    args = getAllItemsInRange_args()
1349 
    args.offset = offset
1350 
    args.limit = limit
1351 
    args.write(self._oprot)
1352 
    self._oprot.writeMessageEnd()
1353 
    self._oprot.trans.flush()
1354 
 
1355 
  def recv_getAllItemsInRange(self, ):
1356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1357 
    if mtype == TMessageType.EXCEPTION:
1358 
      x = TApplicationException()
1359 
      x.read(self._iprot)
1360 
      self._iprot.readMessageEnd()
1361 
      raise x
1362 
    result = getAllItemsInRange_result()
1363 
    result.read(self._iprot)
1364 
    self._iprot.readMessageEnd()
1365 
    if result.success is not None:
1366 
      return result.success
1367 
    if result.cex is not None:
1368 
      raise result.cex
1369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1370 
 
1371 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1372 
    """
1373 
    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.
1374 
 
1375 
    Parameters:
1376 
     - itemStatus
1377 
     - offset
1378 
     - limit
1379 
    """
1380 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1381 
    return self.recv_getAllItemsByStatusInRange()
1382 
 
1383 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1384 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1385 
    args = getAllItemsByStatusInRange_args()
1386 
    args.itemStatus = itemStatus
1387 
    args.offset = offset
1388 
    args.limit = limit
1389 
    args.write(self._oprot)
1390 
    self._oprot.writeMessageEnd()
1391 
    self._oprot.trans.flush()
1392 
 
1393 
  def recv_getAllItemsByStatusInRange(self, ):
1394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1395 
    if mtype == TMessageType.EXCEPTION:
1396 
      x = TApplicationException()
1397 
      x.read(self._iprot)
1398 
      self._iprot.readMessageEnd()
1399 
      raise x
1400 
    result = getAllItemsByStatusInRange_result()
1401 
    result.read(self._iprot)
1402 
    self._iprot.readMessageEnd()
1403 
    if result.success is not None:
1404 
      return result.success
1405 
    if result.cex is not None:
1406 
      raise result.cex
1407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1408 
 
1409 
  def getItemCountByStatus(self, useStatus, itemStatus):
1410 
    """
1411 
    Gets a count of all items by status
1412 
 
1413 
    Parameters:
1414 
     - useStatus
1415 
     - itemStatus
1416 
    """
1417 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1418 
    return self.recv_getItemCountByStatus()
1419 
 
1420 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1421 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1422 
    args = getItemCountByStatus_args()
1423 
    args.useStatus = useStatus
1424 
    args.itemStatus = itemStatus
1425 
    args.write(self._oprot)
1426 
    self._oprot.writeMessageEnd()
1427 
    self._oprot.trans.flush()
1428 
 
1429 
  def recv_getItemCountByStatus(self, ):
1430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1431 
    if mtype == TMessageType.EXCEPTION:
1432 
      x = TApplicationException()
1433 
      x.read(self._iprot)
1434 
      self._iprot.readMessageEnd()
1435 
      raise x
1436 
    result = getItemCountByStatus_result()
1437 
    result.read(self._iprot)
1438 
    self._iprot.readMessageEnd()
1439 
    if result.success is not None:
1440 
      return result.success
1441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1442 
 
1443 
  def getBestSellers(self, ):
1444 
    self.send_getBestSellers()
1445 
    return self.recv_getBestSellers()
1446 
 
1447 
  def send_getBestSellers(self, ):
1448 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1449 
    args = getBestSellers_args()
1450 
    args.write(self._oprot)
1451 
    self._oprot.writeMessageEnd()
1452 
    self._oprot.trans.flush()
1453 
 
1454 
  def recv_getBestSellers(self, ):
1455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1456 
    if mtype == TMessageType.EXCEPTION:
1457 
      x = TApplicationException()
1458 
      x.read(self._iprot)
1459 
      self._iprot.readMessageEnd()
1460 
      raise x
1461 
    result = getBestSellers_result()
1462 
    result.read(self._iprot)
1463 
    self._iprot.readMessageEnd()
1464 
    if result.success is not None:
1465 
      return result.success
1466 
    if result.isex is not None:
1467 
      raise result.isex
1468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1469 
 
1470 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1471 
    """
1472 
    Parameters:
1473 
     - beginIndex
1474 
     - totalItems
1475 
     - brand
1476 
     - category
1477 
    """
1478 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1479 
    return self.recv_getBestSellersCatalogIds()
1480 
 
1481 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1482 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1483 
    args = getBestSellersCatalogIds_args()
1484 
    args.beginIndex = beginIndex
1485 
    args.totalItems = totalItems
1486 
    args.brand = brand
1487 
    args.category = category
1488 
    args.write(self._oprot)
1489 
    self._oprot.writeMessageEnd()
1490 
    self._oprot.trans.flush()
1491 
 
1492 
  def recv_getBestSellersCatalogIds(self, ):
1493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1494 
    if mtype == TMessageType.EXCEPTION:
1495 
      x = TApplicationException()
1496 
      x.read(self._iprot)
1497 
      self._iprot.readMessageEnd()
1498 
      raise x
1499 
    result = getBestSellersCatalogIds_result()
1500 
    result.read(self._iprot)
1501 
    self._iprot.readMessageEnd()
1502 
    if result.success is not None:
1503 
      return result.success
1504 
    if result.cex is not None:
1505 
      raise result.cex
1506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1507 
 
1508 
  def getBestSellersCount(self, ):
1509 
    self.send_getBestSellersCount()
1510 
    return self.recv_getBestSellersCount()
1511 
 
1512 
  def send_getBestSellersCount(self, ):
1513 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1514 
    args = getBestSellersCount_args()
1515 
    args.write(self._oprot)
1516 
    self._oprot.writeMessageEnd()
1517 
    self._oprot.trans.flush()
1518 
 
1519 
  def recv_getBestSellersCount(self, ):
1520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1521 
    if mtype == TMessageType.EXCEPTION:
1522 
      x = TApplicationException()
1523 
      x.read(self._iprot)
1524 
      self._iprot.readMessageEnd()
1525 
      raise x
1526 
    result = getBestSellersCount_result()
1527 
    result.read(self._iprot)
1528 
    self._iprot.readMessageEnd()
1529 
    if result.success is not None:
1530 
      return result.success
1531 
    if result.cex is not None:
1532 
      raise result.cex
1533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1534 
 
1535 
  def getBestDeals(self, ):
1536 
    self.send_getBestDeals()
1537 
    return self.recv_getBestDeals()
1538 
 
1539 
  def send_getBestDeals(self, ):
1540 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1541 
    args = getBestDeals_args()
1542 
    args.write(self._oprot)
1543 
    self._oprot.writeMessageEnd()
1544 
    self._oprot.trans.flush()
1545 
 
1546 
  def recv_getBestDeals(self, ):
1547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1548 
    if mtype == TMessageType.EXCEPTION:
1549 
      x = TApplicationException()
1550 
      x.read(self._iprot)
1551 
      self._iprot.readMessageEnd()
1552 
      raise x
1553 
    result = getBestDeals_result()
1554 
    result.read(self._iprot)
1555 
    self._iprot.readMessageEnd()
1556 
    if result.success is not None:
1557 
      return result.success
1558 
    if result.isex is not None:
1559 
      raise result.isex
1560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1561 
 
1562 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1563 
    """
1564 
    Parameters:
1565 
     - beginIndex
1566 
     - totalItems
1567 
     - brand
1568 
     - category
1569 
    """
1570 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1571 
    return self.recv_getBestDealsCatalogIds()
1572 
 
1573 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1574 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1575 
    args = getBestDealsCatalogIds_args()
1576 
    args.beginIndex = beginIndex
1577 
    args.totalItems = totalItems
1578 
    args.brand = brand
1579 
    args.category = category
1580 
    args.write(self._oprot)
1581 
    self._oprot.writeMessageEnd()
1582 
    self._oprot.trans.flush()
1583 
 
1584 
  def recv_getBestDealsCatalogIds(self, ):
1585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1586 
    if mtype == TMessageType.EXCEPTION:
1587 
      x = TApplicationException()
1588 
      x.read(self._iprot)
1589 
      self._iprot.readMessageEnd()
1590 
      raise x
1591 
    result = getBestDealsCatalogIds_result()
1592 
    result.read(self._iprot)
1593 
    self._iprot.readMessageEnd()
1594 
    if result.success is not None:
1595 
      return result.success
1596 
    if result.cex is not None:
1597 
      raise result.cex
1598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1599 
 
1600 
  def getBestDealsCount(self, ):
1601 
    self.send_getBestDealsCount()
1602 
    return self.recv_getBestDealsCount()
1603 
 
1604 
  def send_getBestDealsCount(self, ):
1605 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1606 
    args = getBestDealsCount_args()
1607 
    args.write(self._oprot)
1608 
    self._oprot.writeMessageEnd()
1609 
    self._oprot.trans.flush()
1610 
 
1611 
  def recv_getBestDealsCount(self, ):
1612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1613 
    if mtype == TMessageType.EXCEPTION:
1614 
      x = TApplicationException()
1615 
      x.read(self._iprot)
1616 
      self._iprot.readMessageEnd()
1617 
      raise x
1618 
    result = getBestDealsCount_result()
1619 
    result.read(self._iprot)
1620 
    self._iprot.readMessageEnd()
1621 
    if result.success is not None:
1622 
      return result.success
1623 
    if result.cex is not None:
1624 
      raise result.cex
1625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1626 
 
1627 
  def getComingSoon(self, ):
1628 
    self.send_getComingSoon()
1629 
    return self.recv_getComingSoon()
1630 
 
1631 
  def send_getComingSoon(self, ):
1632 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1633 
    args = getComingSoon_args()
1634 
    args.write(self._oprot)
1635 
    self._oprot.writeMessageEnd()
1636 
    self._oprot.trans.flush()
1637 
 
1638 
  def recv_getComingSoon(self, ):
1639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1640 
    if mtype == TMessageType.EXCEPTION:
1641 
      x = TApplicationException()
1642 
      x.read(self._iprot)
1643 
      self._iprot.readMessageEnd()
1644 
      raise x
1645 
    result = getComingSoon_result()
1646 
    result.read(self._iprot)
1647 
    self._iprot.readMessageEnd()
1648 
    if result.success is not None:
1649 
      return result.success
1650 
    if result.isex is not None:
1651 
      raise result.isex
1652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1653 
 
1654 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1655 
    """
1656 
    Parameters:
1657 
     - beginIndex
1658 
     - totalItems
1659 
     - brand
1660 
     - category
1661 
    """
1662 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1663 
    return self.recv_getComingSoonCatalogIds()
1664 
 
1665 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1666 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1667 
    args = getComingSoonCatalogIds_args()
1668 
    args.beginIndex = beginIndex
1669 
    args.totalItems = totalItems
1670 
    args.brand = brand
1671 
    args.category = category
1672 
    args.write(self._oprot)
1673 
    self._oprot.writeMessageEnd()
1674 
    self._oprot.trans.flush()
1675 
 
1676 
  def recv_getComingSoonCatalogIds(self, ):
1677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1678 
    if mtype == TMessageType.EXCEPTION:
1679 
      x = TApplicationException()
1680 
      x.read(self._iprot)
1681 
      self._iprot.readMessageEnd()
1682 
      raise x
1683 
    result = getComingSoonCatalogIds_result()
1684 
    result.read(self._iprot)
1685 
    self._iprot.readMessageEnd()
1686 
    if result.success is not None:
1687 
      return result.success
1688 
    if result.cex is not None:
1689 
      raise result.cex
1690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1691 
 
1692 
  def getComingSoonCount(self, ):
1693 
    self.send_getComingSoonCount()
1694 
    return self.recv_getComingSoonCount()
1695 
 
1696 
  def send_getComingSoonCount(self, ):
1697 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1698 
    args = getComingSoonCount_args()
1699 
    args.write(self._oprot)
1700 
    self._oprot.writeMessageEnd()
1701 
    self._oprot.trans.flush()
1702 
 
1703 
  def recv_getComingSoonCount(self, ):
1704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1705 
    if mtype == TMessageType.EXCEPTION:
1706 
      x = TApplicationException()
1707 
      x.read(self._iprot)
1708 
      self._iprot.readMessageEnd()
1709 
      raise x
1710 
    result = getComingSoonCount_result()
1711 
    result.read(self._iprot)
1712 
    self._iprot.readMessageEnd()
1713 
    if result.success is not None:
1714 
      return result.success
1715 
    if result.cex is not None:
1716 
      raise result.cex
1717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1718 
 
1719 
  def getLatestArrivals(self, ):
1720 
    """
1721 
    Returns a list of items sorted in the descending order by start date.
1722 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1723 
    """
1724 
    self.send_getLatestArrivals()
1725 
    return self.recv_getLatestArrivals()
1726 
 
1727 
  def send_getLatestArrivals(self, ):
1728 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1729 
    args = getLatestArrivals_args()
1730 
    args.write(self._oprot)
1731 
    self._oprot.writeMessageEnd()
1732 
    self._oprot.trans.flush()
1733 
 
1734 
  def recv_getLatestArrivals(self, ):
1735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1736 
    if mtype == TMessageType.EXCEPTION:
1737 
      x = TApplicationException()
1738 
      x.read(self._iprot)
1739 
      self._iprot.readMessageEnd()
1740 
      raise x
1741 
    result = getLatestArrivals_result()
1742 
    result.read(self._iprot)
1743 
    self._iprot.readMessageEnd()
1744 
    if result.success is not None:
1745 
      return result.success
1746 
    if result.isex is not None:
1747 
      raise result.isex
1748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1749 
 
1750 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1751 
    """
1752 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1753 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1754 
 
1755 
    Parameters:
1756 
     - beginIndex
1757 
     - totalItems
1758 
     - brand
1759 
     - categories
1760 
    """
1761 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1762 
    return self.recv_getLatestArrivalsCatalogIds()
1763 
 
1764 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1765 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1766 
    args = getLatestArrivalsCatalogIds_args()
1767 
    args.beginIndex = beginIndex
1768 
    args.totalItems = totalItems
1769 
    args.brand = brand
1770 
    args.categories = categories
1771 
    args.write(self._oprot)
1772 
    self._oprot.writeMessageEnd()
1773 
    self._oprot.trans.flush()
1774 
 
1775 
  def recv_getLatestArrivalsCatalogIds(self, ):
1776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1777 
    if mtype == TMessageType.EXCEPTION:
1778 
      x = TApplicationException()
1779 
      x.read(self._iprot)
1780 
      self._iprot.readMessageEnd()
1781 
      raise x
1782 
    result = getLatestArrivalsCatalogIds_result()
1783 
    result.read(self._iprot)
1784 
    self._iprot.readMessageEnd()
1785 
    if result.success is not None:
1786 
      return result.success
1787 
    if result.cex is not None:
1788 
      raise result.cex
1789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1790 
 
1791 
  def getLatestArrivalsCount(self, ):
1792 
    """
1793 
    Get the total number of latest arrivals we are willing to show.
1794 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1795 
    """
1796 
    self.send_getLatestArrivalsCount()
1797 
    return self.recv_getLatestArrivalsCount()
1798 
 
1799 
  def send_getLatestArrivalsCount(self, ):
1800 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1801 
    args = getLatestArrivalsCount_args()
1802 
    args.write(self._oprot)
1803 
    self._oprot.writeMessageEnd()
1804 
    self._oprot.trans.flush()
1805 
 
1806 
  def recv_getLatestArrivalsCount(self, ):
1807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1808 
    if mtype == TMessageType.EXCEPTION:
1809 
      x = TApplicationException()
1810 
      x.read(self._iprot)
1811 
      self._iprot.readMessageEnd()
1812 
      raise x
1813 
    result = getLatestArrivalsCount_result()
1814 
    result.read(self._iprot)
1815 
    self._iprot.readMessageEnd()
1816 
    if result.success is not None:
1817 
      return result.success
1818 
    if result.cex is not None:
1819 
      raise result.cex
1820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1821 
 
1822 
  def generateNewEntityID(self, ):
1823 
    self.send_generateNewEntityID()
1824 
    return self.recv_generateNewEntityID()
1825 
 
1826 
  def send_generateNewEntityID(self, ):
1827 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1828 
    args = generateNewEntityID_args()
1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
1833 
  def recv_generateNewEntityID(self, ):
1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
1840 
    result = generateNewEntityID_result()
1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
1843 
    if result.success is not None:
1844 
      return result.success
1845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1846 
 
1847 
  def addCategory(self, category):
1848 
    """
1849 
    All category related functions
1850 
 
1851 
    Parameters:
1852 
     - category
1853 
    """
1854 
    self.send_addCategory(category)
1855 
    return self.recv_addCategory()
1856 
 
1857 
  def send_addCategory(self, category):
1858 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1859 
    args = addCategory_args()
1860 
    args.category = category
1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
1865 
  def recv_addCategory(self, ):
1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
1872 
    result = addCategory_result()
1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
1875 
    if result.success is not None:
1876 
      return result.success
1877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1878 
 
1879 
  def getCategory(self, id):
1880 
    """
1881 
    Parameters:
1882 
     - id
1883 
    """
1884 
    self.send_getCategory(id)
1885 
    return self.recv_getCategory()
1886 
 
1887 
  def send_getCategory(self, id):
1888 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1889 
    args = getCategory_args()
1890 
    args.id = id
1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getCategory(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getCategory_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
1905 
    if result.success is not None:
1906 
      return result.success
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1908 
 
1909 
  def getAllCategories(self, ):
1910 
    self.send_getAllCategories()
1911 
    return self.recv_getAllCategories()
1912 
 
1913 
  def send_getAllCategories(self, ):
1914 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1915 
    args = getAllCategories_args()
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_getAllCategories(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = getAllCategories_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
1930 
    if result.success is not None:
1931 
      return result.success
1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1933 
 
1934 
  def getAllSimilarItems(self, itemId):
1935 
    """
1936 
    Returns the list of similar items.
1937 
 
1938 
    Parameters:
1939 
     - itemId
1940 
    """
1941 
    self.send_getAllSimilarItems(itemId)
1942 
    return self.recv_getAllSimilarItems()
1943 
 
1944 
  def send_getAllSimilarItems(self, itemId):
1945 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1946 
    args = getAllSimilarItems_args()
1947 
    args.itemId = itemId
1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
1952 
  def recv_getAllSimilarItems(self, ):
1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
1959 
    result = getAllSimilarItems_result()
1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
1962 
    if result.success is not None:
1963 
      return result.success
1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1965 
 
1966 
  def addSimilarItem(self, itemId, catalogItemId):
1967 
    """
1968 
    Adds similar item.
1969 
 
1970 
    Parameters:
1971 
     - itemId
1972 
     - catalogItemId
1973 
    """
1974 
    self.send_addSimilarItem(itemId, catalogItemId)
1975 
    return self.recv_addSimilarItem()
1976 
 
1977 
  def send_addSimilarItem(self, itemId, catalogItemId):
1978 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1979 
    args = addSimilarItem_args()
1980 
    args.itemId = itemId
1981 
    args.catalogItemId = catalogItemId
1982 
    args.write(self._oprot)
1983 
    self._oprot.writeMessageEnd()
1984 
    self._oprot.trans.flush()
1985 
 
1986 
  def recv_addSimilarItem(self, ):
1987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1988 
    if mtype == TMessageType.EXCEPTION:
1989 
      x = TApplicationException()
1990 
      x.read(self._iprot)
1991 
      self._iprot.readMessageEnd()
1992 
      raise x
1993 
    result = addSimilarItem_result()
1994 
    result.read(self._iprot)
1995 
    self._iprot.readMessageEnd()
1996 
    if result.success is not None:
1997 
      return result.success
1998 
    if result.cex is not None:
1999 
      raise result.cex
2000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2001 
 
6512 kshitij.so 2002 
  def addTag(self, displayName, itemId):
2003 
    """
2004 
    Tag Related
2005 
 
2006 
    Parameters:
2007 
     - displayName
2008 
     - itemId
2009 
    """
2010 
    self.send_addTag(displayName, itemId)
2011 
    return self.recv_addTag()
2012 
 
2013 
  def send_addTag(self, displayName, itemId):
2014 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2015 
    args = addTag_args()
2016 
    args.displayName = displayName
2017 
    args.itemId = itemId
2018 
    args.write(self._oprot)
2019 
    self._oprot.writeMessageEnd()
2020 
    self._oprot.trans.flush()
2021 
 
2022 
  def recv_addTag(self, ):
2023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2024 
    if mtype == TMessageType.EXCEPTION:
2025 
      x = TApplicationException()
2026 
      x.read(self._iprot)
2027 
      self._iprot.readMessageEnd()
2028 
      raise x
2029 
    result = addTag_result()
2030 
    result.read(self._iprot)
2031 
    self._iprot.readMessageEnd()
2032 
    if result.success is not None:
2033 
      return result.success
2034 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2035 
 
2036 
  def deleteEntityTag(self, displayName, itemId):
2037 
    """
2038 
    Parameters:
2039 
     - displayName
2040 
     - itemId
2041 
    """
2042 
    self.send_deleteEntityTag(displayName, itemId)
2043 
    return self.recv_deleteEntityTag()
2044 
 
2045 
  def send_deleteEntityTag(self, displayName, itemId):
2046 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2047 
    args = deleteEntityTag_args()
2048 
    args.displayName = displayName
2049 
    args.itemId = itemId
2050 
    args.write(self._oprot)
2051 
    self._oprot.writeMessageEnd()
2052 
    self._oprot.trans.flush()
2053 
 
2054 
  def recv_deleteEntityTag(self, ):
2055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2056 
    if mtype == TMessageType.EXCEPTION:
2057 
      x = TApplicationException()
2058 
      x.read(self._iprot)
2059 
      self._iprot.readMessageEnd()
2060 
      raise x
2061 
    result = deleteEntityTag_result()
2062 
    result.read(self._iprot)
2063 
    self._iprot.readMessageEnd()
2064 
    if result.success is not None:
2065 
      return result.success
2066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2067 
 
2068 
  def deleteTag(self, displayName):
2069 
    """
2070 
    Parameters:
2071 
     - displayName
2072 
    """
2073 
    self.send_deleteTag(displayName)
2074 
    return self.recv_deleteTag()
2075 
 
2076 
  def send_deleteTag(self, displayName):
2077 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2078 
    args = deleteTag_args()
2079 
    args.displayName = displayName
2080 
    args.write(self._oprot)
2081 
    self._oprot.writeMessageEnd()
2082 
    self._oprot.trans.flush()
2083 
 
2084 
  def recv_deleteTag(self, ):
2085 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2086 
    if mtype == TMessageType.EXCEPTION:
2087 
      x = TApplicationException()
2088 
      x.read(self._iprot)
2089 
      self._iprot.readMessageEnd()
2090 
      raise x
2091 
    result = deleteTag_result()
2092 
    result.read(self._iprot)
2093 
    self._iprot.readMessageEnd()
2094 
    if result.success is not None:
2095 
      return result.success
2096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2097 
 
2098 
  def getAllTags(self, ):
2099 
    self.send_getAllTags()
2100 
    return self.recv_getAllTags()
2101 
 
2102 
  def send_getAllTags(self, ):
2103 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2104 
    args = getAllTags_args()
2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
2109 
  def recv_getAllTags(self, ):
2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
2116 
    result = getAllTags_result()
2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
2119 
    if result.success is not None:
2120 
      return result.success
2121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2122 
 
2123 
  def getAllEntitiesByTagName(self, displayName):
2124 
    """
2125 
    Parameters:
2126 
     - displayName
2127 
    """
2128 
    self.send_getAllEntitiesByTagName(displayName)
2129 
    return self.recv_getAllEntitiesByTagName()
2130 
 
2131 
  def send_getAllEntitiesByTagName(self, displayName):
2132 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2133 
    args = getAllEntitiesByTagName_args()
2134 
    args.displayName = displayName
2135 
    args.write(self._oprot)
2136 
    self._oprot.writeMessageEnd()
2137 
    self._oprot.trans.flush()
2138 
 
2139 
  def recv_getAllEntitiesByTagName(self, ):
2140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2141 
    if mtype == TMessageType.EXCEPTION:
2142 
      x = TApplicationException()
2143 
      x.read(self._iprot)
2144 
      self._iprot.readMessageEnd()
2145 
      raise x
2146 
    result = getAllEntitiesByTagName_result()
2147 
    result.read(self._iprot)
2148 
    self._iprot.readMessageEnd()
2149 
    if result.success is not None:
2150 
      return result.success
2151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2152 
 
6845 amit.gupta 2153 
  def getAllEntityTags(self, ):
2154 
    self.send_getAllEntityTags()
2155 
    return self.recv_getAllEntityTags()
2156 
 
2157 
  def send_getAllEntityTags(self, ):
2158 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2159 
    args = getAllEntityTags_args()
2160 
    args.write(self._oprot)
2161 
    self._oprot.writeMessageEnd()
2162 
    self._oprot.trans.flush()
2163 
 
2164 
  def recv_getAllEntityTags(self, ):
2165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2166 
    if mtype == TMessageType.EXCEPTION:
2167 
      x = TApplicationException()
2168 
      x.read(self._iprot)
2169 
      self._iprot.readMessageEnd()
2170 
      raise x
2171 
    result = getAllEntityTags_result()
2172 
    result.read(self._iprot)
2173 
    self._iprot.readMessageEnd()
2174 
    if result.success is not None:
2175 
      return result.success
2176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2177 
 
8579 kshitij.so 2178 
  def addBanner(self, banner):
6850 kshitij.so 2179 
    """
8579 kshitij.so 2180 
    Banner Related
2181 
 
6850 kshitij.so 2182 
    Parameters:
8579 kshitij.so 2183 
     - banner
6850 kshitij.so 2184 
    """
8579 kshitij.so 2185 
    self.send_addBanner(banner)
6850 kshitij.so 2186 
    return self.recv_addBanner()
2187 
 
8579 kshitij.so 2188 
  def send_addBanner(self, banner):
6850 kshitij.so 2189 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2190 
    args = addBanner_args()
8579 kshitij.so 2191 
    args.banner = banner
6850 kshitij.so 2192 
    args.write(self._oprot)
2193 
    self._oprot.writeMessageEnd()
2194 
    self._oprot.trans.flush()
2195 
 
2196 
  def recv_addBanner(self, ):
2197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2198 
    if mtype == TMessageType.EXCEPTION:
2199 
      x = TApplicationException()
2200 
      x.read(self._iprot)
2201 
      self._iprot.readMessageEnd()
2202 
      raise x
2203 
    result = addBanner_result()
2204 
    result.read(self._iprot)
2205 
    self._iprot.readMessageEnd()
2206 
    if result.success is not None:
2207 
      return result.success
2208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2209 
 
8579 kshitij.so 2210 
  def updateBanner(self, banner):
2211 
    """
2212 
    Parameters:
2213 
     - banner
2214 
    """
2215 
    self.send_updateBanner(banner)
2216 
    return self.recv_updateBanner()
2217 
 
2218 
  def send_updateBanner(self, banner):
2219 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2220 
    args = updateBanner_args()
2221 
    args.banner = banner
2222 
    args.write(self._oprot)
2223 
    self._oprot.writeMessageEnd()
2224 
    self._oprot.trans.flush()
2225 
 
2226 
  def recv_updateBanner(self, ):
2227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2228 
    if mtype == TMessageType.EXCEPTION:
2229 
      x = TApplicationException()
2230 
      x.read(self._iprot)
2231 
      self._iprot.readMessageEnd()
2232 
      raise x
2233 
    result = updateBanner_result()
2234 
    result.read(self._iprot)
2235 
    self._iprot.readMessageEnd()
2236 
    if result.success is not None:
2237 
      return result.success
2238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2239 
 
6850 kshitij.so 2240 
  def getAllBanners(self, ):
2241 
    self.send_getAllBanners()
2242 
    return self.recv_getAllBanners()
2243 
 
2244 
  def send_getAllBanners(self, ):
2245 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2246 
    args = getAllBanners_args()
2247 
    args.write(self._oprot)
2248 
    self._oprot.writeMessageEnd()
2249 
    self._oprot.trans.flush()
2250 
 
2251 
  def recv_getAllBanners(self, ):
2252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2253 
    if mtype == TMessageType.EXCEPTION:
2254 
      x = TApplicationException()
2255 
      x.read(self._iprot)
2256 
      self._iprot.readMessageEnd()
2257 
      raise x
2258 
    result = getAllBanners_result()
2259 
    result.read(self._iprot)
2260 
    self._iprot.readMessageEnd()
2261 
    if result.success is not None:
2262 
      return result.success
2263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2264 
 
2265 
  def deleteBanner(self, bannerName):
2266 
    """
2267 
    Parameters:
2268 
     - bannerName
2269 
    """
2270 
    self.send_deleteBanner(bannerName)
2271 
    return self.recv_deleteBanner()
2272 
 
2273 
  def send_deleteBanner(self, bannerName):
2274 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2275 
    args = deleteBanner_args()
2276 
    args.bannerName = bannerName
2277 
    args.write(self._oprot)
2278 
    self._oprot.writeMessageEnd()
2279 
    self._oprot.trans.flush()
2280 
 
2281 
  def recv_deleteBanner(self, ):
2282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2283 
    if mtype == TMessageType.EXCEPTION:
2284 
      x = TApplicationException()
2285 
      x.read(self._iprot)
2286 
      self._iprot.readMessageEnd()
2287 
      raise x
2288 
    result = deleteBanner_result()
2289 
    result.read(self._iprot)
2290 
    self._iprot.readMessageEnd()
2291 
    if result.success is not None:
2292 
      return result.success
2293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2294 
 
2295 
  def getBannerDetails(self, bannerName):
2296 
    """
2297 
    Parameters:
2298 
     - bannerName
2299 
    """
2300 
    self.send_getBannerDetails(bannerName)
2301 
    return self.recv_getBannerDetails()
2302 
 
2303 
  def send_getBannerDetails(self, bannerName):
2304 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2305 
    args = getBannerDetails_args()
2306 
    args.bannerName = bannerName
2307 
    args.write(self._oprot)
2308 
    self._oprot.writeMessageEnd()
2309 
    self._oprot.trans.flush()
2310 
 
2311 
  def recv_getBannerDetails(self, ):
2312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2313 
    if mtype == TMessageType.EXCEPTION:
2314 
      x = TApplicationException()
2315 
      x.read(self._iprot)
2316 
      self._iprot.readMessageEnd()
2317 
      raise x
2318 
    result = getBannerDetails_result()
2319 
    result.read(self._iprot)
2320 
    self._iprot.readMessageEnd()
2321 
    if result.success is not None:
2322 
      return result.success
2323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2324 
 
2325 
  def getActiveBanners(self, ):
2326 
    self.send_getActiveBanners()
2327 
    return self.recv_getActiveBanners()
2328 
 
2329 
  def send_getActiveBanners(self, ):
2330 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2331 
    args = getActiveBanners_args()
2332 
    args.write(self._oprot)
2333 
    self._oprot.writeMessageEnd()
2334 
    self._oprot.trans.flush()
2335 
 
2336 
  def recv_getActiveBanners(self, ):
2337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2338 
    if mtype == TMessageType.EXCEPTION:
2339 
      x = TApplicationException()
2340 
      x.read(self._iprot)
2341 
      self._iprot.readMessageEnd()
2342 
      raise x
2343 
    result = getActiveBanners_result()
2344 
    result.read(self._iprot)
2345 
    self._iprot.readMessageEnd()
2346 
    if result.success is not None:
2347 
      return result.success
2348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2349 
 
8579 kshitij.so 2350 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2351 
    """
2352 
    Parameters:
8579 kshitij.so 2353 
     - bannerMaps
6849 kshitij.so 2354 
    """
8579 kshitij.so 2355 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2356 
    return self.recv_addBannerMap()
2357 
 
8579 kshitij.so 2358 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2359 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2360 
    args = addBannerMap_args()
8579 kshitij.so 2361 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2362 
    args.write(self._oprot)
2363 
    self._oprot.writeMessageEnd()
2364 
    self._oprot.trans.flush()
2365 
 
2366 
  def recv_addBannerMap(self, ):
2367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2368 
    if mtype == TMessageType.EXCEPTION:
2369 
      x = TApplicationException()
2370 
      x.read(self._iprot)
2371 
      self._iprot.readMessageEnd()
2372 
      raise x
2373 
    result = addBannerMap_result()
2374 
    result.read(self._iprot)
2375 
    self._iprot.readMessageEnd()
2376 
    if result.success is not None:
2377 
      return result.success
2378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2379 
 
8579 kshitij.so 2380 
  def updateBannerMap(self, bannerMap):
2381 
    """
2382 
    Parameters:
2383 
     - bannerMap
2384 
    """
2385 
    self.send_updateBannerMap(bannerMap)
2386 
    return self.recv_updateBannerMap()
2387 
 
2388 
  def send_updateBannerMap(self, bannerMap):
2389 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2390 
    args = updateBannerMap_args()
2391 
    args.bannerMap = bannerMap
2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
2396 
  def recv_updateBannerMap(self, ):
2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
2403 
    result = updateBannerMap_result()
2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
2406 
    if result.success is not None:
2407 
      return result.success
2408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2409 
 
6849 kshitij.so 2410 
  def deleteBannerMap(self, bannerName):
2411 
    """
2412 
    Parameters:
2413 
     - bannerName
2414 
    """
2415 
    self.send_deleteBannerMap(bannerName)
2416 
    return self.recv_deleteBannerMap()
2417 
 
2418 
  def send_deleteBannerMap(self, bannerName):
2419 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2420 
    args = deleteBannerMap_args()
2421 
    args.bannerName = bannerName
2422 
    args.write(self._oprot)
2423 
    self._oprot.writeMessageEnd()
2424 
    self._oprot.trans.flush()
2425 
 
2426 
  def recv_deleteBannerMap(self, ):
2427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2428 
    if mtype == TMessageType.EXCEPTION:
2429 
      x = TApplicationException()
2430 
      x.read(self._iprot)
2431 
      self._iprot.readMessageEnd()
2432 
      raise x
2433 
    result = deleteBannerMap_result()
2434 
    result.read(self._iprot)
2435 
    self._iprot.readMessageEnd()
2436 
    if result.success is not None:
2437 
      return result.success
2438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2439 
 
2440 
  def getBannerMapDetails(self, bannerName):
2441 
    """
2442 
    Parameters:
2443 
     - bannerName
2444 
    """
2445 
    self.send_getBannerMapDetails(bannerName)
2446 
    return self.recv_getBannerMapDetails()
2447 
 
2448 
  def send_getBannerMapDetails(self, bannerName):
2449 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2450 
    args = getBannerMapDetails_args()
2451 
    args.bannerName = bannerName
2452 
    args.write(self._oprot)
2453 
    self._oprot.writeMessageEnd()
2454 
    self._oprot.trans.flush()
2455 
 
2456 
  def recv_getBannerMapDetails(self, ):
2457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2458 
    if mtype == TMessageType.EXCEPTION:
2459 
      x = TApplicationException()
2460 
      x.read(self._iprot)
2461 
      self._iprot.readMessageEnd()
2462 
      raise x
2463 
    result = getBannerMapDetails_result()
2464 
    result.read(self._iprot)
2465 
    self._iprot.readMessageEnd()
2466 
    if result.success is not None:
2467 
      return result.success
2468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2469 
 
8579 kshitij.so 2470 
  def addBannerUri(self, bannerUriMappings):
2471 
    """
2472 
    Parameters:
2473 
     - bannerUriMappings
2474 
    """
2475 
    self.send_addBannerUri(bannerUriMappings)
2476 
    self.recv_addBannerUri()
2477 
 
2478 
  def send_addBannerUri(self, bannerUriMappings):
2479 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2480 
    args = addBannerUri_args()
2481 
    args.bannerUriMappings = bannerUriMappings
2482 
    args.write(self._oprot)
2483 
    self._oprot.writeMessageEnd()
2484 
    self._oprot.trans.flush()
2485 
 
2486 
  def recv_addBannerUri(self, ):
2487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2488 
    if mtype == TMessageType.EXCEPTION:
2489 
      x = TApplicationException()
2490 
      x.read(self._iprot)
2491 
      self._iprot.readMessageEnd()
2492 
      raise x
2493 
    result = addBannerUri_result()
2494 
    result.read(self._iprot)
2495 
    self._iprot.readMessageEnd()
2496 
    return
2497 
 
2498 
  def getUriMapping(self, bannerName):
2499 
    """
2500 
    Parameters:
2501 
     - bannerName
2502 
    """
2503 
    self.send_getUriMapping(bannerName)
2504 
    return self.recv_getUriMapping()
2505 
 
2506 
  def send_getUriMapping(self, bannerName):
2507 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2508 
    args = getUriMapping_args()
2509 
    args.bannerName = bannerName
2510 
    args.write(self._oprot)
2511 
    self._oprot.writeMessageEnd()
2512 
    self._oprot.trans.flush()
2513 
 
2514 
  def recv_getUriMapping(self, ):
2515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2516 
    if mtype == TMessageType.EXCEPTION:
2517 
      x = TApplicationException()
2518 
      x.read(self._iprot)
2519 
      self._iprot.readMessageEnd()
2520 
      raise x
2521 
    result = getUriMapping_result()
2522 
    result.read(self._iprot)
2523 
    self._iprot.readMessageEnd()
2524 
    if result.success is not None:
2525 
      return result.success
2526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2527 
 
2528 
  def addCampaign(self, campaign):
2529 
    """
2530 
    Parameters:
2531 
     - campaign
2532 
    """
2533 
    self.send_addCampaign(campaign)
2534 
    self.recv_addCampaign()
2535 
 
2536 
  def send_addCampaign(self, campaign):
2537 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2538 
    args = addCampaign_args()
2539 
    args.campaign = campaign
2540 
    args.write(self._oprot)
2541 
    self._oprot.writeMessageEnd()
2542 
    self._oprot.trans.flush()
2543 
 
2544 
  def recv_addCampaign(self, ):
2545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2546 
    if mtype == TMessageType.EXCEPTION:
2547 
      x = TApplicationException()
2548 
      x.read(self._iprot)
2549 
      self._iprot.readMessageEnd()
2550 
      raise x
2551 
    result = addCampaign_result()
2552 
    result.read(self._iprot)
2553 
    self._iprot.readMessageEnd()
2554 
    return
2555 
 
2556 
  def getCampaigns(self, campaignName):
2557 
    """
2558 
    Parameters:
2559 
     - campaignName
2560 
    """
2561 
    self.send_getCampaigns(campaignName)
2562 
    return self.recv_getCampaigns()
2563 
 
2564 
  def send_getCampaigns(self, campaignName):
2565 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2566 
    args = getCampaigns_args()
2567 
    args.campaignName = campaignName
2568 
    args.write(self._oprot)
2569 
    self._oprot.writeMessageEnd()
2570 
    self._oprot.trans.flush()
2571 
 
2572 
  def recv_getCampaigns(self, ):
2573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2574 
    if mtype == TMessageType.EXCEPTION:
2575 
      x = TApplicationException()
2576 
      x.read(self._iprot)
2577 
      self._iprot.readMessageEnd()
2578 
      raise x
2579 
    result = getCampaigns_result()
2580 
    result.read(self._iprot)
2581 
    self._iprot.readMessageEnd()
2582 
    if result.success is not None:
2583 
      return result.success
2584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2585 
 
2586 
  def deleteCampaign(self, campaignId):
2587 
    """
2588 
    Parameters:
2589 
     - campaignId
2590 
    """
2591 
    self.send_deleteCampaign(campaignId)
2592 
    self.recv_deleteCampaign()
2593 
 
2594 
  def send_deleteCampaign(self, campaignId):
2595 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2596 
    args = deleteCampaign_args()
2597 
    args.campaignId = campaignId
2598 
    args.write(self._oprot)
2599 
    self._oprot.writeMessageEnd()
2600 
    self._oprot.trans.flush()
2601 
 
2602 
  def recv_deleteCampaign(self, ):
2603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2604 
    if mtype == TMessageType.EXCEPTION:
2605 
      x = TApplicationException()
2606 
      x.read(self._iprot)
2607 
      self._iprot.readMessageEnd()
2608 
      raise x
2609 
    result = deleteCampaign_result()
2610 
    result.read(self._iprot)
2611 
    self._iprot.readMessageEnd()
2612 
    return
2613 
 
2614 
  def getAllCampaigns(self, ):
2615 
    self.send_getAllCampaigns()
2616 
    return self.recv_getAllCampaigns()
2617 
 
2618 
  def send_getAllCampaigns(self, ):
2619 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2620 
    args = getAllCampaigns_args()
2621 
    args.write(self._oprot)
2622 
    self._oprot.writeMessageEnd()
2623 
    self._oprot.trans.flush()
2624 
 
2625 
  def recv_getAllCampaigns(self, ):
2626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2627 
    if mtype == TMessageType.EXCEPTION:
2628 
      x = TApplicationException()
2629 
      x.read(self._iprot)
2630 
      self._iprot.readMessageEnd()
2631 
      raise x
2632 
    result = getAllCampaigns_result()
2633 
    result.read(self._iprot)
2634 
    self._iprot.readMessageEnd()
2635 
    if result.success is not None:
2636 
      return result.success
2637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2638 
 
5944 mandeep.dh 2639 
  def deleteSimilarItem(self, itemId, catalogItemId):
2640 
    """
2641 
    Delete similar item.
2642 
 
2643 
    Parameters:
2644 
     - itemId
2645 
     - catalogItemId
2646 
    """
2647 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2648 
    return self.recv_deleteSimilarItem()
2649 
 
2650 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2651 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2652 
    args = deleteSimilarItem_args()
2653 
    args.itemId = itemId
2654 
    args.catalogItemId = catalogItemId
2655 
    args.write(self._oprot)
2656 
    self._oprot.writeMessageEnd()
2657 
    self._oprot.trans.flush()
2658 
 
2659 
  def recv_deleteSimilarItem(self, ):
2660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2661 
    if mtype == TMessageType.EXCEPTION:
2662 
      x = TApplicationException()
2663 
      x.read(self._iprot)
2664 
      self._iprot.readMessageEnd()
2665 
      raise x
2666 
    result = deleteSimilarItem_result()
2667 
    result.read(self._iprot)
2668 
    self._iprot.readMessageEnd()
2669 
    if result.success is not None:
2670 
      return result.success
2671 
    if result.cex is not None:
2672 
      raise result.cex
2673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2674 
 
2675 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2676 
    """
2677 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2678 
    If yes, returns the itemId else returns 0
2679 
 
2680 
    Parameters:
2681 
     - brand
2682 
     - modelNumber
2683 
     - modelName
2684 
     - color
2685 
    """
2686 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2687 
    return self.recv_checkSimilarItem()
2688 
 
2689 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2690 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2691 
    args = checkSimilarItem_args()
2692 
    args.brand = brand
2693 
    args.modelNumber = modelNumber
2694 
    args.modelName = modelName
2695 
    args.color = color
2696 
    args.write(self._oprot)
2697 
    self._oprot.writeMessageEnd()
2698 
    self._oprot.trans.flush()
2699 
 
2700 
  def recv_checkSimilarItem(self, ):
2701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2702 
    if mtype == TMessageType.EXCEPTION:
2703 
      x = TApplicationException()
2704 
      x.read(self._iprot)
2705 
      self._iprot.readMessageEnd()
2706 
      raise x
2707 
    result = checkSimilarItem_result()
2708 
    result.read(self._iprot)
2709 
    self._iprot.readMessageEnd()
2710 
    if result.success is not None:
2711 
      return result.success
2712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2713 
 
2714 
  def validateRiskyStatus(self, itemId):
2715 
    """
2716 
    Check wether item is risky and change status if inventory is not available for risky items
2717 
 
2718 
    Parameters:
2719 
     - itemId
2720 
    """
2721 
    self.send_validateRiskyStatus(itemId)
2722 
    self.recv_validateRiskyStatus()
2723 
 
2724 
  def send_validateRiskyStatus(self, itemId):
2725 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2726 
    args = validateRiskyStatus_args()
2727 
    args.itemId = itemId
2728 
    args.write(self._oprot)
2729 
    self._oprot.writeMessageEnd()
2730 
    self._oprot.trans.flush()
2731 
 
2732 
  def recv_validateRiskyStatus(self, ):
2733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2734 
    if mtype == TMessageType.EXCEPTION:
2735 
      x = TApplicationException()
2736 
      x.read(self._iprot)
2737 
      self._iprot.readMessageEnd()
2738 
      raise x
2739 
    result = validateRiskyStatus_result()
2740 
    result.read(self._iprot)
2741 
    self._iprot.readMessageEnd()
2742 
    return
2743 
 
2744 
  def changeItemRiskyFlag(self, itemId, risky):
2745 
    """
2746 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2747 
 
2748 
    Parameters:
2749 
     - itemId
2750 
     - risky
2751 
    """
2752 
    self.send_changeItemRiskyFlag(itemId, risky)
2753 
    self.recv_changeItemRiskyFlag()
2754 
 
2755 
  def send_changeItemRiskyFlag(self, itemId, risky):
2756 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2757 
    args = changeItemRiskyFlag_args()
2758 
    args.itemId = itemId
2759 
    args.risky = risky
2760 
    args.write(self._oprot)
2761 
    self._oprot.writeMessageEnd()
2762 
    self._oprot.trans.flush()
2763 
 
2764 
  def recv_changeItemRiskyFlag(self, ):
2765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2766 
    if mtype == TMessageType.EXCEPTION:
2767 
      x = TApplicationException()
2768 
      x.read(self._iprot)
2769 
      self._iprot.readMessageEnd()
2770 
      raise x
2771 
    result = changeItemRiskyFlag_result()
2772 
    result.read(self._iprot)
2773 
    self._iprot.readMessageEnd()
2774 
    return
2775 
 
2776 
  def getItemsByRiskyFlag(self, ):
2777 
    """
2778 
    Returns list of items marked as risky.
2779 
    """
2780 
    self.send_getItemsByRiskyFlag()
2781 
    return self.recv_getItemsByRiskyFlag()
2782 
 
2783 
  def send_getItemsByRiskyFlag(self, ):
2784 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2785 
    args = getItemsByRiskyFlag_args()
2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
2790 
  def recv_getItemsByRiskyFlag(self, ):
2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
2797 
    result = getItemsByRiskyFlag_result()
2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
2800 
    if result.success is not None:
2801 
      return result.success
2802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2803 
 
2804 
  def getItemsForMasterSheet(self, category, brand):
2805 
    """
2806 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2807 
 
2808 
    Parameters:
2809 
     - category
2810 
     - brand
2811 
    """
2812 
    self.send_getItemsForMasterSheet(category, brand)
2813 
    return self.recv_getItemsForMasterSheet()
2814 
 
2815 
  def send_getItemsForMasterSheet(self, category, brand):
2816 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2817 
    args = getItemsForMasterSheet_args()
2818 
    args.category = category
2819 
    args.brand = brand
2820 
    args.write(self._oprot)
2821 
    self._oprot.writeMessageEnd()
2822 
    self._oprot.trans.flush()
2823 
 
2824 
  def recv_getItemsForMasterSheet(self, ):
2825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2826 
    if mtype == TMessageType.EXCEPTION:
2827 
      x = TApplicationException()
2828 
      x.read(self._iprot)
2829 
      self._iprot.readMessageEnd()
2830 
      raise x
2831 
    result = getItemsForMasterSheet_result()
2832 
    result.read(self._iprot)
2833 
    self._iprot.readMessageEnd()
2834 
    if result.success is not None:
2835 
      return result.success
2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2837 
 
2838 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2839 
    """
2840 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2841 
 
2842 
    Parameters:
2843 
     - beginIndex
2844 
     - totalItems
2845 
     - itemId
2846 
    """
2847 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2848 
    return self.recv_getSimilarItemsCatalogIds()
2849 
 
2850 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2851 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2852 
    args = getSimilarItemsCatalogIds_args()
2853 
    args.beginIndex = beginIndex
2854 
    args.totalItems = totalItems
2855 
    args.itemId = itemId
2856 
    args.write(self._oprot)
2857 
    self._oprot.writeMessageEnd()
2858 
    self._oprot.trans.flush()
2859 
 
2860 
  def recv_getSimilarItemsCatalogIds(self, ):
2861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2862 
    if mtype == TMessageType.EXCEPTION:
2863 
      x = TApplicationException()
2864 
      x.read(self._iprot)
2865 
      self._iprot.readMessageEnd()
2866 
      raise x
2867 
    result = getSimilarItemsCatalogIds_result()
2868 
    result.read(self._iprot)
2869 
    self._iprot.readMessageEnd()
2870 
    if result.success is not None:
2871 
      return result.success
2872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2873 
 
2874 
  def addProductNotification(self, itemId, email):
2875 
    """
2876 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2877 
 
2878 
    Parameters:
2879 
     - itemId
2880 
     - email
2881 
    """
2882 
    self.send_addProductNotification(itemId, email)
2883 
    return self.recv_addProductNotification()
2884 
 
2885 
  def send_addProductNotification(self, itemId, email):
2886 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2887 
    args = addProductNotification_args()
2888 
    args.itemId = itemId
2889 
    args.email = email
2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
2894 
  def recv_addProductNotification(self, ):
2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
2901 
    result = addProductNotification_result()
2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
2904 
    if result.success is not None:
2905 
      return result.success
2906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2907 
 
2908 
  def sendProductNotifications(self, ):
2909 
    """
2910 
    Send the product notifications to the users for items which has stock.
2911 
    """
2912 
    self.send_sendProductNotifications()
2913 
    return self.recv_sendProductNotifications()
2914 
 
2915 
  def send_sendProductNotifications(self, ):
2916 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2917 
    args = sendProductNotifications_args()
2918 
    args.write(self._oprot)
2919 
    self._oprot.writeMessageEnd()
2920 
    self._oprot.trans.flush()
2921 
 
2922 
  def recv_sendProductNotifications(self, ):
2923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2924 
    if mtype == TMessageType.EXCEPTION:
2925 
      x = TApplicationException()
2926 
      x.read(self._iprot)
2927 
      self._iprot.readMessageEnd()
2928 
      raise x
2929 
    result = sendProductNotifications_result()
2930 
    result.read(self._iprot)
2931 
    self._iprot.readMessageEnd()
2932 
    if result.success is not None:
2933 
      return result.success
2934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2935 
 
2936 
  def getAllBrandsByCategory(self, categoryId):
2937 
    """
2938 
    Returns list of brand names for a given category Id
2939 
 
2940 
    Parameters:
2941 
     - categoryId
2942 
    """
2943 
    self.send_getAllBrandsByCategory(categoryId)
2944 
    return self.recv_getAllBrandsByCategory()
2945 
 
2946 
  def send_getAllBrandsByCategory(self, categoryId):
2947 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2948 
    args = getAllBrandsByCategory_args()
2949 
    args.categoryId = categoryId
2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
2954 
  def recv_getAllBrandsByCategory(self, ):
2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
2961 
    result = getAllBrandsByCategory_result()
2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
2964 
    if result.success is not None:
2965 
      return result.success
2966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2967 
 
2968 
  def getAllBrands(self, ):
2969 
    """
2970 
    Returns list of brand names
2971 
    """
2972 
    self.send_getAllBrands()
2973 
    return self.recv_getAllBrands()
2974 
 
2975 
  def send_getAllBrands(self, ):
2976 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2977 
    args = getAllBrands_args()
2978 
    args.write(self._oprot)
2979 
    self._oprot.writeMessageEnd()
2980 
    self._oprot.trans.flush()
2981 
 
2982 
  def recv_getAllBrands(self, ):
2983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2984 
    if mtype == TMessageType.EXCEPTION:
2985 
      x = TApplicationException()
2986 
      x.read(self._iprot)
2987 
      self._iprot.readMessageEnd()
2988 
      raise x
2989 
    result = getAllBrands_result()
2990 
    result.read(self._iprot)
2991 
    self._iprot.readMessageEnd()
2992 
    if result.success is not None:
2993 
      return result.success
2994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2995 
 
2996 
  def getAllSources(self, ):
2997 
    """
2998 
    Return list of all sources
2999 
    """
3000 
    self.send_getAllSources()
3001 
    return self.recv_getAllSources()
3002 
 
3003 
  def send_getAllSources(self, ):
3004 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3005 
    args = getAllSources_args()
3006 
    args.write(self._oprot)
3007 
    self._oprot.writeMessageEnd()
3008 
    self._oprot.trans.flush()
3009 
 
3010 
  def recv_getAllSources(self, ):
3011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3012 
    if mtype == TMessageType.EXCEPTION:
3013 
      x = TApplicationException()
3014 
      x.read(self._iprot)
3015 
      self._iprot.readMessageEnd()
3016 
      raise x
3017 
    result = getAllSources_result()
3018 
    result.read(self._iprot)
3019 
    self._iprot.readMessageEnd()
3020 
    if result.success is not None:
3021 
      return result.success
3022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3023 
 
3024 
  def getItemPricingBySource(self, itemId, sourceId):
3025 
    """
3026 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3027 
 
3028 
    Parameters:
3029 
     - itemId
3030 
     - sourceId
3031 
    """
3032 
    self.send_getItemPricingBySource(itemId, sourceId)
3033 
    return self.recv_getItemPricingBySource()
3034 
 
3035 
  def send_getItemPricingBySource(self, itemId, sourceId):
3036 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3037 
    args = getItemPricingBySource_args()
3038 
    args.itemId = itemId
3039 
    args.sourceId = sourceId
3040 
    args.write(self._oprot)
3041 
    self._oprot.writeMessageEnd()
3042 
    self._oprot.trans.flush()
3043 
 
3044 
  def recv_getItemPricingBySource(self, ):
3045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3046 
    if mtype == TMessageType.EXCEPTION:
3047 
      x = TApplicationException()
3048 
      x.read(self._iprot)
3049 
      self._iprot.readMessageEnd()
3050 
      raise x
3051 
    result = getItemPricingBySource_result()
3052 
    result.read(self._iprot)
3053 
    self._iprot.readMessageEnd()
3054 
    if result.success is not None:
3055 
      return result.success
3056 
    if result.cex is not None:
3057 
      raise result.cex
3058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3059 
 
3060 
  def addSourceItemPricing(self, sourceItemPricing):
3061 
    """
3062 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3063 
    If item is not found or source is not found, it will throw exception.
3064 
 
3065 
    Parameters:
3066 
     - sourceItemPricing
3067 
    """
3068 
    self.send_addSourceItemPricing(sourceItemPricing)
3069 
    self.recv_addSourceItemPricing()
3070 
 
3071 
  def send_addSourceItemPricing(self, sourceItemPricing):
3072 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3073 
    args = addSourceItemPricing_args()
3074 
    args.sourceItemPricing = sourceItemPricing
3075 
    args.write(self._oprot)
3076 
    self._oprot.writeMessageEnd()
3077 
    self._oprot.trans.flush()
3078 
 
3079 
  def recv_addSourceItemPricing(self, ):
3080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3081 
    if mtype == TMessageType.EXCEPTION:
3082 
      x = TApplicationException()
3083 
      x.read(self._iprot)
3084 
      self._iprot.readMessageEnd()
3085 
      raise x
3086 
    result = addSourceItemPricing_result()
3087 
    result.read(self._iprot)
3088 
    self._iprot.readMessageEnd()
3089 
    if result.cex is not None:
3090 
      raise result.cex
3091 
    return
3092 
 
3093 
  def getAllSourcePricing(self, itemId):
3094 
    """
3095 
    Returns the list of source pricing information of an item.
3096 
    Raises an exception if item not found corresponding to itemId
3097 
 
3098 
    Parameters:
3099 
     - itemId
3100 
    """
3101 
    self.send_getAllSourcePricing(itemId)
3102 
    return self.recv_getAllSourcePricing()
3103 
 
3104 
  def send_getAllSourcePricing(self, itemId):
3105 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3106 
    args = getAllSourcePricing_args()
3107 
    args.itemId = itemId
3108 
    args.write(self._oprot)
3109 
    self._oprot.writeMessageEnd()
3110 
    self._oprot.trans.flush()
3111 
 
3112 
  def recv_getAllSourcePricing(self, ):
3113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3114 
    if mtype == TMessageType.EXCEPTION:
3115 
      x = TApplicationException()
3116 
      x.read(self._iprot)
3117 
      self._iprot.readMessageEnd()
3118 
      raise x
3119 
    result = getAllSourcePricing_result()
3120 
    result.read(self._iprot)
3121 
    self._iprot.readMessageEnd()
3122 
    if result.success is not None:
3123 
      return result.success
3124 
    if result.cex is not None:
3125 
      raise result.cex
3126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3127 
 
3128 
  def getItemForSource(self, item_id, sourceId):
3129 
    """
3130 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3131 
 
3132 
    Parameters:
3133 
     - item_id
3134 
     - sourceId
3135 
    """
3136 
    self.send_getItemForSource(item_id, sourceId)
3137 
    return self.recv_getItemForSource()
3138 
 
3139 
  def send_getItemForSource(self, item_id, sourceId):
3140 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3141 
    args = getItemForSource_args()
3142 
    args.item_id = item_id
3143 
    args.sourceId = sourceId
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_getItemForSource(self, ):
3149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3150 
    if mtype == TMessageType.EXCEPTION:
3151 
      x = TApplicationException()
3152 
      x.read(self._iprot)
3153 
      self._iprot.readMessageEnd()
3154 
      raise x
3155 
    result = getItemForSource_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.success is not None:
3159 
      return result.success
3160 
    if result.cex is not None:
3161 
      raise result.cex
3162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3163 
 
3164 
  def searchItemsInRange(self, searchTerms, offset, limit):
3165 
    """
3166 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3167 
 
3168 
    Parameters:
3169 
     - searchTerms
3170 
     - offset
3171 
     - limit
3172 
    """
3173 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3174 
    return self.recv_searchItemsInRange()
3175 
 
3176 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3177 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3178 
    args = searchItemsInRange_args()
3179 
    args.searchTerms = searchTerms
3180 
    args.offset = offset
3181 
    args.limit = limit
3182 
    args.write(self._oprot)
3183 
    self._oprot.writeMessageEnd()
3184 
    self._oprot.trans.flush()
3185 
 
3186 
  def recv_searchItemsInRange(self, ):
3187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3188 
    if mtype == TMessageType.EXCEPTION:
3189 
      x = TApplicationException()
3190 
      x.read(self._iprot)
3191 
      self._iprot.readMessageEnd()
3192 
      raise x
3193 
    result = searchItemsInRange_result()
3194 
    result.read(self._iprot)
3195 
    self._iprot.readMessageEnd()
3196 
    if result.success is not None:
3197 
      return result.success
3198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3199 
 
3200 
  def getSearchResultCount(self, searchTerms):
3201 
    """
3202 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3203 
 
3204 
    Parameters:
3205 
     - searchTerms
3206 
    """
3207 
    self.send_getSearchResultCount(searchTerms)
3208 
    return self.recv_getSearchResultCount()
3209 
 
3210 
  def send_getSearchResultCount(self, searchTerms):
3211 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3212 
    args = getSearchResultCount_args()
3213 
    args.searchTerms = searchTerms
3214 
    args.write(self._oprot)
3215 
    self._oprot.writeMessageEnd()
3216 
    self._oprot.trans.flush()
3217 
 
3218 
  def recv_getSearchResultCount(self, ):
3219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3220 
    if mtype == TMessageType.EXCEPTION:
3221 
      x = TApplicationException()
3222 
      x.read(self._iprot)
3223 
      self._iprot.readMessageEnd()
3224 
      raise x
3225 
    result = getSearchResultCount_result()
3226 
    result.read(self._iprot)
3227 
    self._iprot.readMessageEnd()
3228 
    if result.success is not None:
3229 
      return result.success
3230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3231 
 
3232 
  def getProductNotifications(self, startDateTime):
3233 
    """
3234 
    Returns a list of product notifications added after a supplied datetime
3235 
 
3236 
    Parameters:
3237 
     - startDateTime
3238 
    """
3239 
    self.send_getProductNotifications(startDateTime)
3240 
    return self.recv_getProductNotifications()
3241 
 
3242 
  def send_getProductNotifications(self, startDateTime):
3243 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3244 
    args = getProductNotifications_args()
3245 
    args.startDateTime = startDateTime
3246 
    args.write(self._oprot)
3247 
    self._oprot.writeMessageEnd()
3248 
    self._oprot.trans.flush()
3249 
 
3250 
  def recv_getProductNotifications(self, ):
3251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3252 
    if mtype == TMessageType.EXCEPTION:
3253 
      x = TApplicationException()
3254 
      x.read(self._iprot)
3255 
      self._iprot.readMessageEnd()
3256 
      raise x
3257 
    result = getProductNotifications_result()
3258 
    result.read(self._iprot)
3259 
    self._iprot.readMessageEnd()
3260 
    if result.success is not None:
3261 
      return result.success
3262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3263 
 
7897 amar.kumar 3264 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3265 
    """
3266 
    Returns a list of count of requests for product notification against each item
3267 
 
3268 
    Parameters:
3269 
     - startDateTime
7897 amar.kumar 3270 
     - categoryId
5944 mandeep.dh 3271 
    """
7897 amar.kumar 3272 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3273 
    return self.recv_getProductNotificationRequestCount()
3274 
 
7897 amar.kumar 3275 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3276 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3277 
    args = getProductNotificationRequestCount_args()
3278 
    args.startDateTime = startDateTime
7897 amar.kumar 3279 
    args.categoryId = categoryId
5944 mandeep.dh 3280 
    args.write(self._oprot)
3281 
    self._oprot.writeMessageEnd()
3282 
    self._oprot.trans.flush()
3283 
 
3284 
  def recv_getProductNotificationRequestCount(self, ):
3285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3286 
    if mtype == TMessageType.EXCEPTION:
3287 
      x = TApplicationException()
3288 
      x.read(self._iprot)
3289 
      self._iprot.readMessageEnd()
3290 
      raise x
3291 
    result = getProductNotificationRequestCount_result()
3292 
    result.read(self._iprot)
3293 
    self._iprot.readMessageEnd()
3294 
    if result.success is not None:
3295 
      return result.success
3296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3297 
 
3298 
  def addAuthorizationLog(self, itemId, username, reason):
3299 
    """
3300 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3301 
 
3302 
    Parameters:
3303 
     - itemId
3304 
     - username
3305 
     - reason
3306 
    """
3307 
    self.send_addAuthorizationLog(itemId, username, reason)
3308 
    return self.recv_addAuthorizationLog()
3309 
 
3310 
  def send_addAuthorizationLog(self, itemId, username, reason):
3311 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3312 
    args = addAuthorizationLog_args()
3313 
    args.itemId = itemId
3314 
    args.username = username
3315 
    args.reason = reason
3316 
    args.write(self._oprot)
3317 
    self._oprot.writeMessageEnd()
3318 
    self._oprot.trans.flush()
3319 
 
3320 
  def recv_addAuthorizationLog(self, ):
3321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3322 
    if mtype == TMessageType.EXCEPTION:
3323 
      x = TApplicationException()
3324 
      x.read(self._iprot)
3325 
      self._iprot.readMessageEnd()
3326 
      raise x
3327 
    result = addAuthorizationLog_result()
3328 
    result.read(self._iprot)
3329 
    self._iprot.readMessageEnd()
3330 
    if result.success is not None:
3331 
      return result.success
3332 
    if result.cex is not None:
3333 
      raise result.cex
3334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3335 
 
3336 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3337 
    """
3338 
    Parameters:
3339 
     - catalog_item_id
3340 
     - voucherType
3341 
     - voucherAmount
3342 
    """
3343 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3344 
    return self.recv_addupdateVoucherForItem()
3345 
 
3346 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3347 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3348 
    args = addupdateVoucherForItem_args()
3349 
    args.catalog_item_id = catalog_item_id
3350 
    args.voucherType = voucherType
3351 
    args.voucherAmount = voucherAmount
3352 
    args.write(self._oprot)
3353 
    self._oprot.writeMessageEnd()
3354 
    self._oprot.trans.flush()
3355 
 
3356 
  def recv_addupdateVoucherForItem(self, ):
3357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3358 
    if mtype == TMessageType.EXCEPTION:
3359 
      x = TApplicationException()
3360 
      x.read(self._iprot)
3361 
      self._iprot.readMessageEnd()
3362 
      raise x
3363 
    result = addupdateVoucherForItem_result()
3364 
    result.read(self._iprot)
3365 
    self._iprot.readMessageEnd()
3366 
    if result.success is not None:
3367 
      return result.success
3368 
    if result.cex is not None:
3369 
      raise result.cex
3370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3371 
 
3372 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3373 
    """
3374 
    Parameters:
3375 
     - catalog_item_id
3376 
     - voucherType
3377 
    """
3378 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3379 
    return self.recv_deleteVoucherForItem()
3380 
 
3381 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3382 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3383 
    args = deleteVoucherForItem_args()
3384 
    args.catalog_item_id = catalog_item_id
3385 
    args.voucherType = voucherType
3386 
    args.write(self._oprot)
3387 
    self._oprot.writeMessageEnd()
3388 
    self._oprot.trans.flush()
3389 
 
3390 
  def recv_deleteVoucherForItem(self, ):
3391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3392 
    if mtype == TMessageType.EXCEPTION:
3393 
      x = TApplicationException()
3394 
      x.read(self._iprot)
3395 
      self._iprot.readMessageEnd()
3396 
      raise x
3397 
    result = deleteVoucherForItem_result()
3398 
    result.read(self._iprot)
3399 
    self._iprot.readMessageEnd()
3400 
    if result.success is not None:
3401 
      return result.success
3402 
    if result.cex is not None:
3403 
      raise result.cex
3404 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3405 
 
3406 
  def getVoucherAmount(self, itemId, voucherType):
3407 
    """
3408 
    Parameters:
3409 
     - itemId
3410 
     - voucherType
3411 
    """
3412 
    self.send_getVoucherAmount(itemId, voucherType)
3413 
    return self.recv_getVoucherAmount()
3414 
 
3415 
  def send_getVoucherAmount(self, itemId, voucherType):
3416 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3417 
    args = getVoucherAmount_args()
3418 
    args.itemId = itemId
3419 
    args.voucherType = voucherType
3420 
    args.write(self._oprot)
3421 
    self._oprot.writeMessageEnd()
3422 
    self._oprot.trans.flush()
3423 
 
3424 
  def recv_getVoucherAmount(self, ):
3425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3426 
    if mtype == TMessageType.EXCEPTION:
3427 
      x = TApplicationException()
3428 
      x.read(self._iprot)
3429 
      self._iprot.readMessageEnd()
3430 
      raise x
3431 
    result = getVoucherAmount_result()
3432 
    result.read(self._iprot)
3433 
    self._iprot.readMessageEnd()
3434 
    if result.success is not None:
3435 
      return result.success
3436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3437 
 
3438 
  def getAllItemVouchers(self, itemId):
3439 
    """
3440 
    Parameters:
3441 
     - itemId
3442 
    """
3443 
    self.send_getAllItemVouchers(itemId)
3444 
    return self.recv_getAllItemVouchers()
3445 
 
3446 
  def send_getAllItemVouchers(self, itemId):
3447 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3448 
    args = getAllItemVouchers_args()
3449 
    args.itemId = itemId
3450 
    args.write(self._oprot)
3451 
    self._oprot.writeMessageEnd()
3452 
    self._oprot.trans.flush()
3453 
 
3454 
  def recv_getAllItemVouchers(self, ):
3455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3456 
    if mtype == TMessageType.EXCEPTION:
3457 
      x = TApplicationException()
3458 
      x.read(self._iprot)
3459 
      self._iprot.readMessageEnd()
3460 
      raise x
3461 
    result = getAllItemVouchers_result()
3462 
    result.read(self._iprot)
3463 
    self._iprot.readMessageEnd()
3464 
    if result.success is not None:
3465 
      return result.success
3466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3467 
 
3468 
  def isValidCatalogItemId(self, catalog_item_id):
3469 
    """
3470 
    Parameters:
3471 
     - catalog_item_id
3472 
    """
3473 
    self.send_isValidCatalogItemId(catalog_item_id)
3474 
    return self.recv_isValidCatalogItemId()
3475 
 
3476 
  def send_isValidCatalogItemId(self, catalog_item_id):
3477 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3478 
    args = isValidCatalogItemId_args()
3479 
    args.catalog_item_id = catalog_item_id
3480 
    args.write(self._oprot)
3481 
    self._oprot.writeMessageEnd()
3482 
    self._oprot.trans.flush()
3483 
 
3484 
  def recv_isValidCatalogItemId(self, ):
3485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3486 
    if mtype == TMessageType.EXCEPTION:
3487 
      x = TApplicationException()
3488 
      x.read(self._iprot)
3489 
      self._iprot.readMessageEnd()
3490 
      raise x
3491 
    result = isValidCatalogItemId_result()
3492 
    result.read(self._iprot)
3493 
    self._iprot.readMessageEnd()
3494 
    if result.success is not None:
3495 
      return result.success
3496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3497 
 
7330 amit.gupta 3498 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3499 
    """
3500 
    Parameters:
3501 
     - itemId
7330 amit.gupta 3502 
     - stateId
6039 amit.gupta 3503 
     - price
3504 
    """
7330 amit.gupta 3505 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3506 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3507 
 
7330 amit.gupta 3508 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3509 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3510 
    args = getVatPercentageForItem_args()
3511 
    args.itemId = itemId
7330 amit.gupta 3512 
    args.stateId = stateId
6039 amit.gupta 3513 
    args.price = price
3514 
    args.write(self._oprot)
3515 
    self._oprot.writeMessageEnd()
3516 
    self._oprot.trans.flush()
3517 
 
3518 
  def recv_getVatPercentageForItem(self, ):
3519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3520 
    if mtype == TMessageType.EXCEPTION:
3521 
      x = TApplicationException()
3522 
      x.read(self._iprot)
3523 
      self._iprot.readMessageEnd()
3524 
      raise x
3525 
    result = getVatPercentageForItem_result()
3526 
    result.read(self._iprot)
3527 
    self._iprot.readMessageEnd()
3528 
    if result.success is not None:
3529 
      return result.success
7340 amit.gupta 3530 
    if result.cex is not None:
3531 
      raise result.cex
6039 amit.gupta 3532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3533 
 
3534 
  def getVatAmountForItem(self, itemId, price):
3535 
    """
3536 
    Parameters:
3537 
     - itemId
3538 
     - price
3539 
    """
3540 
    self.send_getVatAmountForItem(itemId, price)
3541 
    return self.recv_getVatAmountForItem()
3542 
 
3543 
  def send_getVatAmountForItem(self, itemId, price):
3544 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3545 
    args = getVatAmountForItem_args()
3546 
    args.itemId = itemId
3547 
    args.price = price
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_getVatAmountForItem(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = getVatAmountForItem_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3562 
    if result.success is not None:
3563 
      return result.success
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3565 
 
6531 vikram.rag 3566 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3567 
    """
3568 
    Parameters:
3569 
     - offset
3570 
     - limit
3571 
    """
3572 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3573 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3574 
 
6531 vikram.rag 3575 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3576 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3577 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3578 
    args.offset = offset
3579 
    args.limit = limit
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
3594 
    if result.success is not None:
3595 
      return result.success
3596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3597 
 
6821 amar.kumar 3598 
  def getAllAliveItems(self, ):
3599 
    self.send_getAllAliveItems()
3600 
    return self.recv_getAllAliveItems()
3601 
 
3602 
  def send_getAllAliveItems(self, ):
3603 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3604 
    args = getAllAliveItems_args()
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_getAllAliveItems(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = getAllAliveItems_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3619 
    if result.success is not None:
3620 
      return result.success
3621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3622 
 
6921 anupam.sin 3623 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3624 
    """
3625 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3626 
 
6805 anupam.sin 3627 
    Parameters:
3628 
     - itemId
6921 anupam.sin 3629 
     - price
6805 anupam.sin 3630 
     - insurerId
3631 
     - quantity
3632 
    """
6921 anupam.sin 3633 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3634 
    return self.recv_getInsuranceAmount()
3635 
 
6921 anupam.sin 3636 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3637 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3638 
    args = getInsuranceAmount_args()
3639 
    args.itemId = itemId
6921 anupam.sin 3640 
    args.price = price
6805 anupam.sin 3641 
    args.insurerId = insurerId
3642 
    args.quantity = quantity
3643 
    args.write(self._oprot)
3644 
    self._oprot.writeMessageEnd()
3645 
    self._oprot.trans.flush()
3646 
 
3647 
  def recv_getInsuranceAmount(self, ):
3648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3649 
    if mtype == TMessageType.EXCEPTION:
3650 
      x = TApplicationException()
3651 
      x.read(self._iprot)
3652 
      self._iprot.readMessageEnd()
3653 
      raise x
3654 
    result = getInsuranceAmount_result()
3655 
    result.read(self._iprot)
3656 
    self._iprot.readMessageEnd()
3657 
    if result.success is not None:
3658 
      return result.success
3659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3660 
 
3661 
  def getInsurer(self, insurerId):
3662 
    """
3663 
    Parameters:
3664 
     - insurerId
3665 
    """
3666 
    self.send_getInsurer(insurerId)
3667 
    return self.recv_getInsurer()
3668 
 
3669 
  def send_getInsurer(self, insurerId):
3670 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3671 
    args = getInsurer_args()
3672 
    args.insurerId = insurerId
3673 
    args.write(self._oprot)
3674 
    self._oprot.writeMessageEnd()
3675 
    self._oprot.trans.flush()
3676 
 
3677 
  def recv_getInsurer(self, ):
3678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3679 
    if mtype == TMessageType.EXCEPTION:
3680 
      x = TApplicationException()
3681 
      x.read(self._iprot)
3682 
      self._iprot.readMessageEnd()
3683 
      raise x
3684 
    result = getInsurer_result()
3685 
    result.read(self._iprot)
3686 
    self._iprot.readMessageEnd()
3687 
    if result.success is not None:
3688 
      return result.success
3689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3690 
 
6838 vikram.rag 3691 
  def getAllInsurers(self, ):
3692 
    self.send_getAllInsurers()
3693 
    return self.recv_getAllInsurers()
6805 anupam.sin 3694 
 
6838 vikram.rag 3695 
  def send_getAllInsurers(self, ):
3696 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3697 
    args = getAllInsurers_args()
3698 
    args.write(self._oprot)
3699 
    self._oprot.writeMessageEnd()
3700 
    self._oprot.trans.flush()
3701 
 
3702 
  def recv_getAllInsurers(self, ):
3703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3704 
    if mtype == TMessageType.EXCEPTION:
3705 
      x = TApplicationException()
3706 
      x.read(self._iprot)
3707 
      self._iprot.readMessageEnd()
3708 
      raise x
3709 
    result = getAllInsurers_result()
3710 
    result.read(self._iprot)
3711 
    self._iprot.readMessageEnd()
3712 
    if result.success is not None:
3713 
      return result.success
3714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3715 
 
6962 rajveer 3716 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3717 
    """
3718 
    Parameters:
3719 
     - insurerId
3720 
     - amount
3721 
    """
3722 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3723 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3724 
 
6962 rajveer 3725 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3726 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3727 
    args = updateInsuranceDeclaredAmount_args()
3728 
    args.insurerId = insurerId
3729 
    args.amount = amount
3730 
    args.write(self._oprot)
3731 
    self._oprot.writeMessageEnd()
3732 
    self._oprot.trans.flush()
3733 
 
3734 
  def recv_updateInsuranceDeclaredAmount(self, ):
3735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3736 
    if mtype == TMessageType.EXCEPTION:
3737 
      x = TApplicationException()
3738 
      x.read(self._iprot)
3739 
      self._iprot.readMessageEnd()
3740 
      raise x
3741 
    result = updateInsuranceDeclaredAmount_result()
3742 
    result.read(self._iprot)
3743 
    self._iprot.readMessageEnd()
3744 
    return
3745 
 
7190 amar.kumar 3746 
  def getFreebieForItem(self, itemId):
3747 
    """
3748 
    Parameters:
3749 
     - itemId
3750 
    """
3751 
    self.send_getFreebieForItem(itemId)
3752 
    return self.recv_getFreebieForItem()
6962 rajveer 3753 
 
7190 amar.kumar 3754 
  def send_getFreebieForItem(self, itemId):
3755 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3756 
    args = getFreebieForItem_args()
3757 
    args.itemId = itemId
3758 
    args.write(self._oprot)
3759 
    self._oprot.writeMessageEnd()
3760 
    self._oprot.trans.flush()
3761 
 
3762 
  def recv_getFreebieForItem(self, ):
3763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3764 
    if mtype == TMessageType.EXCEPTION:
3765 
      x = TApplicationException()
3766 
      x.read(self._iprot)
3767 
      self._iprot.readMessageEnd()
3768 
      raise x
3769 
    result = getFreebieForItem_result()
3770 
    result.read(self._iprot)
3771 
    self._iprot.readMessageEnd()
3772 
    if result.success is not None:
3773 
      return result.success
3774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3775 
 
3776 
  def addOrUpdateFreebieForItem(self, freebieItem):
3777 
    """
3778 
    Parameters:
3779 
     - freebieItem
3780 
    """
3781 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3782 
    self.recv_addOrUpdateFreebieForItem()
3783 
 
3784 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3785 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3786 
    args = addOrUpdateFreebieForItem_args()
3787 
    args.freebieItem = freebieItem
3788 
    args.write(self._oprot)
3789 
    self._oprot.writeMessageEnd()
3790 
    self._oprot.trans.flush()
3791 
 
3792 
  def recv_addOrUpdateFreebieForItem(self, ):
3793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3794 
    if mtype == TMessageType.EXCEPTION:
3795 
      x = TApplicationException()
3796 
      x.read(self._iprot)
3797 
      self._iprot.readMessageEnd()
3798 
      raise x
3799 
    result = addOrUpdateFreebieForItem_result()
3800 
    result.read(self._iprot)
3801 
    self._iprot.readMessageEnd()
3802 
    return
3803 
 
7272 amit.gupta 3804 
  def addOrUpdateBrandInfo(self, brandInfo):
3805 
    """
3806 
    Parameters:
3807 
     - brandInfo
3808 
    """
3809 
    self.send_addOrUpdateBrandInfo(brandInfo)
3810 
    self.recv_addOrUpdateBrandInfo()
3811 
 
3812 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3813 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3814 
    args = addOrUpdateBrandInfo_args()
3815 
    args.brandInfo = brandInfo
3816 
    args.write(self._oprot)
3817 
    self._oprot.writeMessageEnd()
3818 
    self._oprot.trans.flush()
3819 
 
3820 
  def recv_addOrUpdateBrandInfo(self, ):
3821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3822 
    if mtype == TMessageType.EXCEPTION:
3823 
      x = TApplicationException()
3824 
      x.read(self._iprot)
3825 
      self._iprot.readMessageEnd()
3826 
      raise x
3827 
    result = addOrUpdateBrandInfo_result()
3828 
    result.read(self._iprot)
3829 
    self._iprot.readMessageEnd()
3830 
    return
3831 
 
3832 
  def getBrandInfo(self, ):
3833 
    self.send_getBrandInfo()
3834 
    return self.recv_getBrandInfo()
3835 
 
3836 
  def send_getBrandInfo(self, ):
3837 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3838 
    args = getBrandInfo_args()
3839 
    args.write(self._oprot)
3840 
    self._oprot.writeMessageEnd()
3841 
    self._oprot.trans.flush()
3842 
 
3843 
  def recv_getBrandInfo(self, ):
3844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3845 
    if mtype == TMessageType.EXCEPTION:
3846 
      x = TApplicationException()
3847 
      x.read(self._iprot)
3848 
      self._iprot.readMessageEnd()
3849 
      raise x
3850 
    result = getBrandInfo_result()
3851 
    result.read(self._iprot)
3852 
    self._iprot.readMessageEnd()
3853 
    if result.success is not None:
3854 
      return result.success
3855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3856 
 
7256 rajveer 3857 
  def getStorePricing(self, itemId):
3858 
    """
3859 
    Parameters:
3860 
     - itemId
3861 
    """
3862 
    self.send_getStorePricing(itemId)
3863 
    return self.recv_getStorePricing()
7190 amar.kumar 3864 
 
7256 rajveer 3865 
  def send_getStorePricing(self, itemId):
3866 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3867 
    args = getStorePricing_args()
3868 
    args.itemId = itemId
3869 
    args.write(self._oprot)
3870 
    self._oprot.writeMessageEnd()
3871 
    self._oprot.trans.flush()
3872 
 
3873 
  def recv_getStorePricing(self, ):
3874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3875 
    if mtype == TMessageType.EXCEPTION:
3876 
      x = TApplicationException()
3877 
      x.read(self._iprot)
3878 
      self._iprot.readMessageEnd()
3879 
      raise x
3880 
    result = getStorePricing_result()
3881 
    result.read(self._iprot)
3882 
    self._iprot.readMessageEnd()
3883 
    if result.success is not None:
3884 
      return result.success
3885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3886 
 
7306 rajveer 3887 
  def getStorePricings(self, itemIds):
3888 
    """
3889 
    Parameters:
3890 
     - itemIds
3891 
    """
3892 
    self.send_getStorePricings(itemIds)
3893 
    return self.recv_getStorePricings()
3894 
 
3895 
  def send_getStorePricings(self, itemIds):
3896 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3897 
    args = getStorePricings_args()
3898 
    args.itemIds = itemIds
3899 
    args.write(self._oprot)
3900 
    self._oprot.writeMessageEnd()
3901 
    self._oprot.trans.flush()
3902 
 
3903 
  def recv_getStorePricings(self, ):
3904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3905 
    if mtype == TMessageType.EXCEPTION:
3906 
      x = TApplicationException()
3907 
      x.read(self._iprot)
3908 
      self._iprot.readMessageEnd()
3909 
      raise x
3910 
    result = getStorePricings_result()
3911 
    result.read(self._iprot)
3912 
    self._iprot.readMessageEnd()
3913 
    if result.success is not None:
3914 
      return result.success
3915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3916 
 
7382 rajveer 3917 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3918 
    """
3919 
    Parameters:
3920 
     - sp
7382 rajveer 3921 
     - allColors
7265 rajveer 3922 
    """
7382 rajveer 3923 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3924 
    self.recv_updateStorePricing()
7256 rajveer 3925 
 
7382 rajveer 3926 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3927 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3928 
    args = updateStorePricing_args()
3929 
    args.sp = sp
7382 rajveer 3930 
    args.allColors = allColors
7265 rajveer 3931 
    args.write(self._oprot)
3932 
    self._oprot.writeMessageEnd()
3933 
    self._oprot.trans.flush()
3934 
 
3935 
  def recv_updateStorePricing(self, ):
3936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3937 
    if mtype == TMessageType.EXCEPTION:
3938 
      x = TApplicationException()
3939 
      x.read(self._iprot)
3940 
      self._iprot.readMessageEnd()
3941 
      raise x
3942 
    result = updateStorePricing_result()
3943 
    result.read(self._iprot)
3944 
    self._iprot.readMessageEnd()
3945 
    return
3946 
 
7281 kshitij.so 3947 
  def getAllAmazonListedItems(self, ):
3948 
    self.send_getAllAmazonListedItems()
3949 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3950 
 
7281 kshitij.so 3951 
  def send_getAllAmazonListedItems(self, ):
3952 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3953 
    args = getAllAmazonListedItems_args()
3954 
    args.write(self._oprot)
3955 
    self._oprot.writeMessageEnd()
3956 
    self._oprot.trans.flush()
3957 
 
3958 
  def recv_getAllAmazonListedItems(self, ):
3959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3960 
    if mtype == TMessageType.EXCEPTION:
3961 
      x = TApplicationException()
3962 
      x.read(self._iprot)
3963 
      self._iprot.readMessageEnd()
3964 
      raise x
3965 
    result = getAllAmazonListedItems_result()
3966 
    result.read(self._iprot)
3967 
    self._iprot.readMessageEnd()
3968 
    if result.success is not None:
3969 
      return result.success
3970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3971 
 
3972 
  def getAmazonItemDetails(self, itemId):
3973 
    """
3974 
    Parameters:
3975 
     - itemId
3976 
    """
3977 
    self.send_getAmazonItemDetails(itemId)
3978 
    return self.recv_getAmazonItemDetails()
3979 
 
3980 
  def send_getAmazonItemDetails(self, itemId):
3981 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3982 
    args = getAmazonItemDetails_args()
3983 
    args.itemId = itemId
3984 
    args.write(self._oprot)
3985 
    self._oprot.writeMessageEnd()
3986 
    self._oprot.trans.flush()
3987 
 
3988 
  def recv_getAmazonItemDetails(self, ):
3989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3990 
    if mtype == TMessageType.EXCEPTION:
3991 
      x = TApplicationException()
3992 
      x.read(self._iprot)
3993 
      self._iprot.readMessageEnd()
3994 
      raise x
3995 
    result = getAmazonItemDetails_result()
3996 
    result.read(self._iprot)
3997 
    self._iprot.readMessageEnd()
3998 
    if result.success is not None:
3999 
      return result.success
4000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4001 
 
8168 kshitij.so 4002 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4003 
    """
4004 
    Parameters:
8168 kshitij.so 4005 
     - amazonlisted
7281 kshitij.so 4006 
    """
8168 kshitij.so 4007 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4008 
    self.recv_updateAmazonItemDetails()
4009 
 
8168 kshitij.so 4010 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4011 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4012 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4013 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4014 
    args.write(self._oprot)
4015 
    self._oprot.writeMessageEnd()
4016 
    self._oprot.trans.flush()
4017 
 
4018 
  def recv_updateAmazonItemDetails(self, ):
4019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4020 
    if mtype == TMessageType.EXCEPTION:
4021 
      x = TApplicationException()
4022 
      x.read(self._iprot)
4023 
      self._iprot.readMessageEnd()
4024 
      raise x
4025 
    result = updateAmazonItemDetails_result()
4026 
    result.read(self._iprot)
4027 
    self._iprot.readMessageEnd()
4028 
    return
4029 
 
4030 
  def addAmazonItem(self, amazonlisted):
4031 
    """
4032 
    Parameters:
4033 
     - amazonlisted
4034 
    """
4035 
    self.send_addAmazonItem(amazonlisted)
4036 
    self.recv_addAmazonItem()
4037 
 
4038 
  def send_addAmazonItem(self, amazonlisted):
4039 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4040 
    args = addAmazonItem_args()
4041 
    args.amazonlisted = amazonlisted
4042 
    args.write(self._oprot)
4043 
    self._oprot.writeMessageEnd()
4044 
    self._oprot.trans.flush()
4045 
 
4046 
  def recv_addAmazonItem(self, ):
4047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4048 
    if mtype == TMessageType.EXCEPTION:
4049 
      x = TApplicationException()
4050 
      x.read(self._iprot)
4051 
      self._iprot.readMessageEnd()
4052 
      raise x
4053 
    result = addAmazonItem_result()
4054 
    result.read(self._iprot)
4055 
    self._iprot.readMessageEnd()
4056 
    return
4057 
 
7291 vikram.rag 4058 
  def getAsinItems(self, ):
4059 
    self.send_getAsinItems()
4060 
    return self.recv_getAsinItems()
7281 kshitij.so 4061 
 
7291 vikram.rag 4062 
  def send_getAsinItems(self, ):
4063 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4064 
    args = getAsinItems_args()
4065 
    args.write(self._oprot)
4066 
    self._oprot.writeMessageEnd()
4067 
    self._oprot.trans.flush()
4068 
 
4069 
  def recv_getAsinItems(self, ):
4070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4071 
    if mtype == TMessageType.EXCEPTION:
4072 
      x = TApplicationException()
4073 
      x.read(self._iprot)
4074 
      self._iprot.readMessageEnd()
4075 
      raise x
4076 
    result = getAsinItems_result()
4077 
    result.read(self._iprot)
4078 
    self._iprot.readMessageEnd()
4079 
    if result.success is not None:
4080 
      return result.success
4081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4082 
 
4083 
  def getAllFbaListedItems(self, ):
4084 
    self.send_getAllFbaListedItems()
4085 
    return self.recv_getAllFbaListedItems()
4086 
 
4087 
  def send_getAllFbaListedItems(self, ):
4088 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4089 
    args = getAllFbaListedItems_args()
4090 
    args.write(self._oprot)
4091 
    self._oprot.writeMessageEnd()
4092 
    self._oprot.trans.flush()
4093 
 
4094 
  def recv_getAllFbaListedItems(self, ):
4095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4096 
    if mtype == TMessageType.EXCEPTION:
4097 
      x = TApplicationException()
4098 
      x.read(self._iprot)
4099 
      self._iprot.readMessageEnd()
4100 
      raise x
4101 
    result = getAllFbaListedItems_result()
4102 
    result.read(self._iprot)
4103 
    self._iprot.readMessageEnd()
4104 
    if result.success is not None:
4105 
      return result.success
4106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4107 
 
4108 
  def getAllNonFbaListedItems(self, ):
4109 
    self.send_getAllNonFbaListedItems()
4110 
    return self.recv_getAllNonFbaListedItems()
4111 
 
4112 
  def send_getAllNonFbaListedItems(self, ):
4113 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4114 
    args = getAllNonFbaListedItems_args()
4115 
    args.write(self._oprot)
4116 
    self._oprot.writeMessageEnd()
4117 
    self._oprot.trans.flush()
4118 
 
4119 
  def recv_getAllNonFbaListedItems(self, ):
4120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4121 
    if mtype == TMessageType.EXCEPTION:
4122 
      x = TApplicationException()
4123 
      x.read(self._iprot)
4124 
      self._iprot.readMessageEnd()
4125 
      raise x
4126 
    result = getAllNonFbaListedItems_result()
4127 
    result.read(self._iprot)
4128 
    self._iprot.readMessageEnd()
4129 
    if result.success is not None:
4130 
      return result.success
4131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4132 
 
7460 kshitij.so 4133 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4134 
    """
4135 
    Parameters:
4136 
     - itemId
4137 
     - holdInventory
4138 
     - defaultInventory
4139 
    """
4140 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4141 
    return self.recv_updateItemInventory()
7291 vikram.rag 4142 
 
7460 kshitij.so 4143 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4144 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4145 
    args = updateItemInventory_args()
4146 
    args.itemId = itemId
4147 
    args.holdInventory = holdInventory
4148 
    args.defaultInventory = defaultInventory
4149 
    args.write(self._oprot)
4150 
    self._oprot.writeMessageEnd()
4151 
    self._oprot.trans.flush()
4152 
 
4153 
  def recv_updateItemInventory(self, ):
4154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4155 
    if mtype == TMessageType.EXCEPTION:
4156 
      x = TApplicationException()
4157 
      x.read(self._iprot)
4158 
      self._iprot.readMessageEnd()
4159 
      raise x
4160 
    result = updateItemInventory_result()
4161 
    result.read(self._iprot)
4162 
    self._iprot.readMessageEnd()
4163 
    if result.success is not None:
4164 
      return result.success
4165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4166 
 
7770 kshitij.so 4167 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4168 
    """
4169 
    Parameters:
4170 
     - type
4171 
     - sku
4172 
     - timestamp
4173 
    """
4174 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4175 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4176 
 
7770 kshitij.so 4177 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4178 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4179 
    args = updateTimestampForAmazonFeeds_args()
4180 
    args.type = type
4181 
    args.sku = sku
4182 
    args.timestamp = timestamp
4183 
    args.write(self._oprot)
4184 
    self._oprot.writeMessageEnd()
4185 
    self._oprot.trans.flush()
4186 
 
4187 
  def recv_updateTimestampForAmazonFeeds(self, ):
4188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4189 
    if mtype == TMessageType.EXCEPTION:
4190 
      x = TApplicationException()
4191 
      x.read(self._iprot)
4192 
      self._iprot.readMessageEnd()
4193 
      raise x
4194 
    result = updateTimestampForAmazonFeeds_result()
4195 
    result.read(self._iprot)
4196 
    self._iprot.readMessageEnd()
4197 
    if result.success is not None:
4198 
      return result.success
4199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4200 
 
7897 amar.kumar 4201 
  def getAllParentCategories(self, ):
4202 
    self.send_getAllParentCategories()
4203 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4204 
 
7897 amar.kumar 4205 
  def send_getAllParentCategories(self, ):
4206 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4207 
    args = getAllParentCategories_args()
4208 
    args.write(self._oprot)
4209 
    self._oprot.writeMessageEnd()
4210 
    self._oprot.trans.flush()
4211 
 
4212 
  def recv_getAllParentCategories(self, ):
4213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4214 
    if mtype == TMessageType.EXCEPTION:
4215 
      x = TApplicationException()
4216 
      x.read(self._iprot)
4217 
      self._iprot.readMessageEnd()
4218 
      raise x
4219 
    result = getAllParentCategories_result()
4220 
    result.read(self._iprot)
4221 
    self._iprot.readMessageEnd()
4222 
    if result.success is not None:
4223 
      return result.success
4224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4225 
 
7977 kshitij.so 4226 
  def addPageViewEvent(self, pageViewEvents):
4227 
    """
4228 
    Parameters:
4229 
     - pageViewEvents
4230 
    """
4231 
    self.send_addPageViewEvent(pageViewEvents)
4232 
    self.recv_addPageViewEvent()
7897 amar.kumar 4233 
 
7977 kshitij.so 4234 
  def send_addPageViewEvent(self, pageViewEvents):
4235 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4236 
    args = addPageViewEvent_args()
4237 
    args.pageViewEvents = pageViewEvents
4238 
    args.write(self._oprot)
4239 
    self._oprot.writeMessageEnd()
4240 
    self._oprot.trans.flush()
4241 
 
4242 
  def recv_addPageViewEvent(self, ):
4243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4244 
    if mtype == TMessageType.EXCEPTION:
4245 
      x = TApplicationException()
4246 
      x.read(self._iprot)
4247 
      self._iprot.readMessageEnd()
4248 
      raise x
4249 
    result = addPageViewEvent_result()
4250 
    result.read(self._iprot)
4251 
    self._iprot.readMessageEnd()
4252 
    return
4253 
 
4254 
  def addCartEvent(self, cartEvents):
4255 
    """
4256 
    Parameters:
4257 
     - cartEvents
4258 
    """
4259 
    self.send_addCartEvent(cartEvents)
4260 
    self.recv_addCartEvent()
4261 
 
4262 
  def send_addCartEvent(self, cartEvents):
4263 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4264 
    args = addCartEvent_args()
4265 
    args.cartEvents = cartEvents
4266 
    args.write(self._oprot)
4267 
    self._oprot.writeMessageEnd()
4268 
    self._oprot.trans.flush()
4269 
 
4270 
  def recv_addCartEvent(self, ):
4271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4272 
    if mtype == TMessageType.EXCEPTION:
4273 
      x = TApplicationException()
4274 
      x.read(self._iprot)
4275 
      self._iprot.readMessageEnd()
4276 
      raise x
4277 
    result = addCartEvent_result()
4278 
    result.read(self._iprot)
4279 
    self._iprot.readMessageEnd()
4280 
    return
4281 
 
8182 amar.kumar 4282 
  def addEbayItem(self, ebayItem):
4283 
    """
4284 
    Parameters:
4285 
     - ebayItem
4286 
    """
4287 
    self.send_addEbayItem(ebayItem)
4288 
    self.recv_addEbayItem()
4289 
 
4290 
  def send_addEbayItem(self, ebayItem):
4291 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4292 
    args = addEbayItem_args()
4293 
    args.ebayItem = ebayItem
4294 
    args.write(self._oprot)
4295 
    self._oprot.writeMessageEnd()
4296 
    self._oprot.trans.flush()
4297 
 
4298 
  def recv_addEbayItem(self, ):
4299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4300 
    if mtype == TMessageType.EXCEPTION:
4301 
      x = TApplicationException()
4302 
      x.read(self._iprot)
4303 
      self._iprot.readMessageEnd()
4304 
      raise x
4305 
    result = addEbayItem_result()
4306 
    result.read(self._iprot)
4307 
    self._iprot.readMessageEnd()
4308 
    return
4309 
 
4310 
  def getEbayItem(self, listingId):
4311 
    """
4312 
    Parameters:
4313 
     - listingId
4314 
    """
4315 
    self.send_getEbayItem(listingId)
4316 
    return self.recv_getEbayItem()
4317 
 
4318 
  def send_getEbayItem(self, listingId):
4319 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4320 
    args = getEbayItem_args()
4321 
    args.listingId = listingId
4322 
    args.write(self._oprot)
4323 
    self._oprot.writeMessageEnd()
4324 
    self._oprot.trans.flush()
4325 
 
4326 
  def recv_getEbayItem(self, ):
4327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4328 
    if mtype == TMessageType.EXCEPTION:
4329 
      x = TApplicationException()
4330 
      x.read(self._iprot)
4331 
      self._iprot.readMessageEnd()
4332 
      raise x
4333 
    result = getEbayItem_result()
4334 
    result.read(self._iprot)
4335 
    self._iprot.readMessageEnd()
4336 
    if result.success is not None:
4337 
      return result.success
4338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4339 
 
4340 
  def updateEbayItem(self, ebayItem):
4341 
    """
4342 
    Parameters:
4343 
     - ebayItem
4344 
    """
4345 
    self.send_updateEbayItem(ebayItem)
4346 
    self.recv_updateEbayItem()
4347 
 
4348 
  def send_updateEbayItem(self, ebayItem):
4349 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4350 
    args = updateEbayItem_args()
4351 
    args.ebayItem = ebayItem
4352 
    args.write(self._oprot)
4353 
    self._oprot.writeMessageEnd()
4354 
    self._oprot.trans.flush()
4355 
 
4356 
  def recv_updateEbayItem(self, ):
4357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4358 
    if mtype == TMessageType.EXCEPTION:
4359 
      x = TApplicationException()
4360 
      x.read(self._iprot)
4361 
      self._iprot.readMessageEnd()
4362 
      raise x
4363 
    result = updateEbayItem_result()
4364 
    result.read(self._iprot)
4365 
    self._iprot.readMessageEnd()
4366 
    return
4367 
 
8139 kshitij.so 4368 
  def getAmazonListedItems(self, offset, limit):
4369 
    """
4370 
    Parameters:
4371 
     - offset
4372 
     - limit
4373 
    """
4374 
    self.send_getAmazonListedItems(offset, limit)
4375 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4376 
 
8139 kshitij.so 4377 
  def send_getAmazonListedItems(self, offset, limit):
4378 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4379 
    args = getAmazonListedItems_args()
4380 
    args.offset = offset
4381 
    args.limit = limit
4382 
    args.write(self._oprot)
4383 
    self._oprot.writeMessageEnd()
4384 
    self._oprot.trans.flush()
4385 
 
4386 
  def recv_getAmazonListedItems(self, ):
4387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4388 
    if mtype == TMessageType.EXCEPTION:
4389 
      x = TApplicationException()
4390 
      x.read(self._iprot)
4391 
      self._iprot.readMessageEnd()
4392 
      raise x
4393 
    result = getAmazonListedItems_result()
4394 
    result.read(self._iprot)
4395 
    self._iprot.readMessageEnd()
4396 
    if result.success is not None:
4397 
      return result.success
4398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4399 
 
8168 kshitij.so 4400 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4401 
    """
4402 
    Parameters:
4403 
     - amazonlisted
4404 
    """
4405 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4406 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4407 
 
8168 kshitij.so 4408 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4409 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4410 
    args = updateAmazonAttributesInBulk_args()
4411 
    args.amazonlisted = amazonlisted
4412 
    args.write(self._oprot)
4413 
    self._oprot.writeMessageEnd()
4414 
    self._oprot.trans.flush()
4415 
 
4416 
  def recv_updateAmazonAttributesInBulk(self, ):
4417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4418 
    if mtype == TMessageType.EXCEPTION:
4419 
      x = TApplicationException()
4420 
      x.read(self._iprot)
4421 
      self._iprot.readMessageEnd()
4422 
      raise x
4423 
    result = updateAmazonAttributesInBulk_result()
4424 
    result.read(self._iprot)
4425 
    self._iprot.readMessageEnd()
4426 
    if result.success is not None:
4427 
      return result.success
4428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4429 
 
8379 vikram.rag 4430 
  def getAllItemstoListOnFba(self, ):
4431 
    self.send_getAllItemstoListOnFba()
4432 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4433 
 
8379 vikram.rag 4434 
  def send_getAllItemstoListOnFba(self, ):
4435 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4436 
    args = getAllItemstoListOnFba_args()
4437 
    args.write(self._oprot)
4438 
    self._oprot.writeMessageEnd()
4439 
    self._oprot.trans.flush()
4440 
 
4441 
  def recv_getAllItemstoListOnFba(self, ):
4442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4443 
    if mtype == TMessageType.EXCEPTION:
4444 
      x = TApplicationException()
4445 
      x.read(self._iprot)
4446 
      self._iprot.readMessageEnd()
4447 
      raise x
4448 
    result = getAllItemstoListOnFba_result()
4449 
    result.read(self._iprot)
4450 
    self._iprot.readMessageEnd()
4451 
    if result.success is not None:
4452 
      return result.success
4453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4454 
 
4455 
  def getAllItemstoListOnNonFba(self, ):
4456 
    self.send_getAllItemstoListOnNonFba()
4457 
    return self.recv_getAllItemstoListOnNonFba()
4458 
 
4459 
  def send_getAllItemstoListOnNonFba(self, ):
4460 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4461 
    args = getAllItemstoListOnNonFba_args()
4462 
    args.write(self._oprot)
4463 
    self._oprot.writeMessageEnd()
4464 
    self._oprot.trans.flush()
4465 
 
4466 
  def recv_getAllItemstoListOnNonFba(self, ):
4467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4468 
    if mtype == TMessageType.EXCEPTION:
4469 
      x = TApplicationException()
4470 
      x.read(self._iprot)
4471 
      self._iprot.readMessageEnd()
4472 
      raise x
4473 
    result = getAllItemstoListOnNonFba_result()
4474 
    result.read(self._iprot)
4475 
    self._iprot.readMessageEnd()
4476 
    if result.success is not None:
4477 
      return result.success
4478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4479 
 
4480 
 
5944 mandeep.dh 4481 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4482 
  def __init__(self, handler):
4483 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4484 
    self._processMap["addItem"] = Processor.process_addItem
4485 
    self._processMap["updateItem"] = Processor.process_updateItem
4486 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4487 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4488 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4489 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4490 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4491 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4492 
    self._processMap["getItem"] = Processor.process_getItem
4493 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4494 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4495 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4496 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4497 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4498 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4499 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4500 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4501 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4502 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4503 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4504 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4505 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4506 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4507 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4508 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4509 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4510 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4511 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4512 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4513 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4514 
    self._processMap["addCategory"] = Processor.process_addCategory
4515 
    self._processMap["getCategory"] = Processor.process_getCategory
4516 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4517 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4518 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4519 
    self._processMap["addTag"] = Processor.process_addTag
4520 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4521 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4522 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4523 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4524 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4525 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4526 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4527 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4528 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4529 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4530 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4531 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 4532 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 4533 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4534 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 4535 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
4536 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
4537 
    self._processMap["addCampaign"] = Processor.process_addCampaign
4538 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
4539 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
4540 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
5944 mandeep.dh 4541 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4542 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4543 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4544 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4545 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4546 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4547 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4548 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4549 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4550 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4551 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4552 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4553 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4554 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4555 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4556 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4557 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4558 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4559 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4560 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4561 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4562 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4563 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4564 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4565 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4566 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4567 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4568 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4569 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4570 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4571 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4572 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4573 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4574 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4575 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4576 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4577 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4578 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4579 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4580 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4581 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4582 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4583 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4584 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4585 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4586 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4587 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4588 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4589 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4590 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4591 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4592 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4593 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4594 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4595 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4596 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4597 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4598 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 4599 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
4600 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
5944 mandeep.dh 4601 
 
4602 
  def process(self, iprot, oprot):
4603 
    (name, type, seqid) = iprot.readMessageBegin()
4604 
    if name not in self._processMap:
4605 
      iprot.skip(TType.STRUCT)
4606 
      iprot.readMessageEnd()
4607 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4608 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4609 
      x.write(oprot)
4610 
      oprot.writeMessageEnd()
4611 
      oprot.trans.flush()
4612 
      return
4613 
    else:
4614 
      self._processMap[name](self, seqid, iprot, oprot)
4615 
    return True
4616 
 
4617 
  def process_addItem(self, seqid, iprot, oprot):
4618 
    args = addItem_args()
4619 
    args.read(iprot)
4620 
    iprot.readMessageEnd()
4621 
    result = addItem_result()
4622 
    try:
4623 
      result.success = self._handler.addItem(args.item)
4624 
    except CatalogServiceException, cex:
4625 
      result.cex = cex
4626 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4627 
    result.write(oprot)
4628 
    oprot.writeMessageEnd()
4629 
    oprot.trans.flush()
4630 
 
4631 
  def process_updateItem(self, seqid, iprot, oprot):
4632 
    args = updateItem_args()
4633 
    args.read(iprot)
4634 
    iprot.readMessageEnd()
4635 
    result = updateItem_result()
4636 
    try:
4637 
      result.success = self._handler.updateItem(args.item)
4638 
    except CatalogServiceException, cex:
4639 
      result.cex = cex
4640 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4641 
    result.write(oprot)
4642 
    oprot.writeMessageEnd()
4643 
    oprot.trans.flush()
4644 
 
4645 
  def process_isActive(self, seqid, iprot, oprot):
4646 
    args = isActive_args()
4647 
    args.read(iprot)
4648 
    iprot.readMessageEnd()
4649 
    result = isActive_result()
4650 
    try:
4651 
      result.success = self._handler.isActive(args.itemId)
4652 
    except CatalogServiceException, isex:
4653 
      result.isex = isex
4654 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4655 
    result.write(oprot)
4656 
    oprot.writeMessageEnd()
4657 
    oprot.trans.flush()
4658 
 
7438 amit.gupta 4659 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4660 
    args = getItemsStatus_args()
4661 
    args.read(iprot)
4662 
    iprot.readMessageEnd()
4663 
    result = getItemsStatus_result()
4664 
    try:
4665 
      result.success = self._handler.getItemsStatus(args.itemIds)
4666 
    except CatalogServiceException, isex:
4667 
      result.isex = isex
4668 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4669 
    result.write(oprot)
4670 
    oprot.writeMessageEnd()
4671 
    oprot.trans.flush()
4672 
 
5944 mandeep.dh 4673 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4674 
    args = getItemStatusDescription_args()
4675 
    args.read(iprot)
4676 
    iprot.readMessageEnd()
4677 
    result = getItemStatusDescription_result()
4678 
    try:
4679 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4680 
    except CatalogServiceException, isex:
4681 
      result.isex = isex
4682 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
4687 
  def process_startItemOn(self, seqid, iprot, oprot):
4688 
    args = startItemOn_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = startItemOn_result()
4692 
    try:
4693 
      self._handler.startItemOn(args.item_id, args.timestamp)
4694 
    except CatalogServiceException, cex:
4695 
      result.cex = cex
4696 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4697 
    result.write(oprot)
4698 
    oprot.writeMessageEnd()
4699 
    oprot.trans.flush()
4700 
 
4701 
  def process_retireItemOn(self, seqid, iprot, oprot):
4702 
    args = retireItemOn_args()
4703 
    args.read(iprot)
4704 
    iprot.readMessageEnd()
4705 
    result = retireItemOn_result()
4706 
    try:
4707 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4708 
    except CatalogServiceException, cex:
4709 
      result.cex = cex
4710 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4711 
    result.write(oprot)
4712 
    oprot.writeMessageEnd()
4713 
    oprot.trans.flush()
4714 
 
4715 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4716 
    args = changeItemStatus_args()
4717 
    args.read(iprot)
4718 
    iprot.readMessageEnd()
4719 
    result = changeItemStatus_result()
4720 
    try:
4721 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4722 
    except CatalogServiceException, cex:
4723 
      result.cex = cex
4724 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4725 
    result.write(oprot)
4726 
    oprot.writeMessageEnd()
4727 
    oprot.trans.flush()
4728 
 
4729 
  def process_getItem(self, seqid, iprot, oprot):
4730 
    args = getItem_args()
4731 
    args.read(iprot)
4732 
    iprot.readMessageEnd()
4733 
    result = getItem_result()
4734 
    try:
4735 
      result.success = self._handler.getItem(args.item_id)
4736 
    except CatalogServiceException, cex:
4737 
      result.cex = cex
4738 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4739 
    result.write(oprot)
4740 
    oprot.writeMessageEnd()
4741 
    oprot.trans.flush()
4742 
 
4743 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4744 
    args = getItemsByCatalogId_args()
4745 
    args.read(iprot)
4746 
    iprot.readMessageEnd()
4747 
    result = getItemsByCatalogId_result()
4748 
    try:
4749 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4750 
    except CatalogServiceException, cex:
4751 
      result.cex = cex
4752 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4753 
    result.write(oprot)
4754 
    oprot.writeMessageEnd()
4755 
    oprot.trans.flush()
4756 
 
4757 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4758 
    args = getValidItemsByCatalogId_args()
4759 
    args.read(iprot)
4760 
    iprot.readMessageEnd()
4761 
    result = getValidItemsByCatalogId_result()
4762 
    try:
4763 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4764 
    except CatalogServiceException, cex:
4765 
      result.cex = cex
4766 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4767 
    result.write(oprot)
4768 
    oprot.writeMessageEnd()
4769 
    oprot.trans.flush()
4770 
 
4771 
  def process_getAllItems(self, seqid, iprot, oprot):
4772 
    args = getAllItems_args()
4773 
    args.read(iprot)
4774 
    iprot.readMessageEnd()
4775 
    result = getAllItems_result()
4776 
    try:
4777 
      result.success = self._handler.getAllItems(args.isActive)
4778 
    except CatalogServiceException, cex:
4779 
      result.cex = cex
4780 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4781 
    result.write(oprot)
4782 
    oprot.writeMessageEnd()
4783 
    oprot.trans.flush()
4784 
 
4785 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4786 
    args = getAllItemsByStatus_args()
4787 
    args.read(iprot)
4788 
    iprot.readMessageEnd()
4789 
    result = getAllItemsByStatus_result()
4790 
    try:
4791 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4792 
    except CatalogServiceException, cex:
4793 
      result.cex = cex
4794 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4795 
    result.write(oprot)
4796 
    oprot.writeMessageEnd()
4797 
    oprot.trans.flush()
4798 
 
4799 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4800 
    args = markItemAsContentComplete_args()
4801 
    args.read(iprot)
4802 
    iprot.readMessageEnd()
4803 
    result = markItemAsContentComplete_result()
4804 
    try:
4805 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4806 
    except CatalogServiceException, cex:
4807 
      result.cex = cex
4808 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4809 
    result.write(oprot)
4810 
    oprot.writeMessageEnd()
4811 
    oprot.trans.flush()
4812 
 
4813 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4814 
    args = getAllItemsInRange_args()
4815 
    args.read(iprot)
4816 
    iprot.readMessageEnd()
4817 
    result = getAllItemsInRange_result()
4818 
    try:
4819 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4820 
    except CatalogServiceException, cex:
4821 
      result.cex = cex
4822 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4823 
    result.write(oprot)
4824 
    oprot.writeMessageEnd()
4825 
    oprot.trans.flush()
4826 
 
4827 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4828 
    args = getAllItemsByStatusInRange_args()
4829 
    args.read(iprot)
4830 
    iprot.readMessageEnd()
4831 
    result = getAllItemsByStatusInRange_result()
4832 
    try:
4833 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4834 
    except CatalogServiceException, cex:
4835 
      result.cex = cex
4836 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4837 
    result.write(oprot)
4838 
    oprot.writeMessageEnd()
4839 
    oprot.trans.flush()
4840 
 
4841 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4842 
    args = getItemCountByStatus_args()
4843 
    args.read(iprot)
4844 
    iprot.readMessageEnd()
4845 
    result = getItemCountByStatus_result()
4846 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4847 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4848 
    result.write(oprot)
4849 
    oprot.writeMessageEnd()
4850 
    oprot.trans.flush()
4851 
 
4852 
  def process_getBestSellers(self, seqid, iprot, oprot):
4853 
    args = getBestSellers_args()
4854 
    args.read(iprot)
4855 
    iprot.readMessageEnd()
4856 
    result = getBestSellers_result()
4857 
    try:
4858 
      result.success = self._handler.getBestSellers()
4859 
    except CatalogServiceException, isex:
4860 
      result.isex = isex
4861 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4862 
    result.write(oprot)
4863 
    oprot.writeMessageEnd()
4864 
    oprot.trans.flush()
4865 
 
4866 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4867 
    args = getBestSellersCatalogIds_args()
4868 
    args.read(iprot)
4869 
    iprot.readMessageEnd()
4870 
    result = getBestSellersCatalogIds_result()
4871 
    try:
4872 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4873 
    except CatalogServiceException, cex:
4874 
      result.cex = cex
4875 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4876 
    result.write(oprot)
4877 
    oprot.writeMessageEnd()
4878 
    oprot.trans.flush()
4879 
 
4880 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4881 
    args = getBestSellersCount_args()
4882 
    args.read(iprot)
4883 
    iprot.readMessageEnd()
4884 
    result = getBestSellersCount_result()
4885 
    try:
4886 
      result.success = self._handler.getBestSellersCount()
4887 
    except CatalogServiceException, cex:
4888 
      result.cex = cex
4889 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4890 
    result.write(oprot)
4891 
    oprot.writeMessageEnd()
4892 
    oprot.trans.flush()
4893 
 
4894 
  def process_getBestDeals(self, seqid, iprot, oprot):
4895 
    args = getBestDeals_args()
4896 
    args.read(iprot)
4897 
    iprot.readMessageEnd()
4898 
    result = getBestDeals_result()
4899 
    try:
4900 
      result.success = self._handler.getBestDeals()
4901 
    except CatalogServiceException, isex:
4902 
      result.isex = isex
4903 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4904 
    result.write(oprot)
4905 
    oprot.writeMessageEnd()
4906 
    oprot.trans.flush()
4907 
 
4908 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4909 
    args = getBestDealsCatalogIds_args()
4910 
    args.read(iprot)
4911 
    iprot.readMessageEnd()
4912 
    result = getBestDealsCatalogIds_result()
4913 
    try:
4914 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4915 
    except CatalogServiceException, cex:
4916 
      result.cex = cex
4917 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4918 
    result.write(oprot)
4919 
    oprot.writeMessageEnd()
4920 
    oprot.trans.flush()
4921 
 
4922 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4923 
    args = getBestDealsCount_args()
4924 
    args.read(iprot)
4925 
    iprot.readMessageEnd()
4926 
    result = getBestDealsCount_result()
4927 
    try:
4928 
      result.success = self._handler.getBestDealsCount()
4929 
    except CatalogServiceException, cex:
4930 
      result.cex = cex
4931 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4932 
    result.write(oprot)
4933 
    oprot.writeMessageEnd()
4934 
    oprot.trans.flush()
4935 
 
4936 
  def process_getComingSoon(self, seqid, iprot, oprot):
4937 
    args = getComingSoon_args()
4938 
    args.read(iprot)
4939 
    iprot.readMessageEnd()
4940 
    result = getComingSoon_result()
4941 
    try:
4942 
      result.success = self._handler.getComingSoon()
4943 
    except CatalogServiceException, isex:
4944 
      result.isex = isex
4945 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4946 
    result.write(oprot)
4947 
    oprot.writeMessageEnd()
4948 
    oprot.trans.flush()
4949 
 
4950 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4951 
    args = getComingSoonCatalogIds_args()
4952 
    args.read(iprot)
4953 
    iprot.readMessageEnd()
4954 
    result = getComingSoonCatalogIds_result()
4955 
    try:
4956 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4957 
    except CatalogServiceException, cex:
4958 
      result.cex = cex
4959 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4960 
    result.write(oprot)
4961 
    oprot.writeMessageEnd()
4962 
    oprot.trans.flush()
4963 
 
4964 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4965 
    args = getComingSoonCount_args()
4966 
    args.read(iprot)
4967 
    iprot.readMessageEnd()
4968 
    result = getComingSoonCount_result()
4969 
    try:
4970 
      result.success = self._handler.getComingSoonCount()
4971 
    except CatalogServiceException, cex:
4972 
      result.cex = cex
4973 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4974 
    result.write(oprot)
4975 
    oprot.writeMessageEnd()
4976 
    oprot.trans.flush()
4977 
 
4978 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4979 
    args = getLatestArrivals_args()
4980 
    args.read(iprot)
4981 
    iprot.readMessageEnd()
4982 
    result = getLatestArrivals_result()
4983 
    try:
4984 
      result.success = self._handler.getLatestArrivals()
4985 
    except CatalogServiceException, isex:
4986 
      result.isex = isex
4987 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4988 
    result.write(oprot)
4989 
    oprot.writeMessageEnd()
4990 
    oprot.trans.flush()
4991 
 
4992 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4993 
    args = getLatestArrivalsCatalogIds_args()
4994 
    args.read(iprot)
4995 
    iprot.readMessageEnd()
4996 
    result = getLatestArrivalsCatalogIds_result()
4997 
    try:
4998 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4999 
    except CatalogServiceException, cex:
5000 
      result.cex = cex
5001 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5002 
    result.write(oprot)
5003 
    oprot.writeMessageEnd()
5004 
    oprot.trans.flush()
5005 
 
5006 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5007 
    args = getLatestArrivalsCount_args()
5008 
    args.read(iprot)
5009 
    iprot.readMessageEnd()
5010 
    result = getLatestArrivalsCount_result()
5011 
    try:
5012 
      result.success = self._handler.getLatestArrivalsCount()
5013 
    except CatalogServiceException, cex:
5014 
      result.cex = cex
5015 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5016 
    result.write(oprot)
5017 
    oprot.writeMessageEnd()
5018 
    oprot.trans.flush()
5019 
 
5020 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5021 
    args = generateNewEntityID_args()
5022 
    args.read(iprot)
5023 
    iprot.readMessageEnd()
5024 
    result = generateNewEntityID_result()
5025 
    result.success = self._handler.generateNewEntityID()
5026 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5027 
    result.write(oprot)
5028 
    oprot.writeMessageEnd()
5029 
    oprot.trans.flush()
5030 
 
5031 
  def process_addCategory(self, seqid, iprot, oprot):
5032 
    args = addCategory_args()
5033 
    args.read(iprot)
5034 
    iprot.readMessageEnd()
5035 
    result = addCategory_result()
5036 
    result.success = self._handler.addCategory(args.category)
5037 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5038 
    result.write(oprot)
5039 
    oprot.writeMessageEnd()
5040 
    oprot.trans.flush()
5041 
 
5042 
  def process_getCategory(self, seqid, iprot, oprot):
5043 
    args = getCategory_args()
5044 
    args.read(iprot)
5045 
    iprot.readMessageEnd()
5046 
    result = getCategory_result()
5047 
    result.success = self._handler.getCategory(args.id)
5048 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5049 
    result.write(oprot)
5050 
    oprot.writeMessageEnd()
5051 
    oprot.trans.flush()
5052 
 
5053 
  def process_getAllCategories(self, seqid, iprot, oprot):
5054 
    args = getAllCategories_args()
5055 
    args.read(iprot)
5056 
    iprot.readMessageEnd()
5057 
    result = getAllCategories_result()
5058 
    result.success = self._handler.getAllCategories()
5059 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5060 
    result.write(oprot)
5061 
    oprot.writeMessageEnd()
5062 
    oprot.trans.flush()
5063 
 
5064 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5065 
    args = getAllSimilarItems_args()
5066 
    args.read(iprot)
5067 
    iprot.readMessageEnd()
5068 
    result = getAllSimilarItems_result()
5069 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5070 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
5074 
 
5075 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5076 
    args = addSimilarItem_args()
5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
5079 
    result = addSimilarItem_result()
5080 
    try:
5081 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5082 
    except CatalogServiceException, cex:
5083 
      result.cex = cex
5084 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5085 
    result.write(oprot)
5086 
    oprot.writeMessageEnd()
5087 
    oprot.trans.flush()
5088 
 
6512 kshitij.so 5089 
  def process_addTag(self, seqid, iprot, oprot):
5090 
    args = addTag_args()
5091 
    args.read(iprot)
5092 
    iprot.readMessageEnd()
5093 
    result = addTag_result()
5094 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5095 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5096 
    result.write(oprot)
5097 
    oprot.writeMessageEnd()
5098 
    oprot.trans.flush()
5099 
 
5100 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5101 
    args = deleteEntityTag_args()
5102 
    args.read(iprot)
5103 
    iprot.readMessageEnd()
5104 
    result = deleteEntityTag_result()
5105 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5106 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5107 
    result.write(oprot)
5108 
    oprot.writeMessageEnd()
5109 
    oprot.trans.flush()
5110 
 
5111 
  def process_deleteTag(self, seqid, iprot, oprot):
5112 
    args = deleteTag_args()
5113 
    args.read(iprot)
5114 
    iprot.readMessageEnd()
5115 
    result = deleteTag_result()
5116 
    result.success = self._handler.deleteTag(args.displayName)
5117 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5118 
    result.write(oprot)
5119 
    oprot.writeMessageEnd()
5120 
    oprot.trans.flush()
5121 
 
5122 
  def process_getAllTags(self, seqid, iprot, oprot):
5123 
    args = getAllTags_args()
5124 
    args.read(iprot)
5125 
    iprot.readMessageEnd()
5126 
    result = getAllTags_result()
5127 
    result.success = self._handler.getAllTags()
5128 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5129 
    result.write(oprot)
5130 
    oprot.writeMessageEnd()
5131 
    oprot.trans.flush()
5132 
 
5133 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5134 
    args = getAllEntitiesByTagName_args()
5135 
    args.read(iprot)
5136 
    iprot.readMessageEnd()
5137 
    result = getAllEntitiesByTagName_result()
5138 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5139 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5140 
    result.write(oprot)
5141 
    oprot.writeMessageEnd()
5142 
    oprot.trans.flush()
5143 
 
6845 amit.gupta 5144 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5145 
    args = getAllEntityTags_args()
5146 
    args.read(iprot)
5147 
    iprot.readMessageEnd()
5148 
    result = getAllEntityTags_result()
5149 
    result.success = self._handler.getAllEntityTags()
5150 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5151 
    result.write(oprot)
5152 
    oprot.writeMessageEnd()
5153 
    oprot.trans.flush()
5154 
 
6850 kshitij.so 5155 
  def process_addBanner(self, seqid, iprot, oprot):
5156 
    args = addBanner_args()
5157 
    args.read(iprot)
5158 
    iprot.readMessageEnd()
5159 
    result = addBanner_result()
8579 kshitij.so 5160 
    result.success = self._handler.addBanner(args.banner)
6850 kshitij.so 5161 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5162 
    result.write(oprot)
5163 
    oprot.writeMessageEnd()
5164 
    oprot.trans.flush()
5165 
 
8579 kshitij.so 5166 
  def process_updateBanner(self, seqid, iprot, oprot):
5167 
    args = updateBanner_args()
5168 
    args.read(iprot)
5169 
    iprot.readMessageEnd()
5170 
    result = updateBanner_result()
5171 
    result.success = self._handler.updateBanner(args.banner)
5172 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5173 
    result.write(oprot)
5174 
    oprot.writeMessageEnd()
5175 
    oprot.trans.flush()
5176 
 
6850 kshitij.so 5177 
  def process_getAllBanners(self, seqid, iprot, oprot):
5178 
    args = getAllBanners_args()
5179 
    args.read(iprot)
5180 
    iprot.readMessageEnd()
5181 
    result = getAllBanners_result()
5182 
    result.success = self._handler.getAllBanners()
5183 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5184 
    result.write(oprot)
5185 
    oprot.writeMessageEnd()
5186 
    oprot.trans.flush()
5187 
 
5188 
  def process_deleteBanner(self, seqid, iprot, oprot):
5189 
    args = deleteBanner_args()
5190 
    args.read(iprot)
5191 
    iprot.readMessageEnd()
5192 
    result = deleteBanner_result()
5193 
    result.success = self._handler.deleteBanner(args.bannerName)
5194 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5195 
    result.write(oprot)
5196 
    oprot.writeMessageEnd()
5197 
    oprot.trans.flush()
5198 
 
5199 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5200 
    args = getBannerDetails_args()
5201 
    args.read(iprot)
5202 
    iprot.readMessageEnd()
5203 
    result = getBannerDetails_result()
5204 
    result.success = self._handler.getBannerDetails(args.bannerName)
5205 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5206 
    result.write(oprot)
5207 
    oprot.writeMessageEnd()
5208 
    oprot.trans.flush()
5209 
 
5210 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5211 
    args = getActiveBanners_args()
5212 
    args.read(iprot)
5213 
    iprot.readMessageEnd()
5214 
    result = getActiveBanners_result()
5215 
    result.success = self._handler.getActiveBanners()
5216 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5217 
    result.write(oprot)
5218 
    oprot.writeMessageEnd()
5219 
    oprot.trans.flush()
5220 
 
6849 kshitij.so 5221 
  def process_addBannerMap(self, seqid, iprot, oprot):
5222 
    args = addBannerMap_args()
5223 
    args.read(iprot)
5224 
    iprot.readMessageEnd()
5225 
    result = addBannerMap_result()
8579 kshitij.so 5226 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5227 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5228 
    result.write(oprot)
5229 
    oprot.writeMessageEnd()
5230 
    oprot.trans.flush()
5231 
 
8579 kshitij.so 5232 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5233 
    args = updateBannerMap_args()
5234 
    args.read(iprot)
5235 
    iprot.readMessageEnd()
5236 
    result = updateBannerMap_result()
5237 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5238 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5239 
    result.write(oprot)
5240 
    oprot.writeMessageEnd()
5241 
    oprot.trans.flush()
5242 
 
6849 kshitij.so 5243 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5244 
    args = deleteBannerMap_args()
5245 
    args.read(iprot)
5246 
    iprot.readMessageEnd()
5247 
    result = deleteBannerMap_result()
5248 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5249 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5250 
    result.write(oprot)
5251 
    oprot.writeMessageEnd()
5252 
    oprot.trans.flush()
5253 
 
5254 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5255 
    args = getBannerMapDetails_args()
5256 
    args.read(iprot)
5257 
    iprot.readMessageEnd()
5258 
    result = getBannerMapDetails_result()
5259 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
5260 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5261 
    result.write(oprot)
5262 
    oprot.writeMessageEnd()
5263 
    oprot.trans.flush()
5264 
 
8579 kshitij.so 5265 
  def process_addBannerUri(self, seqid, iprot, oprot):
5266 
    args = addBannerUri_args()
5267 
    args.read(iprot)
5268 
    iprot.readMessageEnd()
5269 
    result = addBannerUri_result()
5270 
    self._handler.addBannerUri(args.bannerUriMappings)
5271 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5272 
    result.write(oprot)
5273 
    oprot.writeMessageEnd()
5274 
    oprot.trans.flush()
5275 
 
5276 
  def process_getUriMapping(self, seqid, iprot, oprot):
5277 
    args = getUriMapping_args()
5278 
    args.read(iprot)
5279 
    iprot.readMessageEnd()
5280 
    result = getUriMapping_result()
5281 
    result.success = self._handler.getUriMapping(args.bannerName)
5282 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5283 
    result.write(oprot)
5284 
    oprot.writeMessageEnd()
5285 
    oprot.trans.flush()
5286 
 
5287 
  def process_addCampaign(self, seqid, iprot, oprot):
5288 
    args = addCampaign_args()
5289 
    args.read(iprot)
5290 
    iprot.readMessageEnd()
5291 
    result = addCampaign_result()
5292 
    self._handler.addCampaign(args.campaign)
5293 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5294 
    result.write(oprot)
5295 
    oprot.writeMessageEnd()
5296 
    oprot.trans.flush()
5297 
 
5298 
  def process_getCampaigns(self, seqid, iprot, oprot):
5299 
    args = getCampaigns_args()
5300 
    args.read(iprot)
5301 
    iprot.readMessageEnd()
5302 
    result = getCampaigns_result()
5303 
    result.success = self._handler.getCampaigns(args.campaignName)
5304 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5305 
    result.write(oprot)
5306 
    oprot.writeMessageEnd()
5307 
    oprot.trans.flush()
5308 
 
5309 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5310 
    args = deleteCampaign_args()
5311 
    args.read(iprot)
5312 
    iprot.readMessageEnd()
5313 
    result = deleteCampaign_result()
5314 
    self._handler.deleteCampaign(args.campaignId)
5315 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5316 
    result.write(oprot)
5317 
    oprot.writeMessageEnd()
5318 
    oprot.trans.flush()
5319 
 
5320 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5321 
    args = getAllCampaigns_args()
5322 
    args.read(iprot)
5323 
    iprot.readMessageEnd()
5324 
    result = getAllCampaigns_result()
5325 
    result.success = self._handler.getAllCampaigns()
5326 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5327 
    result.write(oprot)
5328 
    oprot.writeMessageEnd()
5329 
    oprot.trans.flush()
5330 
 
5944 mandeep.dh 5331 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5332 
    args = deleteSimilarItem_args()
5333 
    args.read(iprot)
5334 
    iprot.readMessageEnd()
5335 
    result = deleteSimilarItem_result()
5336 
    try:
5337 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5338 
    except CatalogServiceException, cex:
5339 
      result.cex = cex
5340 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5341 
    result.write(oprot)
5342 
    oprot.writeMessageEnd()
5343 
    oprot.trans.flush()
5344 
 
5345 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5346 
    args = checkSimilarItem_args()
5347 
    args.read(iprot)
5348 
    iprot.readMessageEnd()
5349 
    result = checkSimilarItem_result()
5350 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5351 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5352 
    result.write(oprot)
5353 
    oprot.writeMessageEnd()
5354 
    oprot.trans.flush()
5355 
 
5356 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5357 
    args = validateRiskyStatus_args()
5358 
    args.read(iprot)
5359 
    iprot.readMessageEnd()
5360 
    result = validateRiskyStatus_result()
5361 
    self._handler.validateRiskyStatus(args.itemId)
5362 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5363 
    result.write(oprot)
5364 
    oprot.writeMessageEnd()
5365 
    oprot.trans.flush()
5366 
 
5367 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5368 
    args = changeItemRiskyFlag_args()
5369 
    args.read(iprot)
5370 
    iprot.readMessageEnd()
5371 
    result = changeItemRiskyFlag_result()
5372 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5373 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5374 
    result.write(oprot)
5375 
    oprot.writeMessageEnd()
5376 
    oprot.trans.flush()
5377 
 
5378 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5379 
    args = getItemsByRiskyFlag_args()
5380 
    args.read(iprot)
5381 
    iprot.readMessageEnd()
5382 
    result = getItemsByRiskyFlag_result()
5383 
    result.success = self._handler.getItemsByRiskyFlag()
5384 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5385 
    result.write(oprot)
5386 
    oprot.writeMessageEnd()
5387 
    oprot.trans.flush()
5388 
 
5389 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5390 
    args = getItemsForMasterSheet_args()
5391 
    args.read(iprot)
5392 
    iprot.readMessageEnd()
5393 
    result = getItemsForMasterSheet_result()
5394 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5395 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5396 
    result.write(oprot)
5397 
    oprot.writeMessageEnd()
5398 
    oprot.trans.flush()
5399 
 
5400 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5401 
    args = getSimilarItemsCatalogIds_args()
5402 
    args.read(iprot)
5403 
    iprot.readMessageEnd()
5404 
    result = getSimilarItemsCatalogIds_result()
5405 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5406 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5407 
    result.write(oprot)
5408 
    oprot.writeMessageEnd()
5409 
    oprot.trans.flush()
5410 
 
5411 
  def process_addProductNotification(self, seqid, iprot, oprot):
5412 
    args = addProductNotification_args()
5413 
    args.read(iprot)
5414 
    iprot.readMessageEnd()
5415 
    result = addProductNotification_result()
5416 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5417 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5418 
    result.write(oprot)
5419 
    oprot.writeMessageEnd()
5420 
    oprot.trans.flush()
5421 
 
5422 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5423 
    args = sendProductNotifications_args()
5424 
    args.read(iprot)
5425 
    iprot.readMessageEnd()
5426 
    result = sendProductNotifications_result()
5427 
    result.success = self._handler.sendProductNotifications()
5428 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5429 
    result.write(oprot)
5430 
    oprot.writeMessageEnd()
5431 
    oprot.trans.flush()
5432 
 
5433 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5434 
    args = getAllBrandsByCategory_args()
5435 
    args.read(iprot)
5436 
    iprot.readMessageEnd()
5437 
    result = getAllBrandsByCategory_result()
5438 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5439 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5440 
    result.write(oprot)
5441 
    oprot.writeMessageEnd()
5442 
    oprot.trans.flush()
5443 
 
5444 
  def process_getAllBrands(self, seqid, iprot, oprot):
5445 
    args = getAllBrands_args()
5446 
    args.read(iprot)
5447 
    iprot.readMessageEnd()
5448 
    result = getAllBrands_result()
5449 
    result.success = self._handler.getAllBrands()
5450 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5451 
    result.write(oprot)
5452 
    oprot.writeMessageEnd()
5453 
    oprot.trans.flush()
5454 
 
5455 
  def process_getAllSources(self, seqid, iprot, oprot):
5456 
    args = getAllSources_args()
5457 
    args.read(iprot)
5458 
    iprot.readMessageEnd()
5459 
    result = getAllSources_result()
5460 
    result.success = self._handler.getAllSources()
5461 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5462 
    result.write(oprot)
5463 
    oprot.writeMessageEnd()
5464 
    oprot.trans.flush()
5465 
 
5466 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5467 
    args = getItemPricingBySource_args()
5468 
    args.read(iprot)
5469 
    iprot.readMessageEnd()
5470 
    result = getItemPricingBySource_result()
5471 
    try:
5472 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5473 
    except CatalogServiceException, cex:
5474 
      result.cex = cex
5475 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5476 
    result.write(oprot)
5477 
    oprot.writeMessageEnd()
5478 
    oprot.trans.flush()
5479 
 
5480 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5481 
    args = addSourceItemPricing_args()
5482 
    args.read(iprot)
5483 
    iprot.readMessageEnd()
5484 
    result = addSourceItemPricing_result()
5485 
    try:
5486 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5487 
    except CatalogServiceException, cex:
5488 
      result.cex = cex
5489 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5490 
    result.write(oprot)
5491 
    oprot.writeMessageEnd()
5492 
    oprot.trans.flush()
5493 
 
5494 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5495 
    args = getAllSourcePricing_args()
5496 
    args.read(iprot)
5497 
    iprot.readMessageEnd()
5498 
    result = getAllSourcePricing_result()
5499 
    try:
5500 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5501 
    except CatalogServiceException, cex:
5502 
      result.cex = cex
5503 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5504 
    result.write(oprot)
5505 
    oprot.writeMessageEnd()
5506 
    oprot.trans.flush()
5507 
 
5508 
  def process_getItemForSource(self, seqid, iprot, oprot):
5509 
    args = getItemForSource_args()
5510 
    args.read(iprot)
5511 
    iprot.readMessageEnd()
5512 
    result = getItemForSource_result()
5513 
    try:
5514 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5515 
    except CatalogServiceException, cex:
5516 
      result.cex = cex
5517 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5518 
    result.write(oprot)
5519 
    oprot.writeMessageEnd()
5520 
    oprot.trans.flush()
5521 
 
5522 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5523 
    args = searchItemsInRange_args()
5524 
    args.read(iprot)
5525 
    iprot.readMessageEnd()
5526 
    result = searchItemsInRange_result()
5527 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5528 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5529 
    result.write(oprot)
5530 
    oprot.writeMessageEnd()
5531 
    oprot.trans.flush()
5532 
 
5533 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5534 
    args = getSearchResultCount_args()
5535 
    args.read(iprot)
5536 
    iprot.readMessageEnd()
5537 
    result = getSearchResultCount_result()
5538 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5539 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5540 
    result.write(oprot)
5541 
    oprot.writeMessageEnd()
5542 
    oprot.trans.flush()
5543 
 
5544 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5545 
    args = getProductNotifications_args()
5546 
    args.read(iprot)
5547 
    iprot.readMessageEnd()
5548 
    result = getProductNotifications_result()
5549 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5550 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5551 
    result.write(oprot)
5552 
    oprot.writeMessageEnd()
5553 
    oprot.trans.flush()
5554 
 
5555 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5556 
    args = getProductNotificationRequestCount_args()
5557 
    args.read(iprot)
5558 
    iprot.readMessageEnd()
5559 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5560 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5561 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5562 
    result.write(oprot)
5563 
    oprot.writeMessageEnd()
5564 
    oprot.trans.flush()
5565 
 
5566 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5567 
    args = addAuthorizationLog_args()
5568 
    args.read(iprot)
5569 
    iprot.readMessageEnd()
5570 
    result = addAuthorizationLog_result()
5571 
    try:
5572 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5573 
    except CatalogServiceException, cex:
5574 
      result.cex = cex
5575 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5576 
    result.write(oprot)
5577 
    oprot.writeMessageEnd()
5578 
    oprot.trans.flush()
5579 
 
5580 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5581 
    args = addupdateVoucherForItem_args()
5582 
    args.read(iprot)
5583 
    iprot.readMessageEnd()
5584 
    result = addupdateVoucherForItem_result()
5585 
    try:
5586 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5587 
    except CatalogServiceException, cex:
5588 
      result.cex = cex
5589 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5590 
    result.write(oprot)
5591 
    oprot.writeMessageEnd()
5592 
    oprot.trans.flush()
5593 
 
5594 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5595 
    args = deleteVoucherForItem_args()
5596 
    args.read(iprot)
5597 
    iprot.readMessageEnd()
5598 
    result = deleteVoucherForItem_result()
5599 
    try:
5600 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5601 
    except CatalogServiceException, cex:
5602 
      result.cex = cex
5603 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5604 
    result.write(oprot)
5605 
    oprot.writeMessageEnd()
5606 
    oprot.trans.flush()
5607 
 
5608 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5609 
    args = getVoucherAmount_args()
5610 
    args.read(iprot)
5611 
    iprot.readMessageEnd()
5612 
    result = getVoucherAmount_result()
5613 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5614 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5615 
    result.write(oprot)
5616 
    oprot.writeMessageEnd()
5617 
    oprot.trans.flush()
5618 
 
5619 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5620 
    args = getAllItemVouchers_args()
5621 
    args.read(iprot)
5622 
    iprot.readMessageEnd()
5623 
    result = getAllItemVouchers_result()
5624 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5625 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5626 
    result.write(oprot)
5627 
    oprot.writeMessageEnd()
5628 
    oprot.trans.flush()
5629 
 
5630 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5631 
    args = isValidCatalogItemId_args()
5632 
    args.read(iprot)
5633 
    iprot.readMessageEnd()
5634 
    result = isValidCatalogItemId_result()
5635 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5636 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5637 
    result.write(oprot)
5638 
    oprot.writeMessageEnd()
5639 
    oprot.trans.flush()
5640 
 
6039 amit.gupta 5641 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5642 
    args = getVatPercentageForItem_args()
5643 
    args.read(iprot)
5644 
    iprot.readMessageEnd()
5645 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5646 
    try:
5647 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5648 
    except CatalogServiceException, cex:
5649 
      result.cex = cex
6039 amit.gupta 5650 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5651 
    result.write(oprot)
5652 
    oprot.writeMessageEnd()
5653 
    oprot.trans.flush()
5944 mandeep.dh 5654 
 
6039 amit.gupta 5655 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5656 
    args = getVatAmountForItem_args()
5657 
    args.read(iprot)
5658 
    iprot.readMessageEnd()
5659 
    result = getVatAmountForItem_result()
5660 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5661 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5662 
    result.write(oprot)
5663 
    oprot.writeMessageEnd()
5664 
    oprot.trans.flush()
5665 
 
6531 vikram.rag 5666 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5667 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5668 
    args.read(iprot)
5669 
    iprot.readMessageEnd()
5670 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5671 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5672 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5673 
    result.write(oprot)
5674 
    oprot.writeMessageEnd()
5675 
    oprot.trans.flush()
6039 amit.gupta 5676 
 
6821 amar.kumar 5677 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5678 
    args = getAllAliveItems_args()
5679 
    args.read(iprot)
5680 
    iprot.readMessageEnd()
5681 
    result = getAllAliveItems_result()
5682 
    result.success = self._handler.getAllAliveItems()
5683 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5684 
    result.write(oprot)
5685 
    oprot.writeMessageEnd()
5686 
    oprot.trans.flush()
5687 
 
6805 anupam.sin 5688 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5689 
    args = getInsuranceAmount_args()
5690 
    args.read(iprot)
5691 
    iprot.readMessageEnd()
5692 
    result = getInsuranceAmount_result()
6921 anupam.sin 5693 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5694 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5695 
    result.write(oprot)
5696 
    oprot.writeMessageEnd()
5697 
    oprot.trans.flush()
6531 vikram.rag 5698 
 
6805 anupam.sin 5699 
  def process_getInsurer(self, seqid, iprot, oprot):
5700 
    args = getInsurer_args()
5701 
    args.read(iprot)
5702 
    iprot.readMessageEnd()
5703 
    result = getInsurer_result()
5704 
    result.success = self._handler.getInsurer(args.insurerId)
5705 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5706 
    result.write(oprot)
5707 
    oprot.writeMessageEnd()
5708 
    oprot.trans.flush()
5709 
 
6838 vikram.rag 5710 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5711 
    args = getAllInsurers_args()
5712 
    args.read(iprot)
5713 
    iprot.readMessageEnd()
5714 
    result = getAllInsurers_result()
5715 
    result.success = self._handler.getAllInsurers()
5716 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5717 
    result.write(oprot)
5718 
    oprot.writeMessageEnd()
5719 
    oprot.trans.flush()
6805 anupam.sin 5720 
 
6962 rajveer 5721 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5722 
    args = updateInsuranceDeclaredAmount_args()
5723 
    args.read(iprot)
5724 
    iprot.readMessageEnd()
5725 
    result = updateInsuranceDeclaredAmount_result()
5726 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5727 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5728 
    result.write(oprot)
5729 
    oprot.writeMessageEnd()
5730 
    oprot.trans.flush()
6838 vikram.rag 5731 
 
7190 amar.kumar 5732 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5733 
    args = getFreebieForItem_args()
5734 
    args.read(iprot)
5735 
    iprot.readMessageEnd()
5736 
    result = getFreebieForItem_result()
5737 
    result.success = self._handler.getFreebieForItem(args.itemId)
5738 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5739 
    result.write(oprot)
5740 
    oprot.writeMessageEnd()
5741 
    oprot.trans.flush()
6962 rajveer 5742 
 
7190 amar.kumar 5743 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5744 
    args = addOrUpdateFreebieForItem_args()
5745 
    args.read(iprot)
5746 
    iprot.readMessageEnd()
5747 
    result = addOrUpdateFreebieForItem_result()
5748 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5749 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5750 
    result.write(oprot)
5751 
    oprot.writeMessageEnd()
5752 
    oprot.trans.flush()
5753 
 
7272 amit.gupta 5754 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5755 
    args = addOrUpdateBrandInfo_args()
5756 
    args.read(iprot)
5757 
    iprot.readMessageEnd()
5758 
    result = addOrUpdateBrandInfo_result()
5759 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5760 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5761 
    result.write(oprot)
5762 
    oprot.writeMessageEnd()
5763 
    oprot.trans.flush()
5764 
 
5765 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5766 
    args = getBrandInfo_args()
5767 
    args.read(iprot)
5768 
    iprot.readMessageEnd()
5769 
    result = getBrandInfo_result()
5770 
    result.success = self._handler.getBrandInfo()
5771 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5772 
    result.write(oprot)
5773 
    oprot.writeMessageEnd()
5774 
    oprot.trans.flush()
5775 
 
7256 rajveer 5776 
  def process_getStorePricing(self, seqid, iprot, oprot):
5777 
    args = getStorePricing_args()
5778 
    args.read(iprot)
5779 
    iprot.readMessageEnd()
5780 
    result = getStorePricing_result()
5781 
    result.success = self._handler.getStorePricing(args.itemId)
5782 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5783 
    result.write(oprot)
5784 
    oprot.writeMessageEnd()
5785 
    oprot.trans.flush()
7190 amar.kumar 5786 
 
7306 rajveer 5787 
  def process_getStorePricings(self, seqid, iprot, oprot):
5788 
    args = getStorePricings_args()
5789 
    args.read(iprot)
5790 
    iprot.readMessageEnd()
5791 
    result = getStorePricings_result()
5792 
    result.success = self._handler.getStorePricings(args.itemIds)
5793 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5794 
    result.write(oprot)
5795 
    oprot.writeMessageEnd()
5796 
    oprot.trans.flush()
5797 
 
7265 rajveer 5798 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5799 
    args = updateStorePricing_args()
5800 
    args.read(iprot)
5801 
    iprot.readMessageEnd()
5802 
    result = updateStorePricing_result()
7382 rajveer 5803 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5804 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5805 
    result.write(oprot)
5806 
    oprot.writeMessageEnd()
5807 
    oprot.trans.flush()
7256 rajveer 5808 
 
7281 kshitij.so 5809 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5810 
    args = getAllAmazonListedItems_args()
5811 
    args.read(iprot)
5812 
    iprot.readMessageEnd()
5813 
    result = getAllAmazonListedItems_result()
5814 
    result.success = self._handler.getAllAmazonListedItems()
5815 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5816 
    result.write(oprot)
5817 
    oprot.writeMessageEnd()
5818 
    oprot.trans.flush()
7265 rajveer 5819 
 
7281 kshitij.so 5820 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5821 
    args = getAmazonItemDetails_args()
5822 
    args.read(iprot)
5823 
    iprot.readMessageEnd()
5824 
    result = getAmazonItemDetails_result()
5825 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5826 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5827 
    result.write(oprot)
5828 
    oprot.writeMessageEnd()
5829 
    oprot.trans.flush()
5830 
 
5831 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5832 
    args = updateAmazonItemDetails_args()
5833 
    args.read(iprot)
5834 
    iprot.readMessageEnd()
5835 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 5836 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 5837 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5838 
    result.write(oprot)
5839 
    oprot.writeMessageEnd()
5840 
    oprot.trans.flush()
5841 
 
5842 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5843 
    args = addAmazonItem_args()
5844 
    args.read(iprot)
5845 
    iprot.readMessageEnd()
5846 
    result = addAmazonItem_result()
5847 
    self._handler.addAmazonItem(args.amazonlisted)
5848 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5849 
    result.write(oprot)
5850 
    oprot.writeMessageEnd()
5851 
    oprot.trans.flush()
5852 
 
7291 vikram.rag 5853 
  def process_getAsinItems(self, seqid, iprot, oprot):
5854 
    args = getAsinItems_args()
5855 
    args.read(iprot)
5856 
    iprot.readMessageEnd()
5857 
    result = getAsinItems_result()
5858 
    result.success = self._handler.getAsinItems()
5859 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5860 
    result.write(oprot)
5861 
    oprot.writeMessageEnd()
5862 
    oprot.trans.flush()
7281 kshitij.so 5863 
 
7291 vikram.rag 5864 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5865 
    args = getAllFbaListedItems_args()
5866 
    args.read(iprot)
5867 
    iprot.readMessageEnd()
5868 
    result = getAllFbaListedItems_result()
5869 
    result.success = self._handler.getAllFbaListedItems()
5870 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5871 
    result.write(oprot)
5872 
    oprot.writeMessageEnd()
5873 
    oprot.trans.flush()
5874 
 
5875 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5876 
    args = getAllNonFbaListedItems_args()
5877 
    args.read(iprot)
5878 
    iprot.readMessageEnd()
5879 
    result = getAllNonFbaListedItems_result()
5880 
    result.success = self._handler.getAllNonFbaListedItems()
5881 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5882 
    result.write(oprot)
5883 
    oprot.writeMessageEnd()
5884 
    oprot.trans.flush()
5885 
 
7460 kshitij.so 5886 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5887 
    args = updateItemInventory_args()
5888 
    args.read(iprot)
5889 
    iprot.readMessageEnd()
5890 
    result = updateItemInventory_result()
5891 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5892 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5893 
    result.write(oprot)
5894 
    oprot.writeMessageEnd()
5895 
    oprot.trans.flush()
7291 vikram.rag 5896 
 
7770 kshitij.so 5897 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5898 
    args = updateTimestampForAmazonFeeds_args()
5899 
    args.read(iprot)
5900 
    iprot.readMessageEnd()
5901 
    result = updateTimestampForAmazonFeeds_result()
5902 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5903 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5904 
    result.write(oprot)
5905 
    oprot.writeMessageEnd()
5906 
    oprot.trans.flush()
7460 kshitij.so 5907 
 
7897 amar.kumar 5908 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5909 
    args = getAllParentCategories_args()
5910 
    args.read(iprot)
5911 
    iprot.readMessageEnd()
5912 
    result = getAllParentCategories_result()
5913 
    result.success = self._handler.getAllParentCategories()
5914 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5915 
    result.write(oprot)
5916 
    oprot.writeMessageEnd()
5917 
    oprot.trans.flush()
7770 kshitij.so 5918 
 
7977 kshitij.so 5919 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5920 
    args = addPageViewEvent_args()
5921 
    args.read(iprot)
5922 
    iprot.readMessageEnd()
5923 
    result = addPageViewEvent_result()
5924 
    self._handler.addPageViewEvent(args.pageViewEvents)
5925 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5926 
    result.write(oprot)
5927 
    oprot.writeMessageEnd()
5928 
    oprot.trans.flush()
7897 amar.kumar 5929 
 
7977 kshitij.so 5930 
  def process_addCartEvent(self, seqid, iprot, oprot):
5931 
    args = addCartEvent_args()
5932 
    args.read(iprot)
5933 
    iprot.readMessageEnd()
5934 
    result = addCartEvent_result()
5935 
    self._handler.addCartEvent(args.cartEvents)
5936 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5937 
    result.write(oprot)
5938 
    oprot.writeMessageEnd()
5939 
    oprot.trans.flush()
5940 
 
8182 amar.kumar 5941 
  def process_addEbayItem(self, seqid, iprot, oprot):
5942 
    args = addEbayItem_args()
5943 
    args.read(iprot)
5944 
    iprot.readMessageEnd()
5945 
    result = addEbayItem_result()
5946 
    self._handler.addEbayItem(args.ebayItem)
5947 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
5948 
    result.write(oprot)
5949 
    oprot.writeMessageEnd()
5950 
    oprot.trans.flush()
5951 
 
5952 
  def process_getEbayItem(self, seqid, iprot, oprot):
5953 
    args = getEbayItem_args()
5954 
    args.read(iprot)
5955 
    iprot.readMessageEnd()
5956 
    result = getEbayItem_result()
5957 
    result.success = self._handler.getEbayItem(args.listingId)
5958 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
5959 
    result.write(oprot)
5960 
    oprot.writeMessageEnd()
5961 
    oprot.trans.flush()
5962 
 
5963 
  def process_updateEbayItem(self, seqid, iprot, oprot):
5964 
    args = updateEbayItem_args()
5965 
    args.read(iprot)
5966 
    iprot.readMessageEnd()
5967 
    result = updateEbayItem_result()
5968 
    self._handler.updateEbayItem(args.ebayItem)
5969 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
5970 
    result.write(oprot)
5971 
    oprot.writeMessageEnd()
5972 
    oprot.trans.flush()
5973 
 
8139 kshitij.so 5974 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
5975 
    args = getAmazonListedItems_args()
5976 
    args.read(iprot)
5977 
    iprot.readMessageEnd()
5978 
    result = getAmazonListedItems_result()
5979 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
5980 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
5981 
    result.write(oprot)
5982 
    oprot.writeMessageEnd()
5983 
    oprot.trans.flush()
7977 kshitij.so 5984 
 
8168 kshitij.so 5985 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
5986 
    args = updateAmazonAttributesInBulk_args()
5987 
    args.read(iprot)
5988 
    iprot.readMessageEnd()
5989 
    result = updateAmazonAttributesInBulk_result()
5990 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
5991 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
5992 
    result.write(oprot)
5993 
    oprot.writeMessageEnd()
5994 
    oprot.trans.flush()
8139 kshitij.so 5995 
 
8379 vikram.rag 5996 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
5997 
    args = getAllItemstoListOnFba_args()
5998 
    args.read(iprot)
5999 
    iprot.readMessageEnd()
6000 
    result = getAllItemstoListOnFba_result()
6001 
    result.success = self._handler.getAllItemstoListOnFba()
6002 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6003 
    result.write(oprot)
6004 
    oprot.writeMessageEnd()
6005 
    oprot.trans.flush()
8168 kshitij.so 6006 
 
8379 vikram.rag 6007 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6008 
    args = getAllItemstoListOnNonFba_args()
6009 
    args.read(iprot)
6010 
    iprot.readMessageEnd()
6011 
    result = getAllItemstoListOnNonFba_result()
6012 
    result.success = self._handler.getAllItemstoListOnNonFba()
6013 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6014 
    result.write(oprot)
6015 
    oprot.writeMessageEnd()
6016 
    oprot.trans.flush()
6017 
 
6018 
 
5944 mandeep.dh 6019 
# HELPER FUNCTIONS AND STRUCTURES
6020 
 
6021 
class addItem_args:
6022 
  """
6023 
  Attributes:
6024 
   - item
6025 
  """
6026 
 
6027 
  thrift_spec = (
6028 
    None, # 0
6029 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6030 
  )
6031 
 
6032 
  def __init__(self, item=None,):
6033 
    self.item = item
6034 
 
6035 
  def read(self, iprot):
6036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6038 
      return
6039 
    iprot.readStructBegin()
6040 
    while True:
6041 
      (fname, ftype, fid) = iprot.readFieldBegin()
6042 
      if ftype == TType.STOP:
6043 
        break
6044 
      if fid == 1:
6045 
        if ftype == TType.STRUCT:
6046 
          self.item = Item()
6047 
          self.item.read(iprot)
6048 
        else:
6049 
          iprot.skip(ftype)
6050 
      else:
6051 
        iprot.skip(ftype)
6052 
      iprot.readFieldEnd()
6053 
    iprot.readStructEnd()
6054 
 
6055 
  def write(self, oprot):
6056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6058 
      return
6059 
    oprot.writeStructBegin('addItem_args')
6060 
    if self.item is not None:
6061 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6062 
      self.item.write(oprot)
6063 
      oprot.writeFieldEnd()
6064 
    oprot.writeFieldStop()
6065 
    oprot.writeStructEnd()
6066 
 
6067 
  def validate(self):
6068 
    return
6069 
 
6070 
 
6071 
  def __repr__(self):
6072 
    L = ['%s=%r' % (key, value)
6073 
      for key, value in self.__dict__.iteritems()]
6074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6075 
 
6076 
  def __eq__(self, other):
6077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6078 
 
6079 
  def __ne__(self, other):
6080 
    return not (self == other)
6081 
 
6082 
class addItem_result:
6083 
  """
6084 
  Attributes:
6085 
   - success
6086 
   - cex
6087 
  """
6088 
 
6089 
  thrift_spec = (
6090 
    (0, TType.I64, 'success', None, None, ), # 0
6091 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6092 
  )
6093 
 
6094 
  def __init__(self, success=None, cex=None,):
6095 
    self.success = success
6096 
    self.cex = cex
6097 
 
6098 
  def read(self, iprot):
6099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6101 
      return
6102 
    iprot.readStructBegin()
6103 
    while True:
6104 
      (fname, ftype, fid) = iprot.readFieldBegin()
6105 
      if ftype == TType.STOP:
6106 
        break
6107 
      if fid == 0:
6108 
        if ftype == TType.I64:
6109 
          self.success = iprot.readI64();
6110 
        else:
6111 
          iprot.skip(ftype)
6112 
      elif fid == 1:
6113 
        if ftype == TType.STRUCT:
6114 
          self.cex = CatalogServiceException()
6115 
          self.cex.read(iprot)
6116 
        else:
6117 
          iprot.skip(ftype)
6118 
      else:
6119 
        iprot.skip(ftype)
6120 
      iprot.readFieldEnd()
6121 
    iprot.readStructEnd()
6122 
 
6123 
  def write(self, oprot):
6124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6126 
      return
6127 
    oprot.writeStructBegin('addItem_result')
6128 
    if self.success is not None:
6129 
      oprot.writeFieldBegin('success', TType.I64, 0)
6130 
      oprot.writeI64(self.success)
6131 
      oprot.writeFieldEnd()
6132 
    if self.cex is not None:
6133 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6134 
      self.cex.write(oprot)
6135 
      oprot.writeFieldEnd()
6136 
    oprot.writeFieldStop()
6137 
    oprot.writeStructEnd()
6138 
 
6139 
  def validate(self):
6140 
    return
6141 
 
6142 
 
6143 
  def __repr__(self):
6144 
    L = ['%s=%r' % (key, value)
6145 
      for key, value in self.__dict__.iteritems()]
6146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6147 
 
6148 
  def __eq__(self, other):
6149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6150 
 
6151 
  def __ne__(self, other):
6152 
    return not (self == other)
6153 
 
6154 
class updateItem_args:
6155 
  """
6156 
  Attributes:
6157 
   - item
6158 
  """
6159 
 
6160 
  thrift_spec = (
6161 
    None, # 0
6162 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6163 
  )
6164 
 
6165 
  def __init__(self, item=None,):
6166 
    self.item = item
6167 
 
6168 
  def read(self, iprot):
6169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6171 
      return
6172 
    iprot.readStructBegin()
6173 
    while True:
6174 
      (fname, ftype, fid) = iprot.readFieldBegin()
6175 
      if ftype == TType.STOP:
6176 
        break
6177 
      if fid == 1:
6178 
        if ftype == TType.STRUCT:
6179 
          self.item = Item()
6180 
          self.item.read(iprot)
6181 
        else:
6182 
          iprot.skip(ftype)
6183 
      else:
6184 
        iprot.skip(ftype)
6185 
      iprot.readFieldEnd()
6186 
    iprot.readStructEnd()
6187 
 
6188 
  def write(self, oprot):
6189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6191 
      return
6192 
    oprot.writeStructBegin('updateItem_args')
6193 
    if self.item is not None:
6194 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6195 
      self.item.write(oprot)
6196 
      oprot.writeFieldEnd()
6197 
    oprot.writeFieldStop()
6198 
    oprot.writeStructEnd()
6199 
 
6200 
  def validate(self):
6201 
    return
6202 
 
6203 
 
6204 
  def __repr__(self):
6205 
    L = ['%s=%r' % (key, value)
6206 
      for key, value in self.__dict__.iteritems()]
6207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6208 
 
6209 
  def __eq__(self, other):
6210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6211 
 
6212 
  def __ne__(self, other):
6213 
    return not (self == other)
6214 
 
6215 
class updateItem_result:
6216 
  """
6217 
  Attributes:
6218 
   - success
6219 
   - cex
6220 
  """
6221 
 
6222 
  thrift_spec = (
6223 
    (0, TType.I64, 'success', None, None, ), # 0
6224 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6225 
  )
6226 
 
6227 
  def __init__(self, success=None, cex=None,):
6228 
    self.success = success
6229 
    self.cex = cex
6230 
 
6231 
  def read(self, iprot):
6232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6234 
      return
6235 
    iprot.readStructBegin()
6236 
    while True:
6237 
      (fname, ftype, fid) = iprot.readFieldBegin()
6238 
      if ftype == TType.STOP:
6239 
        break
6240 
      if fid == 0:
6241 
        if ftype == TType.I64:
6242 
          self.success = iprot.readI64();
6243 
        else:
6244 
          iprot.skip(ftype)
6245 
      elif fid == 1:
6246 
        if ftype == TType.STRUCT:
6247 
          self.cex = CatalogServiceException()
6248 
          self.cex.read(iprot)
6249 
        else:
6250 
          iprot.skip(ftype)
6251 
      else:
6252 
        iprot.skip(ftype)
6253 
      iprot.readFieldEnd()
6254 
    iprot.readStructEnd()
6255 
 
6256 
  def write(self, oprot):
6257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6259 
      return
6260 
    oprot.writeStructBegin('updateItem_result')
6261 
    if self.success is not None:
6262 
      oprot.writeFieldBegin('success', TType.I64, 0)
6263 
      oprot.writeI64(self.success)
6264 
      oprot.writeFieldEnd()
6265 
    if self.cex is not None:
6266 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6267 
      self.cex.write(oprot)
6268 
      oprot.writeFieldEnd()
6269 
    oprot.writeFieldStop()
6270 
    oprot.writeStructEnd()
6271 
 
6272 
  def validate(self):
6273 
    return
6274 
 
6275 
 
6276 
  def __repr__(self):
6277 
    L = ['%s=%r' % (key, value)
6278 
      for key, value in self.__dict__.iteritems()]
6279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6280 
 
6281 
  def __eq__(self, other):
6282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6283 
 
6284 
  def __ne__(self, other):
6285 
    return not (self == other)
6286 
 
6287 
class isActive_args:
6288 
  """
6289 
  Attributes:
6290 
   - itemId
6291 
  """
6292 
 
6293 
  thrift_spec = (
6294 
    None, # 0
6295 
    (1, TType.I64, 'itemId', None, None, ), # 1
6296 
  )
6297 
 
6298 
  def __init__(self, itemId=None,):
6299 
    self.itemId = itemId
6300 
 
6301 
  def read(self, iprot):
6302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6304 
      return
6305 
    iprot.readStructBegin()
6306 
    while True:
6307 
      (fname, ftype, fid) = iprot.readFieldBegin()
6308 
      if ftype == TType.STOP:
6309 
        break
6310 
      if fid == 1:
6311 
        if ftype == TType.I64:
6312 
          self.itemId = iprot.readI64();
6313 
        else:
6314 
          iprot.skip(ftype)
6315 
      else:
6316 
        iprot.skip(ftype)
6317 
      iprot.readFieldEnd()
6318 
    iprot.readStructEnd()
6319 
 
6320 
  def write(self, oprot):
6321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6323 
      return
6324 
    oprot.writeStructBegin('isActive_args')
6325 
    if self.itemId is not None:
6326 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6327 
      oprot.writeI64(self.itemId)
6328 
      oprot.writeFieldEnd()
6329 
    oprot.writeFieldStop()
6330 
    oprot.writeStructEnd()
6331 
 
6332 
  def validate(self):
6333 
    return
6334 
 
6335 
 
6336 
  def __repr__(self):
6337 
    L = ['%s=%r' % (key, value)
6338 
      for key, value in self.__dict__.iteritems()]
6339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6340 
 
6341 
  def __eq__(self, other):
6342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6343 
 
6344 
  def __ne__(self, other):
6345 
    return not (self == other)
6346 
 
6347 
class isActive_result:
6348 
  """
6349 
  Attributes:
6350 
   - success
6351 
   - isex
6352 
  """
6353 
 
6354 
  thrift_spec = (
6355 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6356 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6357 
  )
6358 
 
6359 
  def __init__(self, success=None, isex=None,):
6360 
    self.success = success
6361 
    self.isex = isex
6362 
 
6363 
  def read(self, iprot):
6364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6366 
      return
6367 
    iprot.readStructBegin()
6368 
    while True:
6369 
      (fname, ftype, fid) = iprot.readFieldBegin()
6370 
      if ftype == TType.STOP:
6371 
        break
6372 
      if fid == 0:
6373 
        if ftype == TType.STRUCT:
6374 
          self.success = ItemShippingInfo()
6375 
          self.success.read(iprot)
6376 
        else:
6377 
          iprot.skip(ftype)
6378 
      elif fid == 1:
6379 
        if ftype == TType.STRUCT:
6380 
          self.isex = CatalogServiceException()
6381 
          self.isex.read(iprot)
6382 
        else:
6383 
          iprot.skip(ftype)
6384 
      else:
6385 
        iprot.skip(ftype)
6386 
      iprot.readFieldEnd()
6387 
    iprot.readStructEnd()
6388 
 
6389 
  def write(self, oprot):
6390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6392 
      return
6393 
    oprot.writeStructBegin('isActive_result')
6394 
    if self.success is not None:
6395 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6396 
      self.success.write(oprot)
6397 
      oprot.writeFieldEnd()
6398 
    if self.isex is not None:
6399 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6400 
      self.isex.write(oprot)
6401 
      oprot.writeFieldEnd()
6402 
    oprot.writeFieldStop()
6403 
    oprot.writeStructEnd()
6404 
 
6405 
  def validate(self):
6406 
    return
6407 
 
6408 
 
6409 
  def __repr__(self):
6410 
    L = ['%s=%r' % (key, value)
6411 
      for key, value in self.__dict__.iteritems()]
6412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6413 
 
6414 
  def __eq__(self, other):
6415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6416 
 
6417 
  def __ne__(self, other):
6418 
    return not (self == other)
6419 
 
7438 amit.gupta 6420 
class getItemsStatus_args:
6421 
  """
6422 
  Attributes:
6423 
   - itemIds
6424 
  """
6425 
 
6426 
  thrift_spec = (
6427 
    None, # 0
6428 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
6429 
  )
6430 
 
6431 
  def __init__(self, itemIds=None,):
6432 
    self.itemIds = itemIds
6433 
 
6434 
  def read(self, iprot):
6435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6437 
      return
6438 
    iprot.readStructBegin()
6439 
    while True:
6440 
      (fname, ftype, fid) = iprot.readFieldBegin()
6441 
      if ftype == TType.STOP:
6442 
        break
6443 
      if fid == 1:
6444 
        if ftype == TType.LIST:
6445 
          self.itemIds = []
6446 
          (_etype19, _size16) = iprot.readListBegin()
6447 
          for _i20 in xrange(_size16):
6448 
            _elem21 = iprot.readI64();
6449 
            self.itemIds.append(_elem21)
6450 
          iprot.readListEnd()
6451 
        else:
6452 
          iprot.skip(ftype)
6453 
      else:
6454 
        iprot.skip(ftype)
6455 
      iprot.readFieldEnd()
6456 
    iprot.readStructEnd()
6457 
 
6458 
  def write(self, oprot):
6459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6461 
      return
6462 
    oprot.writeStructBegin('getItemsStatus_args')
6463 
    if self.itemIds is not None:
6464 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6465 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6466 
      for iter22 in self.itemIds:
6467 
        oprot.writeI64(iter22)
6468 
      oprot.writeListEnd()
6469 
      oprot.writeFieldEnd()
6470 
    oprot.writeFieldStop()
6471 
    oprot.writeStructEnd()
6472 
 
6473 
  def validate(self):
6474 
    return
6475 
 
6476 
 
6477 
  def __repr__(self):
6478 
    L = ['%s=%r' % (key, value)
6479 
      for key, value in self.__dict__.iteritems()]
6480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6481 
 
6482 
  def __eq__(self, other):
6483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6484 
 
6485 
  def __ne__(self, other):
6486 
    return not (self == other)
6487 
 
6488 
class getItemsStatus_result:
6489 
  """
6490 
  Attributes:
6491 
   - success
6492 
   - isex
6493 
  """
6494 
 
6495 
  thrift_spec = (
6496 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6497 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6498 
  )
6499 
 
6500 
  def __init__(self, success=None, isex=None,):
6501 
    self.success = success
6502 
    self.isex = isex
6503 
 
6504 
  def read(self, iprot):
6505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6507 
      return
6508 
    iprot.readStructBegin()
6509 
    while True:
6510 
      (fname, ftype, fid) = iprot.readFieldBegin()
6511 
      if ftype == TType.STOP:
6512 
        break
6513 
      if fid == 0:
6514 
        if ftype == TType.MAP:
6515 
          self.success = {}
6516 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
6517 
          for _i27 in xrange(_size23):
6518 
            _key28 = iprot.readI64();
6519 
            _val29 = iprot.readBool();
6520 
            self.success[_key28] = _val29
6521 
          iprot.readMapEnd()
6522 
        else:
6523 
          iprot.skip(ftype)
6524 
      elif fid == 1:
6525 
        if ftype == TType.STRUCT:
6526 
          self.isex = CatalogServiceException()
6527 
          self.isex.read(iprot)
6528 
        else:
6529 
          iprot.skip(ftype)
6530 
      else:
6531 
        iprot.skip(ftype)
6532 
      iprot.readFieldEnd()
6533 
    iprot.readStructEnd()
6534 
 
6535 
  def write(self, oprot):
6536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6538 
      return
6539 
    oprot.writeStructBegin('getItemsStatus_result')
6540 
    if self.success is not None:
6541 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6542 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
6543 
      for kiter30,viter31 in self.success.items():
6544 
        oprot.writeI64(kiter30)
6545 
        oprot.writeBool(viter31)
6546 
      oprot.writeMapEnd()
6547 
      oprot.writeFieldEnd()
6548 
    if self.isex is not None:
6549 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6550 
      self.isex.write(oprot)
6551 
      oprot.writeFieldEnd()
6552 
    oprot.writeFieldStop()
6553 
    oprot.writeStructEnd()
6554 
 
6555 
  def validate(self):
6556 
    return
6557 
 
6558 
 
6559 
  def __repr__(self):
6560 
    L = ['%s=%r' % (key, value)
6561 
      for key, value in self.__dict__.iteritems()]
6562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6563 
 
6564 
  def __eq__(self, other):
6565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6566 
 
6567 
  def __ne__(self, other):
6568 
    return not (self == other)
6569 
 
5944 mandeep.dh 6570 
class getItemStatusDescription_args:
6571 
  """
6572 
  Attributes:
6573 
   - itemId
6574 
  """
6575 
 
6576 
  thrift_spec = (
6577 
    None, # 0
6578 
    (1, TType.I64, 'itemId', None, None, ), # 1
6579 
  )
6580 
 
6581 
  def __init__(self, itemId=None,):
6582 
    self.itemId = itemId
6583 
 
6584 
  def read(self, iprot):
6585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6587 
      return
6588 
    iprot.readStructBegin()
6589 
    while True:
6590 
      (fname, ftype, fid) = iprot.readFieldBegin()
6591 
      if ftype == TType.STOP:
6592 
        break
6593 
      if fid == 1:
6594 
        if ftype == TType.I64:
6595 
          self.itemId = iprot.readI64();
6596 
        else:
6597 
          iprot.skip(ftype)
6598 
      else:
6599 
        iprot.skip(ftype)
6600 
      iprot.readFieldEnd()
6601 
    iprot.readStructEnd()
6602 
 
6603 
  def write(self, oprot):
6604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6606 
      return
6607 
    oprot.writeStructBegin('getItemStatusDescription_args')
6608 
    if self.itemId is not None:
6609 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6610 
      oprot.writeI64(self.itemId)
6611 
      oprot.writeFieldEnd()
6612 
    oprot.writeFieldStop()
6613 
    oprot.writeStructEnd()
6614 
 
6615 
  def validate(self):
6616 
    return
6617 
 
6618 
 
6619 
  def __repr__(self):
6620 
    L = ['%s=%r' % (key, value)
6621 
      for key, value in self.__dict__.iteritems()]
6622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6623 
 
6624 
  def __eq__(self, other):
6625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6626 
 
6627 
  def __ne__(self, other):
6628 
    return not (self == other)
6629 
 
6630 
class getItemStatusDescription_result:
6631 
  """
6632 
  Attributes:
6633 
   - success
6634 
   - isex
6635 
  """
6636 
 
6637 
  thrift_spec = (
6638 
    (0, TType.STRING, 'success', None, None, ), # 0
6639 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6640 
  )
6641 
 
6642 
  def __init__(self, success=None, isex=None,):
6643 
    self.success = success
6644 
    self.isex = isex
6645 
 
6646 
  def read(self, iprot):
6647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6649 
      return
6650 
    iprot.readStructBegin()
6651 
    while True:
6652 
      (fname, ftype, fid) = iprot.readFieldBegin()
6653 
      if ftype == TType.STOP:
6654 
        break
6655 
      if fid == 0:
6656 
        if ftype == TType.STRING:
6657 
          self.success = iprot.readString();
6658 
        else:
6659 
          iprot.skip(ftype)
6660 
      elif fid == 1:
6661 
        if ftype == TType.STRUCT:
6662 
          self.isex = CatalogServiceException()
6663 
          self.isex.read(iprot)
6664 
        else:
6665 
          iprot.skip(ftype)
6666 
      else:
6667 
        iprot.skip(ftype)
6668 
      iprot.readFieldEnd()
6669 
    iprot.readStructEnd()
6670 
 
6671 
  def write(self, oprot):
6672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6674 
      return
6675 
    oprot.writeStructBegin('getItemStatusDescription_result')
6676 
    if self.success is not None:
6677 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6678 
      oprot.writeString(self.success)
6679 
      oprot.writeFieldEnd()
6680 
    if self.isex is not None:
6681 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6682 
      self.isex.write(oprot)
6683 
      oprot.writeFieldEnd()
6684 
    oprot.writeFieldStop()
6685 
    oprot.writeStructEnd()
6686 
 
6687 
  def validate(self):
6688 
    return
6689 
 
6690 
 
6691 
  def __repr__(self):
6692 
    L = ['%s=%r' % (key, value)
6693 
      for key, value in self.__dict__.iteritems()]
6694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6695 
 
6696 
  def __eq__(self, other):
6697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6698 
 
6699 
  def __ne__(self, other):
6700 
    return not (self == other)
6701 
 
6702 
class startItemOn_args:
6703 
  """
6704 
  Attributes:
6705 
   - item_id
6706 
   - timestamp
6707 
  """
6708 
 
6709 
  thrift_spec = (
6710 
    None, # 0
6711 
    (1, TType.I64, 'item_id', None, None, ), # 1
6712 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6713 
  )
6714 
 
6715 
  def __init__(self, item_id=None, timestamp=None,):
6716 
    self.item_id = item_id
6717 
    self.timestamp = timestamp
6718 
 
6719 
  def read(self, iprot):
6720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6722 
      return
6723 
    iprot.readStructBegin()
6724 
    while True:
6725 
      (fname, ftype, fid) = iprot.readFieldBegin()
6726 
      if ftype == TType.STOP:
6727 
        break
6728 
      if fid == 1:
6729 
        if ftype == TType.I64:
6730 
          self.item_id = iprot.readI64();
6731 
        else:
6732 
          iprot.skip(ftype)
6733 
      elif fid == 2:
6734 
        if ftype == TType.I64:
6735 
          self.timestamp = iprot.readI64();
6736 
        else:
6737 
          iprot.skip(ftype)
6738 
      else:
6739 
        iprot.skip(ftype)
6740 
      iprot.readFieldEnd()
6741 
    iprot.readStructEnd()
6742 
 
6743 
  def write(self, oprot):
6744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6746 
      return
6747 
    oprot.writeStructBegin('startItemOn_args')
6748 
    if self.item_id is not None:
6749 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6750 
      oprot.writeI64(self.item_id)
6751 
      oprot.writeFieldEnd()
6752 
    if self.timestamp is not None:
6753 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6754 
      oprot.writeI64(self.timestamp)
6755 
      oprot.writeFieldEnd()
6756 
    oprot.writeFieldStop()
6757 
    oprot.writeStructEnd()
6758 
 
6759 
  def validate(self):
6760 
    return
6761 
 
6762 
 
6763 
  def __repr__(self):
6764 
    L = ['%s=%r' % (key, value)
6765 
      for key, value in self.__dict__.iteritems()]
6766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6767 
 
6768 
  def __eq__(self, other):
6769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6770 
 
6771 
  def __ne__(self, other):
6772 
    return not (self == other)
6773 
 
6774 
class startItemOn_result:
6775 
  """
6776 
  Attributes:
6777 
   - cex
6778 
  """
6779 
 
6780 
  thrift_spec = (
6781 
    None, # 0
6782 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6783 
  )
6784 
 
6785 
  def __init__(self, cex=None,):
6786 
    self.cex = cex
6787 
 
6788 
  def read(self, iprot):
6789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6791 
      return
6792 
    iprot.readStructBegin()
6793 
    while True:
6794 
      (fname, ftype, fid) = iprot.readFieldBegin()
6795 
      if ftype == TType.STOP:
6796 
        break
6797 
      if fid == 1:
6798 
        if ftype == TType.STRUCT:
6799 
          self.cex = CatalogServiceException()
6800 
          self.cex.read(iprot)
6801 
        else:
6802 
          iprot.skip(ftype)
6803 
      else:
6804 
        iprot.skip(ftype)
6805 
      iprot.readFieldEnd()
6806 
    iprot.readStructEnd()
6807 
 
6808 
  def write(self, oprot):
6809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6811 
      return
6812 
    oprot.writeStructBegin('startItemOn_result')
6813 
    if self.cex is not None:
6814 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6815 
      self.cex.write(oprot)
6816 
      oprot.writeFieldEnd()
6817 
    oprot.writeFieldStop()
6818 
    oprot.writeStructEnd()
6819 
 
6820 
  def validate(self):
6821 
    return
6822 
 
6823 
 
6824 
  def __repr__(self):
6825 
    L = ['%s=%r' % (key, value)
6826 
      for key, value in self.__dict__.iteritems()]
6827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6828 
 
6829 
  def __eq__(self, other):
6830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6831 
 
6832 
  def __ne__(self, other):
6833 
    return not (self == other)
6834 
 
6835 
class retireItemOn_args:
6836 
  """
6837 
  Attributes:
6838 
   - item_id
6839 
   - timestamp
6840 
  """
6841 
 
6842 
  thrift_spec = (
6843 
    None, # 0
6844 
    (1, TType.I64, 'item_id', None, None, ), # 1
6845 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6846 
  )
6847 
 
6848 
  def __init__(self, item_id=None, timestamp=None,):
6849 
    self.item_id = item_id
6850 
    self.timestamp = timestamp
6851 
 
6852 
  def read(self, iprot):
6853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6855 
      return
6856 
    iprot.readStructBegin()
6857 
    while True:
6858 
      (fname, ftype, fid) = iprot.readFieldBegin()
6859 
      if ftype == TType.STOP:
6860 
        break
6861 
      if fid == 1:
6862 
        if ftype == TType.I64:
6863 
          self.item_id = iprot.readI64();
6864 
        else:
6865 
          iprot.skip(ftype)
6866 
      elif fid == 2:
6867 
        if ftype == TType.I64:
6868 
          self.timestamp = iprot.readI64();
6869 
        else:
6870 
          iprot.skip(ftype)
6871 
      else:
6872 
        iprot.skip(ftype)
6873 
      iprot.readFieldEnd()
6874 
    iprot.readStructEnd()
6875 
 
6876 
  def write(self, oprot):
6877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6879 
      return
6880 
    oprot.writeStructBegin('retireItemOn_args')
6881 
    if self.item_id is not None:
6882 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6883 
      oprot.writeI64(self.item_id)
6884 
      oprot.writeFieldEnd()
6885 
    if self.timestamp is not None:
6886 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6887 
      oprot.writeI64(self.timestamp)
6888 
      oprot.writeFieldEnd()
6889 
    oprot.writeFieldStop()
6890 
    oprot.writeStructEnd()
6891 
 
6892 
  def validate(self):
6893 
    return
6894 
 
6895 
 
6896 
  def __repr__(self):
6897 
    L = ['%s=%r' % (key, value)
6898 
      for key, value in self.__dict__.iteritems()]
6899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6900 
 
6901 
  def __eq__(self, other):
6902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6903 
 
6904 
  def __ne__(self, other):
6905 
    return not (self == other)
6906 
 
6907 
class retireItemOn_result:
6908 
  """
6909 
  Attributes:
6910 
   - cex
6911 
  """
6912 
 
6913 
  thrift_spec = (
6914 
    None, # 0
6915 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6916 
  )
6917 
 
6918 
  def __init__(self, cex=None,):
6919 
    self.cex = cex
6920 
 
6921 
  def read(self, iprot):
6922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6924 
      return
6925 
    iprot.readStructBegin()
6926 
    while True:
6927 
      (fname, ftype, fid) = iprot.readFieldBegin()
6928 
      if ftype == TType.STOP:
6929 
        break
6930 
      if fid == 1:
6931 
        if ftype == TType.STRUCT:
6932 
          self.cex = CatalogServiceException()
6933 
          self.cex.read(iprot)
6934 
        else:
6935 
          iprot.skip(ftype)
6936 
      else:
6937 
        iprot.skip(ftype)
6938 
      iprot.readFieldEnd()
6939 
    iprot.readStructEnd()
6940 
 
6941 
  def write(self, oprot):
6942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6944 
      return
6945 
    oprot.writeStructBegin('retireItemOn_result')
6946 
    if self.cex is not None:
6947 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6948 
      self.cex.write(oprot)
6949 
      oprot.writeFieldEnd()
6950 
    oprot.writeFieldStop()
6951 
    oprot.writeStructEnd()
6952 
 
6953 
  def validate(self):
6954 
    return
6955 
 
6956 
 
6957 
  def __repr__(self):
6958 
    L = ['%s=%r' % (key, value)
6959 
      for key, value in self.__dict__.iteritems()]
6960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6961 
 
6962 
  def __eq__(self, other):
6963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6964 
 
6965 
  def __ne__(self, other):
6966 
    return not (self == other)
6967 
 
6968 
class changeItemStatus_args:
6969 
  """
6970 
  Attributes:
6971 
   - item_id
6972 
   - timestamp
6973 
   - newstatus
6974 
  """
6975 
 
6976 
  thrift_spec = (
6977 
    None, # 0
6978 
    (1, TType.I64, 'item_id', None, None, ), # 1
6979 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6980 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6981 
  )
6982 
 
6983 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6984 
    self.item_id = item_id
6985 
    self.timestamp = timestamp
6986 
    self.newstatus = newstatus
6987 
 
6988 
  def read(self, iprot):
6989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6991 
      return
6992 
    iprot.readStructBegin()
6993 
    while True:
6994 
      (fname, ftype, fid) = iprot.readFieldBegin()
6995 
      if ftype == TType.STOP:
6996 
        break
6997 
      if fid == 1:
6998 
        if ftype == TType.I64:
6999 
          self.item_id = iprot.readI64();
7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      elif fid == 2:
7003 
        if ftype == TType.I64:
7004 
          self.timestamp = iprot.readI64();
7005 
        else:
7006 
          iprot.skip(ftype)
7007 
      elif fid == 3:
7008 
        if ftype == TType.I32:
7009 
          self.newstatus = iprot.readI32();
7010 
        else:
7011 
          iprot.skip(ftype)
7012 
      else:
7013 
        iprot.skip(ftype)
7014 
      iprot.readFieldEnd()
7015 
    iprot.readStructEnd()
7016 
 
7017 
  def write(self, oprot):
7018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7020 
      return
7021 
    oprot.writeStructBegin('changeItemStatus_args')
7022 
    if self.item_id is not None:
7023 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7024 
      oprot.writeI64(self.item_id)
7025 
      oprot.writeFieldEnd()
7026 
    if self.timestamp is not None:
7027 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7028 
      oprot.writeI64(self.timestamp)
7029 
      oprot.writeFieldEnd()
7030 
    if self.newstatus is not None:
7031 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7032 
      oprot.writeI32(self.newstatus)
7033 
      oprot.writeFieldEnd()
7034 
    oprot.writeFieldStop()
7035 
    oprot.writeStructEnd()
7036 
 
7037 
  def validate(self):
7038 
    return
7039 
 
7040 
 
7041 
  def __repr__(self):
7042 
    L = ['%s=%r' % (key, value)
7043 
      for key, value in self.__dict__.iteritems()]
7044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7045 
 
7046 
  def __eq__(self, other):
7047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7048 
 
7049 
  def __ne__(self, other):
7050 
    return not (self == other)
7051 
 
7052 
class changeItemStatus_result:
7053 
  """
7054 
  Attributes:
7055 
   - cex
7056 
  """
7057 
 
7058 
  thrift_spec = (
7059 
    None, # 0
7060 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7061 
  )
7062 
 
7063 
  def __init__(self, cex=None,):
7064 
    self.cex = cex
7065 
 
7066 
  def read(self, iprot):
7067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7069 
      return
7070 
    iprot.readStructBegin()
7071 
    while True:
7072 
      (fname, ftype, fid) = iprot.readFieldBegin()
7073 
      if ftype == TType.STOP:
7074 
        break
7075 
      if fid == 1:
7076 
        if ftype == TType.STRUCT:
7077 
          self.cex = CatalogServiceException()
7078 
          self.cex.read(iprot)
7079 
        else:
7080 
          iprot.skip(ftype)
7081 
      else:
7082 
        iprot.skip(ftype)
7083 
      iprot.readFieldEnd()
7084 
    iprot.readStructEnd()
7085 
 
7086 
  def write(self, oprot):
7087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7089 
      return
7090 
    oprot.writeStructBegin('changeItemStatus_result')
7091 
    if self.cex is not None:
7092 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7093 
      self.cex.write(oprot)
7094 
      oprot.writeFieldEnd()
7095 
    oprot.writeFieldStop()
7096 
    oprot.writeStructEnd()
7097 
 
7098 
  def validate(self):
7099 
    return
7100 
 
7101 
 
7102 
  def __repr__(self):
7103 
    L = ['%s=%r' % (key, value)
7104 
      for key, value in self.__dict__.iteritems()]
7105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7106 
 
7107 
  def __eq__(self, other):
7108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7109 
 
7110 
  def __ne__(self, other):
7111 
    return not (self == other)
7112 
 
7113 
class getItem_args:
7114 
  """
7115 
  Attributes:
7116 
   - item_id
7117 
  """
7118 
 
7119 
  thrift_spec = (
7120 
    None, # 0
7121 
    (1, TType.I64, 'item_id', None, None, ), # 1
7122 
  )
7123 
 
7124 
  def __init__(self, item_id=None,):
7125 
    self.item_id = item_id
7126 
 
7127 
  def read(self, iprot):
7128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7130 
      return
7131 
    iprot.readStructBegin()
7132 
    while True:
7133 
      (fname, ftype, fid) = iprot.readFieldBegin()
7134 
      if ftype == TType.STOP:
7135 
        break
7136 
      if fid == 1:
7137 
        if ftype == TType.I64:
7138 
          self.item_id = iprot.readI64();
7139 
        else:
7140 
          iprot.skip(ftype)
7141 
      else:
7142 
        iprot.skip(ftype)
7143 
      iprot.readFieldEnd()
7144 
    iprot.readStructEnd()
7145 
 
7146 
  def write(self, oprot):
7147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7149 
      return
7150 
    oprot.writeStructBegin('getItem_args')
7151 
    if self.item_id is not None:
7152 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7153 
      oprot.writeI64(self.item_id)
7154 
      oprot.writeFieldEnd()
7155 
    oprot.writeFieldStop()
7156 
    oprot.writeStructEnd()
7157 
 
7158 
  def validate(self):
7159 
    return
7160 
 
7161 
 
7162 
  def __repr__(self):
7163 
    L = ['%s=%r' % (key, value)
7164 
      for key, value in self.__dict__.iteritems()]
7165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7166 
 
7167 
  def __eq__(self, other):
7168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7169 
 
7170 
  def __ne__(self, other):
7171 
    return not (self == other)
7172 
 
7173 
class getItem_result:
7174 
  """
7175 
  Attributes:
7176 
   - success
7177 
   - cex
7178 
  """
7179 
 
7180 
  thrift_spec = (
7181 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7182 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7183 
  )
7184 
 
7185 
  def __init__(self, success=None, cex=None,):
7186 
    self.success = success
7187 
    self.cex = cex
7188 
 
7189 
  def read(self, iprot):
7190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7192 
      return
7193 
    iprot.readStructBegin()
7194 
    while True:
7195 
      (fname, ftype, fid) = iprot.readFieldBegin()
7196 
      if ftype == TType.STOP:
7197 
        break
7198 
      if fid == 0:
7199 
        if ftype == TType.STRUCT:
7200 
          self.success = Item()
7201 
          self.success.read(iprot)
7202 
        else:
7203 
          iprot.skip(ftype)
7204 
      elif fid == 1:
7205 
        if ftype == TType.STRUCT:
7206 
          self.cex = CatalogServiceException()
7207 
          self.cex.read(iprot)
7208 
        else:
7209 
          iprot.skip(ftype)
7210 
      else:
7211 
        iprot.skip(ftype)
7212 
      iprot.readFieldEnd()
7213 
    iprot.readStructEnd()
7214 
 
7215 
  def write(self, oprot):
7216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7218 
      return
7219 
    oprot.writeStructBegin('getItem_result')
7220 
    if self.success is not None:
7221 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7222 
      self.success.write(oprot)
7223 
      oprot.writeFieldEnd()
7224 
    if self.cex is not None:
7225 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7226 
      self.cex.write(oprot)
7227 
      oprot.writeFieldEnd()
7228 
    oprot.writeFieldStop()
7229 
    oprot.writeStructEnd()
7230 
 
7231 
  def validate(self):
7232 
    return
7233 
 
7234 
 
7235 
  def __repr__(self):
7236 
    L = ['%s=%r' % (key, value)
7237 
      for key, value in self.__dict__.iteritems()]
7238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7239 
 
7240 
  def __eq__(self, other):
7241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7242 
 
7243 
  def __ne__(self, other):
7244 
    return not (self == other)
7245 
 
7246 
class getItemsByCatalogId_args:
7247 
  """
7248 
  Attributes:
7249 
   - catalog_item_id
7250 
  """
7251 
 
7252 
  thrift_spec = (
7253 
    None, # 0
7254 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7255 
  )
7256 
 
7257 
  def __init__(self, catalog_item_id=None,):
7258 
    self.catalog_item_id = catalog_item_id
7259 
 
7260 
  def read(self, iprot):
7261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7263 
      return
7264 
    iprot.readStructBegin()
7265 
    while True:
7266 
      (fname, ftype, fid) = iprot.readFieldBegin()
7267 
      if ftype == TType.STOP:
7268 
        break
7269 
      if fid == 1:
7270 
        if ftype == TType.I64:
7271 
          self.catalog_item_id = iprot.readI64();
7272 
        else:
7273 
          iprot.skip(ftype)
7274 
      else:
7275 
        iprot.skip(ftype)
7276 
      iprot.readFieldEnd()
7277 
    iprot.readStructEnd()
7278 
 
7279 
  def write(self, oprot):
7280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7282 
      return
7283 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7284 
    if self.catalog_item_id is not None:
7285 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7286 
      oprot.writeI64(self.catalog_item_id)
7287 
      oprot.writeFieldEnd()
7288 
    oprot.writeFieldStop()
7289 
    oprot.writeStructEnd()
7290 
 
7291 
  def validate(self):
7292 
    return
7293 
 
7294 
 
7295 
  def __repr__(self):
7296 
    L = ['%s=%r' % (key, value)
7297 
      for key, value in self.__dict__.iteritems()]
7298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7299 
 
7300 
  def __eq__(self, other):
7301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7302 
 
7303 
  def __ne__(self, other):
7304 
    return not (self == other)
7305 
 
7306 
class getItemsByCatalogId_result:
7307 
  """
7308 
  Attributes:
7309 
   - success
7310 
   - cex
7311 
  """
7312 
 
7313 
  thrift_spec = (
7314 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7315 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7316 
  )
7317 
 
7318 
  def __init__(self, success=None, cex=None,):
7319 
    self.success = success
7320 
    self.cex = cex
7321 
 
7322 
  def read(self, iprot):
7323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7325 
      return
7326 
    iprot.readStructBegin()
7327 
    while True:
7328 
      (fname, ftype, fid) = iprot.readFieldBegin()
7329 
      if ftype == TType.STOP:
7330 
        break
7331 
      if fid == 0:
7332 
        if ftype == TType.LIST:
7333 
          self.success = []
7438 amit.gupta 7334 
          (_etype35, _size32) = iprot.readListBegin()
7335 
          for _i36 in xrange(_size32):
7336 
            _elem37 = Item()
7337 
            _elem37.read(iprot)
7338 
            self.success.append(_elem37)
5944 mandeep.dh 7339 
          iprot.readListEnd()
7340 
        else:
7341 
          iprot.skip(ftype)
7342 
      elif fid == 1:
7343 
        if ftype == TType.STRUCT:
7344 
          self.cex = CatalogServiceException()
7345 
          self.cex.read(iprot)
7346 
        else:
7347 
          iprot.skip(ftype)
7348 
      else:
7349 
        iprot.skip(ftype)
7350 
      iprot.readFieldEnd()
7351 
    iprot.readStructEnd()
7352 
 
7353 
  def write(self, oprot):
7354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7356 
      return
7357 
    oprot.writeStructBegin('getItemsByCatalogId_result')
7358 
    if self.success is not None:
7359 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7360 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7361 
      for iter38 in self.success:
7362 
        iter38.write(oprot)
5944 mandeep.dh 7363 
      oprot.writeListEnd()
7364 
      oprot.writeFieldEnd()
7365 
    if self.cex is not None:
7366 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7367 
      self.cex.write(oprot)
7368 
      oprot.writeFieldEnd()
7369 
    oprot.writeFieldStop()
7370 
    oprot.writeStructEnd()
7371 
 
7372 
  def validate(self):
7373 
    return
7374 
 
7375 
 
7376 
  def __repr__(self):
7377 
    L = ['%s=%r' % (key, value)
7378 
      for key, value in self.__dict__.iteritems()]
7379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7380 
 
7381 
  def __eq__(self, other):
7382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7383 
 
7384 
  def __ne__(self, other):
7385 
    return not (self == other)
7386 
 
7387 
class getValidItemsByCatalogId_args:
7388 
  """
7389 
  Attributes:
7390 
   - catalog_item_id
7391 
  """
7392 
 
7393 
  thrift_spec = (
7394 
    None, # 0
7395 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7396 
  )
7397 
 
7398 
  def __init__(self, catalog_item_id=None,):
7399 
    self.catalog_item_id = catalog_item_id
7400 
 
7401 
  def read(self, iprot):
7402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7404 
      return
7405 
    iprot.readStructBegin()
7406 
    while True:
7407 
      (fname, ftype, fid) = iprot.readFieldBegin()
7408 
      if ftype == TType.STOP:
7409 
        break
7410 
      if fid == 1:
7411 
        if ftype == TType.I64:
7412 
          self.catalog_item_id = iprot.readI64();
7413 
        else:
7414 
          iprot.skip(ftype)
7415 
      else:
7416 
        iprot.skip(ftype)
7417 
      iprot.readFieldEnd()
7418 
    iprot.readStructEnd()
7419 
 
7420 
  def write(self, oprot):
7421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7423 
      return
7424 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
7425 
    if self.catalog_item_id is not None:
7426 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7427 
      oprot.writeI64(self.catalog_item_id)
7428 
      oprot.writeFieldEnd()
7429 
    oprot.writeFieldStop()
7430 
    oprot.writeStructEnd()
7431 
 
7432 
  def validate(self):
7433 
    return
7434 
 
7435 
 
7436 
  def __repr__(self):
7437 
    L = ['%s=%r' % (key, value)
7438 
      for key, value in self.__dict__.iteritems()]
7439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7440 
 
7441 
  def __eq__(self, other):
7442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7443 
 
7444 
  def __ne__(self, other):
7445 
    return not (self == other)
7446 
 
7447 
class getValidItemsByCatalogId_result:
7448 
  """
7449 
  Attributes:
7450 
   - success
7451 
   - cex
7452 
  """
7453 
 
7454 
  thrift_spec = (
7455 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7456 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7457 
  )
7458 
 
7459 
  def __init__(self, success=None, cex=None,):
7460 
    self.success = success
7461 
    self.cex = cex
7462 
 
7463 
  def read(self, iprot):
7464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7466 
      return
7467 
    iprot.readStructBegin()
7468 
    while True:
7469 
      (fname, ftype, fid) = iprot.readFieldBegin()
7470 
      if ftype == TType.STOP:
7471 
        break
7472 
      if fid == 0:
7473 
        if ftype == TType.LIST:
7474 
          self.success = []
7438 amit.gupta 7475 
          (_etype42, _size39) = iprot.readListBegin()
7476 
          for _i43 in xrange(_size39):
7477 
            _elem44 = Item()
7478 
            _elem44.read(iprot)
7479 
            self.success.append(_elem44)
5944 mandeep.dh 7480 
          iprot.readListEnd()
7481 
        else:
7482 
          iprot.skip(ftype)
7483 
      elif fid == 1:
7484 
        if ftype == TType.STRUCT:
7485 
          self.cex = CatalogServiceException()
7486 
          self.cex.read(iprot)
7487 
        else:
7488 
          iprot.skip(ftype)
7489 
      else:
7490 
        iprot.skip(ftype)
7491 
      iprot.readFieldEnd()
7492 
    iprot.readStructEnd()
7493 
 
7494 
  def write(self, oprot):
7495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7497 
      return
7498 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7499 
    if self.success is not None:
7500 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7501 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7502 
      for iter45 in self.success:
7503 
        iter45.write(oprot)
5944 mandeep.dh 7504 
      oprot.writeListEnd()
7505 
      oprot.writeFieldEnd()
7506 
    if self.cex is not None:
7507 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7508 
      self.cex.write(oprot)
7509 
      oprot.writeFieldEnd()
7510 
    oprot.writeFieldStop()
7511 
    oprot.writeStructEnd()
7512 
 
7513 
  def validate(self):
7514 
    return
7515 
 
7516 
 
7517 
  def __repr__(self):
7518 
    L = ['%s=%r' % (key, value)
7519 
      for key, value in self.__dict__.iteritems()]
7520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7521 
 
7522 
  def __eq__(self, other):
7523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7524 
 
7525 
  def __ne__(self, other):
7526 
    return not (self == other)
7527 
 
7528 
class getAllItems_args:
7529 
  """
7530 
  Attributes:
7531 
   - isActive
7532 
  """
7533 
 
7534 
  thrift_spec = (
7535 
    None, # 0
7536 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7537 
  )
7538 
 
7539 
  def __init__(self, isActive=None,):
7540 
    self.isActive = isActive
7541 
 
7542 
  def read(self, iprot):
7543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7545 
      return
7546 
    iprot.readStructBegin()
7547 
    while True:
7548 
      (fname, ftype, fid) = iprot.readFieldBegin()
7549 
      if ftype == TType.STOP:
7550 
        break
7551 
      if fid == 1:
7552 
        if ftype == TType.BOOL:
7553 
          self.isActive = iprot.readBool();
7554 
        else:
7555 
          iprot.skip(ftype)
7556 
      else:
7557 
        iprot.skip(ftype)
7558 
      iprot.readFieldEnd()
7559 
    iprot.readStructEnd()
7560 
 
7561 
  def write(self, oprot):
7562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7564 
      return
7565 
    oprot.writeStructBegin('getAllItems_args')
7566 
    if self.isActive is not None:
7567 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7568 
      oprot.writeBool(self.isActive)
7569 
      oprot.writeFieldEnd()
7570 
    oprot.writeFieldStop()
7571 
    oprot.writeStructEnd()
7572 
 
7573 
  def validate(self):
7574 
    return
7575 
 
7576 
 
7577 
  def __repr__(self):
7578 
    L = ['%s=%r' % (key, value)
7579 
      for key, value in self.__dict__.iteritems()]
7580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7581 
 
7582 
  def __eq__(self, other):
7583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7584 
 
7585 
  def __ne__(self, other):
7586 
    return not (self == other)
7587 
 
7588 
class getAllItems_result:
7589 
  """
7590 
  Attributes:
7591 
   - success
7592 
   - cex
7593 
  """
7594 
 
7595 
  thrift_spec = (
7596 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7597 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7598 
  )
7599 
 
7600 
  def __init__(self, success=None, cex=None,):
7601 
    self.success = success
7602 
    self.cex = cex
7603 
 
7604 
  def read(self, iprot):
7605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7607 
      return
7608 
    iprot.readStructBegin()
7609 
    while True:
7610 
      (fname, ftype, fid) = iprot.readFieldBegin()
7611 
      if ftype == TType.STOP:
7612 
        break
7613 
      if fid == 0:
7614 
        if ftype == TType.LIST:
7615 
          self.success = []
7438 amit.gupta 7616 
          (_etype49, _size46) = iprot.readListBegin()
7617 
          for _i50 in xrange(_size46):
7618 
            _elem51 = Item()
7619 
            _elem51.read(iprot)
7620 
            self.success.append(_elem51)
5944 mandeep.dh 7621 
          iprot.readListEnd()
7622 
        else:
7623 
          iprot.skip(ftype)
7624 
      elif fid == 1:
7625 
        if ftype == TType.STRUCT:
7626 
          self.cex = CatalogServiceException()
7627 
          self.cex.read(iprot)
7628 
        else:
7629 
          iprot.skip(ftype)
7630 
      else:
7631 
        iprot.skip(ftype)
7632 
      iprot.readFieldEnd()
7633 
    iprot.readStructEnd()
7634 
 
7635 
  def write(self, oprot):
7636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7638 
      return
7639 
    oprot.writeStructBegin('getAllItems_result')
7640 
    if self.success is not None:
7641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7643 
      for iter52 in self.success:
7644 
        iter52.write(oprot)
5944 mandeep.dh 7645 
      oprot.writeListEnd()
7646 
      oprot.writeFieldEnd()
7647 
    if self.cex is not None:
7648 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7649 
      self.cex.write(oprot)
7650 
      oprot.writeFieldEnd()
7651 
    oprot.writeFieldStop()
7652 
    oprot.writeStructEnd()
7653 
 
7654 
  def validate(self):
7655 
    return
7656 
 
7657 
 
7658 
  def __repr__(self):
7659 
    L = ['%s=%r' % (key, value)
7660 
      for key, value in self.__dict__.iteritems()]
7661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7662 
 
7663 
  def __eq__(self, other):
7664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7665 
 
7666 
  def __ne__(self, other):
7667 
    return not (self == other)
7668 
 
7669 
class getAllItemsByStatus_args:
7670 
  """
7671 
  Attributes:
7672 
   - itemStatus
7673 
  """
7674 
 
7675 
  thrift_spec = (
7676 
    None, # 0
7677 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7678 
  )
7679 
 
7680 
  def __init__(self, itemStatus=None,):
7681 
    self.itemStatus = itemStatus
7682 
 
7683 
  def read(self, iprot):
7684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7686 
      return
7687 
    iprot.readStructBegin()
7688 
    while True:
7689 
      (fname, ftype, fid) = iprot.readFieldBegin()
7690 
      if ftype == TType.STOP:
7691 
        break
7692 
      if fid == 1:
7693 
        if ftype == TType.I32:
7694 
          self.itemStatus = iprot.readI32();
7695 
        else:
7696 
          iprot.skip(ftype)
7697 
      else:
7698 
        iprot.skip(ftype)
7699 
      iprot.readFieldEnd()
7700 
    iprot.readStructEnd()
7701 
 
7702 
  def write(self, oprot):
7703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7705 
      return
7706 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7707 
    if self.itemStatus is not None:
7708 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7709 
      oprot.writeI32(self.itemStatus)
7710 
      oprot.writeFieldEnd()
7711 
    oprot.writeFieldStop()
7712 
    oprot.writeStructEnd()
7713 
 
7714 
  def validate(self):
7715 
    return
7716 
 
7717 
 
7718 
  def __repr__(self):
7719 
    L = ['%s=%r' % (key, value)
7720 
      for key, value in self.__dict__.iteritems()]
7721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7722 
 
7723 
  def __eq__(self, other):
7724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7725 
 
7726 
  def __ne__(self, other):
7727 
    return not (self == other)
7728 
 
7729 
class getAllItemsByStatus_result:
7730 
  """
7731 
  Attributes:
7732 
   - success
7733 
   - cex
7734 
  """
7735 
 
7736 
  thrift_spec = (
7737 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7738 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7739 
  )
7740 
 
7741 
  def __init__(self, success=None, cex=None,):
7742 
    self.success = success
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 == 0:
7755 
        if ftype == TType.LIST:
7756 
          self.success = []
7438 amit.gupta 7757 
          (_etype56, _size53) = iprot.readListBegin()
7758 
          for _i57 in xrange(_size53):
7759 
            _elem58 = Item()
7760 
            _elem58.read(iprot)
7761 
            self.success.append(_elem58)
5944 mandeep.dh 7762 
          iprot.readListEnd()
7763 
        else:
7764 
          iprot.skip(ftype)
7765 
      elif fid == 1:
7766 
        if ftype == TType.STRUCT:
7767 
          self.cex = CatalogServiceException()
7768 
          self.cex.read(iprot)
7769 
        else:
7770 
          iprot.skip(ftype)
7771 
      else:
7772 
        iprot.skip(ftype)
7773 
      iprot.readFieldEnd()
7774 
    iprot.readStructEnd()
7775 
 
7776 
  def write(self, oprot):
7777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7779 
      return
7780 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7781 
    if self.success is not None:
7782 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7783 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7784 
      for iter59 in self.success:
7785 
        iter59.write(oprot)
5944 mandeep.dh 7786 
      oprot.writeListEnd()
7787 
      oprot.writeFieldEnd()
7788 
    if self.cex is not None:
7789 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7790 
      self.cex.write(oprot)
7791 
      oprot.writeFieldEnd()
7792 
    oprot.writeFieldStop()
7793 
    oprot.writeStructEnd()
7794 
 
7795 
  def validate(self):
7796 
    return
7797 
 
7798 
 
7799 
  def __repr__(self):
7800 
    L = ['%s=%r' % (key, value)
7801 
      for key, value in self.__dict__.iteritems()]
7802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7803 
 
7804 
  def __eq__(self, other):
7805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7806 
 
7807 
  def __ne__(self, other):
7808 
    return not (self == other)
7809 
 
7810 
class markItemAsContentComplete_args:
7811 
  """
7812 
  Attributes:
7813 
   - entityId
7814 
   - category
7815 
   - brand
7816 
   - modelName
7817 
   - modelNumber
7818 
  """
7819 
 
7820 
  thrift_spec = (
7821 
    None, # 0
7822 
    (1, TType.I64, 'entityId', None, None, ), # 1
7823 
    (2, TType.I64, 'category', None, None, ), # 2
7824 
    (3, TType.STRING, 'brand', None, None, ), # 3
7825 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7826 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7827 
  )
7828 
 
7829 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7830 
    self.entityId = entityId
7831 
    self.category = category
7832 
    self.brand = brand
7833 
    self.modelName = modelName
7834 
    self.modelNumber = modelNumber
7835 
 
7836 
  def read(self, iprot):
7837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7839 
      return
7840 
    iprot.readStructBegin()
7841 
    while True:
7842 
      (fname, ftype, fid) = iprot.readFieldBegin()
7843 
      if ftype == TType.STOP:
7844 
        break
7845 
      if fid == 1:
7846 
        if ftype == TType.I64:
7847 
          self.entityId = iprot.readI64();
7848 
        else:
7849 
          iprot.skip(ftype)
7850 
      elif fid == 2:
7851 
        if ftype == TType.I64:
7852 
          self.category = iprot.readI64();
7853 
        else:
7854 
          iprot.skip(ftype)
7855 
      elif fid == 3:
7856 
        if ftype == TType.STRING:
7857 
          self.brand = iprot.readString();
7858 
        else:
7859 
          iprot.skip(ftype)
7860 
      elif fid == 4:
7861 
        if ftype == TType.STRING:
7862 
          self.modelName = iprot.readString();
7863 
        else:
7864 
          iprot.skip(ftype)
7865 
      elif fid == 5:
7866 
        if ftype == TType.STRING:
7867 
          self.modelNumber = iprot.readString();
7868 
        else:
7869 
          iprot.skip(ftype)
7870 
      else:
7871 
        iprot.skip(ftype)
7872 
      iprot.readFieldEnd()
7873 
    iprot.readStructEnd()
7874 
 
7875 
  def write(self, oprot):
7876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7878 
      return
7879 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7880 
    if self.entityId is not None:
7881 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7882 
      oprot.writeI64(self.entityId)
7883 
      oprot.writeFieldEnd()
7884 
    if self.category is not None:
7885 
      oprot.writeFieldBegin('category', TType.I64, 2)
7886 
      oprot.writeI64(self.category)
7887 
      oprot.writeFieldEnd()
7888 
    if self.brand is not None:
7889 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7890 
      oprot.writeString(self.brand)
7891 
      oprot.writeFieldEnd()
7892 
    if self.modelName is not None:
7893 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7894 
      oprot.writeString(self.modelName)
7895 
      oprot.writeFieldEnd()
7896 
    if self.modelNumber is not None:
7897 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7898 
      oprot.writeString(self.modelNumber)
7899 
      oprot.writeFieldEnd()
7900 
    oprot.writeFieldStop()
7901 
    oprot.writeStructEnd()
7902 
 
7903 
  def validate(self):
7904 
    return
7905 
 
7906 
 
7907 
  def __repr__(self):
7908 
    L = ['%s=%r' % (key, value)
7909 
      for key, value in self.__dict__.iteritems()]
7910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7911 
 
7912 
  def __eq__(self, other):
7913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7914 
 
7915 
  def __ne__(self, other):
7916 
    return not (self == other)
7917 
 
7918 
class markItemAsContentComplete_result:
7919 
  """
7920 
  Attributes:
7921 
   - success
7922 
   - cex
7923 
  """
7924 
 
7925 
  thrift_spec = (
7926 
    (0, TType.BOOL, 'success', None, None, ), # 0
7927 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7928 
  )
7929 
 
7930 
  def __init__(self, success=None, cex=None,):
7931 
    self.success = success
7932 
    self.cex = cex
7933 
 
7934 
  def read(self, iprot):
7935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7937 
      return
7938 
    iprot.readStructBegin()
7939 
    while True:
7940 
      (fname, ftype, fid) = iprot.readFieldBegin()
7941 
      if ftype == TType.STOP:
7942 
        break
7943 
      if fid == 0:
7944 
        if ftype == TType.BOOL:
7945 
          self.success = iprot.readBool();
7946 
        else:
7947 
          iprot.skip(ftype)
7948 
      elif fid == 1:
7949 
        if ftype == TType.STRUCT:
7950 
          self.cex = CatalogServiceException()
7951 
          self.cex.read(iprot)
7952 
        else:
7953 
          iprot.skip(ftype)
7954 
      else:
7955 
        iprot.skip(ftype)
7956 
      iprot.readFieldEnd()
7957 
    iprot.readStructEnd()
7958 
 
7959 
  def write(self, oprot):
7960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7962 
      return
7963 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7964 
    if self.success is not None:
7965 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7966 
      oprot.writeBool(self.success)
7967 
      oprot.writeFieldEnd()
7968 
    if self.cex is not None:
7969 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7970 
      self.cex.write(oprot)
7971 
      oprot.writeFieldEnd()
7972 
    oprot.writeFieldStop()
7973 
    oprot.writeStructEnd()
7974 
 
7975 
  def validate(self):
7976 
    return
7977 
 
7978 
 
7979 
  def __repr__(self):
7980 
    L = ['%s=%r' % (key, value)
7981 
      for key, value in self.__dict__.iteritems()]
7982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7983 
 
7984 
  def __eq__(self, other):
7985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7986 
 
7987 
  def __ne__(self, other):
7988 
    return not (self == other)
7989 
 
7990 
class getAllItemsInRange_args:
7991 
  """
7992 
  Attributes:
7993 
   - offset
7994 
   - limit
7995 
  """
7996 
 
7997 
  thrift_spec = (
7998 
    None, # 0
7999 
    (1, TType.I64, 'offset', None, None, ), # 1
8000 
    (2, TType.I64, 'limit', None, None, ), # 2
8001 
  )
8002 
 
8003 
  def __init__(self, offset=None, limit=None,):
8004 
    self.offset = offset
8005 
    self.limit = limit
8006 
 
8007 
  def read(self, iprot):
8008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8010 
      return
8011 
    iprot.readStructBegin()
8012 
    while True:
8013 
      (fname, ftype, fid) = iprot.readFieldBegin()
8014 
      if ftype == TType.STOP:
8015 
        break
8016 
      if fid == 1:
8017 
        if ftype == TType.I64:
8018 
          self.offset = iprot.readI64();
8019 
        else:
8020 
          iprot.skip(ftype)
8021 
      elif fid == 2:
8022 
        if ftype == TType.I64:
8023 
          self.limit = iprot.readI64();
8024 
        else:
8025 
          iprot.skip(ftype)
8026 
      else:
8027 
        iprot.skip(ftype)
8028 
      iprot.readFieldEnd()
8029 
    iprot.readStructEnd()
8030 
 
8031 
  def write(self, oprot):
8032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8034 
      return
8035 
    oprot.writeStructBegin('getAllItemsInRange_args')
8036 
    if self.offset is not None:
8037 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8038 
      oprot.writeI64(self.offset)
8039 
      oprot.writeFieldEnd()
8040 
    if self.limit is not None:
8041 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8042 
      oprot.writeI64(self.limit)
8043 
      oprot.writeFieldEnd()
8044 
    oprot.writeFieldStop()
8045 
    oprot.writeStructEnd()
8046 
 
8047 
  def validate(self):
8048 
    return
8049 
 
8050 
 
8051 
  def __repr__(self):
8052 
    L = ['%s=%r' % (key, value)
8053 
      for key, value in self.__dict__.iteritems()]
8054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8055 
 
8056 
  def __eq__(self, other):
8057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8058 
 
8059 
  def __ne__(self, other):
8060 
    return not (self == other)
8061 
 
8062 
class getAllItemsInRange_result:
8063 
  """
8064 
  Attributes:
8065 
   - success
8066 
   - cex
8067 
  """
8068 
 
8069 
  thrift_spec = (
8070 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8071 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8072 
  )
8073 
 
8074 
  def __init__(self, success=None, cex=None,):
8075 
    self.success = success
8076 
    self.cex = cex
8077 
 
8078 
  def read(self, iprot):
8079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8081 
      return
8082 
    iprot.readStructBegin()
8083 
    while True:
8084 
      (fname, ftype, fid) = iprot.readFieldBegin()
8085 
      if ftype == TType.STOP:
8086 
        break
8087 
      if fid == 0:
8088 
        if ftype == TType.LIST:
8089 
          self.success = []
7438 amit.gupta 8090 
          (_etype63, _size60) = iprot.readListBegin()
8091 
          for _i64 in xrange(_size60):
8092 
            _elem65 = Item()
8093 
            _elem65.read(iprot)
8094 
            self.success.append(_elem65)
5944 mandeep.dh 8095 
          iprot.readListEnd()
8096 
        else:
8097 
          iprot.skip(ftype)
8098 
      elif fid == 1:
8099 
        if ftype == TType.STRUCT:
8100 
          self.cex = CatalogServiceException()
8101 
          self.cex.read(iprot)
8102 
        else:
8103 
          iprot.skip(ftype)
8104 
      else:
8105 
        iprot.skip(ftype)
8106 
      iprot.readFieldEnd()
8107 
    iprot.readStructEnd()
8108 
 
8109 
  def write(self, oprot):
8110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8112 
      return
8113 
    oprot.writeStructBegin('getAllItemsInRange_result')
8114 
    if self.success is not None:
8115 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8116 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8117 
      for iter66 in self.success:
8118 
        iter66.write(oprot)
5944 mandeep.dh 8119 
      oprot.writeListEnd()
8120 
      oprot.writeFieldEnd()
8121 
    if self.cex is not None:
8122 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8123 
      self.cex.write(oprot)
8124 
      oprot.writeFieldEnd()
8125 
    oprot.writeFieldStop()
8126 
    oprot.writeStructEnd()
8127 
 
8128 
  def validate(self):
8129 
    return
8130 
 
8131 
 
8132 
  def __repr__(self):
8133 
    L = ['%s=%r' % (key, value)
8134 
      for key, value in self.__dict__.iteritems()]
8135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8136 
 
8137 
  def __eq__(self, other):
8138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8139 
 
8140 
  def __ne__(self, other):
8141 
    return not (self == other)
8142 
 
8143 
class getAllItemsByStatusInRange_args:
8144 
  """
8145 
  Attributes:
8146 
   - itemStatus
8147 
   - offset
8148 
   - limit
8149 
  """
8150 
 
8151 
  thrift_spec = (
8152 
    None, # 0
8153 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8154 
    (2, TType.I64, 'offset', None, None, ), # 2
8155 
    (3, TType.I64, 'limit', None, None, ), # 3
8156 
  )
8157 
 
8158 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8159 
    self.itemStatus = itemStatus
8160 
    self.offset = offset
8161 
    self.limit = limit
8162 
 
8163 
  def read(self, iprot):
8164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8166 
      return
8167 
    iprot.readStructBegin()
8168 
    while True:
8169 
      (fname, ftype, fid) = iprot.readFieldBegin()
8170 
      if ftype == TType.STOP:
8171 
        break
8172 
      if fid == 1:
8173 
        if ftype == TType.I32:
8174 
          self.itemStatus = iprot.readI32();
8175 
        else:
8176 
          iprot.skip(ftype)
8177 
      elif fid == 2:
8178 
        if ftype == TType.I64:
8179 
          self.offset = iprot.readI64();
8180 
        else:
8181 
          iprot.skip(ftype)
8182 
      elif fid == 3:
8183 
        if ftype == TType.I64:
8184 
          self.limit = iprot.readI64();
8185 
        else:
8186 
          iprot.skip(ftype)
8187 
      else:
8188 
        iprot.skip(ftype)
8189 
      iprot.readFieldEnd()
8190 
    iprot.readStructEnd()
8191 
 
8192 
  def write(self, oprot):
8193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8195 
      return
8196 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8197 
    if self.itemStatus is not None:
8198 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8199 
      oprot.writeI32(self.itemStatus)
8200 
      oprot.writeFieldEnd()
8201 
    if self.offset is not None:
8202 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8203 
      oprot.writeI64(self.offset)
8204 
      oprot.writeFieldEnd()
8205 
    if self.limit is not None:
8206 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8207 
      oprot.writeI64(self.limit)
8208 
      oprot.writeFieldEnd()
8209 
    oprot.writeFieldStop()
8210 
    oprot.writeStructEnd()
8211 
 
8212 
  def validate(self):
8213 
    return
8214 
 
8215 
 
8216 
  def __repr__(self):
8217 
    L = ['%s=%r' % (key, value)
8218 
      for key, value in self.__dict__.iteritems()]
8219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8220 
 
8221 
  def __eq__(self, other):
8222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8223 
 
8224 
  def __ne__(self, other):
8225 
    return not (self == other)
8226 
 
8227 
class getAllItemsByStatusInRange_result:
8228 
  """
8229 
  Attributes:
8230 
   - success
8231 
   - cex
8232 
  """
8233 
 
8234 
  thrift_spec = (
8235 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8236 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8237 
  )
8238 
 
8239 
  def __init__(self, success=None, cex=None,):
8240 
    self.success = success
8241 
    self.cex = cex
8242 
 
8243 
  def read(self, iprot):
8244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8246 
      return
8247 
    iprot.readStructBegin()
8248 
    while True:
8249 
      (fname, ftype, fid) = iprot.readFieldBegin()
8250 
      if ftype == TType.STOP:
8251 
        break
8252 
      if fid == 0:
8253 
        if ftype == TType.LIST:
8254 
          self.success = []
7438 amit.gupta 8255 
          (_etype70, _size67) = iprot.readListBegin()
8256 
          for _i71 in xrange(_size67):
8257 
            _elem72 = Item()
8258 
            _elem72.read(iprot)
8259 
            self.success.append(_elem72)
5944 mandeep.dh 8260 
          iprot.readListEnd()
8261 
        else:
8262 
          iprot.skip(ftype)
8263 
      elif fid == 1:
8264 
        if ftype == TType.STRUCT:
8265 
          self.cex = CatalogServiceException()
8266 
          self.cex.read(iprot)
8267 
        else:
8268 
          iprot.skip(ftype)
8269 
      else:
8270 
        iprot.skip(ftype)
8271 
      iprot.readFieldEnd()
8272 
    iprot.readStructEnd()
8273 
 
8274 
  def write(self, oprot):
8275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8277 
      return
8278 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8279 
    if self.success is not None:
8280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8282 
      for iter73 in self.success:
8283 
        iter73.write(oprot)
5944 mandeep.dh 8284 
      oprot.writeListEnd()
8285 
      oprot.writeFieldEnd()
8286 
    if self.cex is not None:
8287 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8288 
      self.cex.write(oprot)
8289 
      oprot.writeFieldEnd()
8290 
    oprot.writeFieldStop()
8291 
    oprot.writeStructEnd()
8292 
 
8293 
  def validate(self):
8294 
    return
8295 
 
8296 
 
8297 
  def __repr__(self):
8298 
    L = ['%s=%r' % (key, value)
8299 
      for key, value in self.__dict__.iteritems()]
8300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8301 
 
8302 
  def __eq__(self, other):
8303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8304 
 
8305 
  def __ne__(self, other):
8306 
    return not (self == other)
8307 
 
8308 
class getItemCountByStatus_args:
8309 
  """
8310 
  Attributes:
8311 
   - useStatus
8312 
   - itemStatus
8313 
  """
8314 
 
8315 
  thrift_spec = (
8316 
    None, # 0
8317 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8318 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8319 
  )
8320 
 
8321 
  def __init__(self, useStatus=None, itemStatus=None,):
8322 
    self.useStatus = useStatus
8323 
    self.itemStatus = itemStatus
8324 
 
8325 
  def read(self, iprot):
8326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8328 
      return
8329 
    iprot.readStructBegin()
8330 
    while True:
8331 
      (fname, ftype, fid) = iprot.readFieldBegin()
8332 
      if ftype == TType.STOP:
8333 
        break
8334 
      if fid == 1:
8335 
        if ftype == TType.BOOL:
8336 
          self.useStatus = iprot.readBool();
8337 
        else:
8338 
          iprot.skip(ftype)
8339 
      elif fid == 2:
8340 
        if ftype == TType.I32:
8341 
          self.itemStatus = iprot.readI32();
8342 
        else:
8343 
          iprot.skip(ftype)
8344 
      else:
8345 
        iprot.skip(ftype)
8346 
      iprot.readFieldEnd()
8347 
    iprot.readStructEnd()
8348 
 
8349 
  def write(self, oprot):
8350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8352 
      return
8353 
    oprot.writeStructBegin('getItemCountByStatus_args')
8354 
    if self.useStatus is not None:
8355 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8356 
      oprot.writeBool(self.useStatus)
8357 
      oprot.writeFieldEnd()
8358 
    if self.itemStatus is not None:
8359 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8360 
      oprot.writeI32(self.itemStatus)
8361 
      oprot.writeFieldEnd()
8362 
    oprot.writeFieldStop()
8363 
    oprot.writeStructEnd()
8364 
 
8365 
  def validate(self):
8366 
    return
8367 
 
8368 
 
8369 
  def __repr__(self):
8370 
    L = ['%s=%r' % (key, value)
8371 
      for key, value in self.__dict__.iteritems()]
8372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8373 
 
8374 
  def __eq__(self, other):
8375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8376 
 
8377 
  def __ne__(self, other):
8378 
    return not (self == other)
8379 
 
8380 
class getItemCountByStatus_result:
8381 
  """
8382 
  Attributes:
8383 
   - success
8384 
  """
8385 
 
8386 
  thrift_spec = (
8387 
    (0, TType.I32, 'success', None, None, ), # 0
8388 
  )
8389 
 
8390 
  def __init__(self, success=None,):
8391 
    self.success = success
8392 
 
8393 
  def read(self, iprot):
8394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8396 
      return
8397 
    iprot.readStructBegin()
8398 
    while True:
8399 
      (fname, ftype, fid) = iprot.readFieldBegin()
8400 
      if ftype == TType.STOP:
8401 
        break
8402 
      if fid == 0:
8403 
        if ftype == TType.I32:
8404 
          self.success = iprot.readI32();
8405 
        else:
8406 
          iprot.skip(ftype)
8407 
      else:
8408 
        iprot.skip(ftype)
8409 
      iprot.readFieldEnd()
8410 
    iprot.readStructEnd()
8411 
 
8412 
  def write(self, oprot):
8413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8415 
      return
8416 
    oprot.writeStructBegin('getItemCountByStatus_result')
8417 
    if self.success is not None:
8418 
      oprot.writeFieldBegin('success', TType.I32, 0)
8419 
      oprot.writeI32(self.success)
8420 
      oprot.writeFieldEnd()
8421 
    oprot.writeFieldStop()
8422 
    oprot.writeStructEnd()
8423 
 
8424 
  def validate(self):
8425 
    return
8426 
 
8427 
 
8428 
  def __repr__(self):
8429 
    L = ['%s=%r' % (key, value)
8430 
      for key, value in self.__dict__.iteritems()]
8431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8432 
 
8433 
  def __eq__(self, other):
8434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8435 
 
8436 
  def __ne__(self, other):
8437 
    return not (self == other)
8438 
 
8439 
class getBestSellers_args:
8440 
 
8441 
  thrift_spec = (
8442 
  )
8443 
 
8444 
  def read(self, iprot):
8445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8447 
      return
8448 
    iprot.readStructBegin()
8449 
    while True:
8450 
      (fname, ftype, fid) = iprot.readFieldBegin()
8451 
      if ftype == TType.STOP:
8452 
        break
8453 
      else:
8454 
        iprot.skip(ftype)
8455 
      iprot.readFieldEnd()
8456 
    iprot.readStructEnd()
8457 
 
8458 
  def write(self, oprot):
8459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8461 
      return
8462 
    oprot.writeStructBegin('getBestSellers_args')
8463 
    oprot.writeFieldStop()
8464 
    oprot.writeStructEnd()
8465 
 
8466 
  def validate(self):
8467 
    return
8468 
 
8469 
 
8470 
  def __repr__(self):
8471 
    L = ['%s=%r' % (key, value)
8472 
      for key, value in self.__dict__.iteritems()]
8473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8474 
 
8475 
  def __eq__(self, other):
8476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8477 
 
8478 
  def __ne__(self, other):
8479 
    return not (self == other)
8480 
 
8481 
class getBestSellers_result:
8482 
  """
8483 
  Attributes:
8484 
   - success
8485 
   - isex
8486 
  """
8487 
 
8488 
  thrift_spec = (
8489 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8490 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8491 
  )
8492 
 
8493 
  def __init__(self, success=None, isex=None,):
8494 
    self.success = success
8495 
    self.isex = isex
8496 
 
8497 
  def read(self, iprot):
8498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8500 
      return
8501 
    iprot.readStructBegin()
8502 
    while True:
8503 
      (fname, ftype, fid) = iprot.readFieldBegin()
8504 
      if ftype == TType.STOP:
8505 
        break
8506 
      if fid == 0:
8507 
        if ftype == TType.LIST:
8508 
          self.success = []
7438 amit.gupta 8509 
          (_etype77, _size74) = iprot.readListBegin()
8510 
          for _i78 in xrange(_size74):
8511 
            _elem79 = Item()
8512 
            _elem79.read(iprot)
8513 
            self.success.append(_elem79)
5944 mandeep.dh 8514 
          iprot.readListEnd()
8515 
        else:
8516 
          iprot.skip(ftype)
8517 
      elif fid == 1:
8518 
        if ftype == TType.STRUCT:
8519 
          self.isex = CatalogServiceException()
8520 
          self.isex.read(iprot)
8521 
        else:
8522 
          iprot.skip(ftype)
8523 
      else:
8524 
        iprot.skip(ftype)
8525 
      iprot.readFieldEnd()
8526 
    iprot.readStructEnd()
8527 
 
8528 
  def write(self, oprot):
8529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8531 
      return
8532 
    oprot.writeStructBegin('getBestSellers_result')
8533 
    if self.success is not None:
8534 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8535 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8536 
      for iter80 in self.success:
8537 
        iter80.write(oprot)
5944 mandeep.dh 8538 
      oprot.writeListEnd()
8539 
      oprot.writeFieldEnd()
8540 
    if self.isex is not None:
8541 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8542 
      self.isex.write(oprot)
8543 
      oprot.writeFieldEnd()
8544 
    oprot.writeFieldStop()
8545 
    oprot.writeStructEnd()
8546 
 
8547 
  def validate(self):
8548 
    return
8549 
 
8550 
 
8551 
  def __repr__(self):
8552 
    L = ['%s=%r' % (key, value)
8553 
      for key, value in self.__dict__.iteritems()]
8554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8555 
 
8556 
  def __eq__(self, other):
8557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8558 
 
8559 
  def __ne__(self, other):
8560 
    return not (self == other)
8561 
 
8562 
class getBestSellersCatalogIds_args:
8563 
  """
8564 
  Attributes:
8565 
   - beginIndex
8566 
   - totalItems
8567 
   - brand
8568 
   - category
8569 
  """
8570 
 
8571 
  thrift_spec = (
8572 
    None, # 0
8573 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8574 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8575 
    (3, TType.STRING, 'brand', None, None, ), # 3
8576 
    (4, TType.I64, 'category', None, None, ), # 4
8577 
  )
8578 
 
8579 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8580 
    self.beginIndex = beginIndex
8581 
    self.totalItems = totalItems
8582 
    self.brand = brand
8583 
    self.category = category
8584 
 
8585 
  def read(self, iprot):
8586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8588 
      return
8589 
    iprot.readStructBegin()
8590 
    while True:
8591 
      (fname, ftype, fid) = iprot.readFieldBegin()
8592 
      if ftype == TType.STOP:
8593 
        break
8594 
      if fid == 1:
8595 
        if ftype == TType.I64:
8596 
          self.beginIndex = iprot.readI64();
8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      elif fid == 2:
8600 
        if ftype == TType.I64:
8601 
          self.totalItems = iprot.readI64();
8602 
        else:
8603 
          iprot.skip(ftype)
8604 
      elif fid == 3:
8605 
        if ftype == TType.STRING:
8606 
          self.brand = iprot.readString();
8607 
        else:
8608 
          iprot.skip(ftype)
8609 
      elif fid == 4:
8610 
        if ftype == TType.I64:
8611 
          self.category = iprot.readI64();
8612 
        else:
8613 
          iprot.skip(ftype)
8614 
      else:
8615 
        iprot.skip(ftype)
8616 
      iprot.readFieldEnd()
8617 
    iprot.readStructEnd()
8618 
 
8619 
  def write(self, oprot):
8620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8622 
      return
8623 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8624 
    if self.beginIndex is not None:
8625 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8626 
      oprot.writeI64(self.beginIndex)
8627 
      oprot.writeFieldEnd()
8628 
    if self.totalItems is not None:
8629 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8630 
      oprot.writeI64(self.totalItems)
8631 
      oprot.writeFieldEnd()
8632 
    if self.brand is not None:
8633 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8634 
      oprot.writeString(self.brand)
8635 
      oprot.writeFieldEnd()
8636 
    if self.category is not None:
8637 
      oprot.writeFieldBegin('category', TType.I64, 4)
8638 
      oprot.writeI64(self.category)
8639 
      oprot.writeFieldEnd()
8640 
    oprot.writeFieldStop()
8641 
    oprot.writeStructEnd()
8642 
 
8643 
  def validate(self):
8644 
    return
8645 
 
8646 
 
8647 
  def __repr__(self):
8648 
    L = ['%s=%r' % (key, value)
8649 
      for key, value in self.__dict__.iteritems()]
8650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8651 
 
8652 
  def __eq__(self, other):
8653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8654 
 
8655 
  def __ne__(self, other):
8656 
    return not (self == other)
8657 
 
8658 
class getBestSellersCatalogIds_result:
8659 
  """
8660 
  Attributes:
8661 
   - success
8662 
   - cex
8663 
  """
8664 
 
8665 
  thrift_spec = (
8666 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8667 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8668 
  )
8669 
 
8670 
  def __init__(self, success=None, cex=None,):
8671 
    self.success = success
8672 
    self.cex = cex
8673 
 
8674 
  def read(self, iprot):
8675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8677 
      return
8678 
    iprot.readStructBegin()
8679 
    while True:
8680 
      (fname, ftype, fid) = iprot.readFieldBegin()
8681 
      if ftype == TType.STOP:
8682 
        break
8683 
      if fid == 0:
8684 
        if ftype == TType.LIST:
8685 
          self.success = []
7438 amit.gupta 8686 
          (_etype84, _size81) = iprot.readListBegin()
8687 
          for _i85 in xrange(_size81):
8688 
            _elem86 = iprot.readI64();
8689 
            self.success.append(_elem86)
5944 mandeep.dh 8690 
          iprot.readListEnd()
8691 
        else:
8692 
          iprot.skip(ftype)
8693 
      elif fid == 1:
8694 
        if ftype == TType.STRUCT:
8695 
          self.cex = CatalogServiceException()
8696 
          self.cex.read(iprot)
8697 
        else:
8698 
          iprot.skip(ftype)
8699 
      else:
8700 
        iprot.skip(ftype)
8701 
      iprot.readFieldEnd()
8702 
    iprot.readStructEnd()
8703 
 
8704 
  def write(self, oprot):
8705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8707 
      return
8708 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8709 
    if self.success is not None:
8710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8711 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8712 
      for iter87 in self.success:
8713 
        oprot.writeI64(iter87)
5944 mandeep.dh 8714 
      oprot.writeListEnd()
8715 
      oprot.writeFieldEnd()
8716 
    if self.cex is not None:
8717 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8718 
      self.cex.write(oprot)
8719 
      oprot.writeFieldEnd()
8720 
    oprot.writeFieldStop()
8721 
    oprot.writeStructEnd()
8722 
 
8723 
  def validate(self):
8724 
    return
8725 
 
8726 
 
8727 
  def __repr__(self):
8728 
    L = ['%s=%r' % (key, value)
8729 
      for key, value in self.__dict__.iteritems()]
8730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8731 
 
8732 
  def __eq__(self, other):
8733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8734 
 
8735 
  def __ne__(self, other):
8736 
    return not (self == other)
8737 
 
8738 
class getBestSellersCount_args:
8739 
 
8740 
  thrift_spec = (
8741 
  )
8742 
 
8743 
  def read(self, iprot):
8744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8746 
      return
8747 
    iprot.readStructBegin()
8748 
    while True:
8749 
      (fname, ftype, fid) = iprot.readFieldBegin()
8750 
      if ftype == TType.STOP:
8751 
        break
8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
8761 
    oprot.writeStructBegin('getBestSellersCount_args')
8762 
    oprot.writeFieldStop()
8763 
    oprot.writeStructEnd()
8764 
 
8765 
  def validate(self):
8766 
    return
8767 
 
8768 
 
8769 
  def __repr__(self):
8770 
    L = ['%s=%r' % (key, value)
8771 
      for key, value in self.__dict__.iteritems()]
8772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8773 
 
8774 
  def __eq__(self, other):
8775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8776 
 
8777 
  def __ne__(self, other):
8778 
    return not (self == other)
8779 
 
8780 
class getBestSellersCount_result:
8781 
  """
8782 
  Attributes:
8783 
   - success
8784 
   - cex
8785 
  """
8786 
 
8787 
  thrift_spec = (
8788 
    (0, TType.I64, 'success', None, None, ), # 0
8789 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8790 
  )
8791 
 
8792 
  def __init__(self, success=None, cex=None,):
8793 
    self.success = success
8794 
    self.cex = cex
8795 
 
8796 
  def read(self, iprot):
8797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8799 
      return
8800 
    iprot.readStructBegin()
8801 
    while True:
8802 
      (fname, ftype, fid) = iprot.readFieldBegin()
8803 
      if ftype == TType.STOP:
8804 
        break
8805 
      if fid == 0:
8806 
        if ftype == TType.I64:
8807 
          self.success = iprot.readI64();
8808 
        else:
8809 
          iprot.skip(ftype)
8810 
      elif fid == 1:
8811 
        if ftype == TType.STRUCT:
8812 
          self.cex = CatalogServiceException()
8813 
          self.cex.read(iprot)
8814 
        else:
8815 
          iprot.skip(ftype)
8816 
      else:
8817 
        iprot.skip(ftype)
8818 
      iprot.readFieldEnd()
8819 
    iprot.readStructEnd()
8820 
 
8821 
  def write(self, oprot):
8822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8824 
      return
8825 
    oprot.writeStructBegin('getBestSellersCount_result')
8826 
    if self.success is not None:
8827 
      oprot.writeFieldBegin('success', TType.I64, 0)
8828 
      oprot.writeI64(self.success)
8829 
      oprot.writeFieldEnd()
8830 
    if self.cex is not None:
8831 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8832 
      self.cex.write(oprot)
8833 
      oprot.writeFieldEnd()
8834 
    oprot.writeFieldStop()
8835 
    oprot.writeStructEnd()
8836 
 
8837 
  def validate(self):
8838 
    return
8839 
 
8840 
 
8841 
  def __repr__(self):
8842 
    L = ['%s=%r' % (key, value)
8843 
      for key, value in self.__dict__.iteritems()]
8844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8845 
 
8846 
  def __eq__(self, other):
8847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8848 
 
8849 
  def __ne__(self, other):
8850 
    return not (self == other)
8851 
 
8852 
class getBestDeals_args:
8853 
 
8854 
  thrift_spec = (
8855 
  )
8856 
 
8857 
  def read(self, iprot):
8858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8860 
      return
8861 
    iprot.readStructBegin()
8862 
    while True:
8863 
      (fname, ftype, fid) = iprot.readFieldBegin()
8864 
      if ftype == TType.STOP:
8865 
        break
8866 
      else:
8867 
        iprot.skip(ftype)
8868 
      iprot.readFieldEnd()
8869 
    iprot.readStructEnd()
8870 
 
8871 
  def write(self, oprot):
8872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8874 
      return
8875 
    oprot.writeStructBegin('getBestDeals_args')
8876 
    oprot.writeFieldStop()
8877 
    oprot.writeStructEnd()
8878 
 
8879 
  def validate(self):
8880 
    return
8881 
 
8882 
 
8883 
  def __repr__(self):
8884 
    L = ['%s=%r' % (key, value)
8885 
      for key, value in self.__dict__.iteritems()]
8886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8887 
 
8888 
  def __eq__(self, other):
8889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8890 
 
8891 
  def __ne__(self, other):
8892 
    return not (self == other)
8893 
 
8894 
class getBestDeals_result:
8895 
  """
8896 
  Attributes:
8897 
   - success
8898 
   - isex
8899 
  """
8900 
 
8901 
  thrift_spec = (
8902 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8903 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8904 
  )
8905 
 
8906 
  def __init__(self, success=None, isex=None,):
8907 
    self.success = success
8908 
    self.isex = isex
8909 
 
8910 
  def read(self, iprot):
8911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8913 
      return
8914 
    iprot.readStructBegin()
8915 
    while True:
8916 
      (fname, ftype, fid) = iprot.readFieldBegin()
8917 
      if ftype == TType.STOP:
8918 
        break
8919 
      if fid == 0:
8920 
        if ftype == TType.LIST:
8921 
          self.success = []
7438 amit.gupta 8922 
          (_etype91, _size88) = iprot.readListBegin()
8923 
          for _i92 in xrange(_size88):
8924 
            _elem93 = Item()
8925 
            _elem93.read(iprot)
8926 
            self.success.append(_elem93)
5944 mandeep.dh 8927 
          iprot.readListEnd()
8928 
        else:
8929 
          iprot.skip(ftype)
8930 
      elif fid == 1:
8931 
        if ftype == TType.STRUCT:
8932 
          self.isex = CatalogServiceException()
8933 
          self.isex.read(iprot)
8934 
        else:
8935 
          iprot.skip(ftype)
8936 
      else:
8937 
        iprot.skip(ftype)
8938 
      iprot.readFieldEnd()
8939 
    iprot.readStructEnd()
8940 
 
8941 
  def write(self, oprot):
8942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8944 
      return
8945 
    oprot.writeStructBegin('getBestDeals_result')
8946 
    if self.success is not None:
8947 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8948 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8949 
      for iter94 in self.success:
8950 
        iter94.write(oprot)
5944 mandeep.dh 8951 
      oprot.writeListEnd()
8952 
      oprot.writeFieldEnd()
8953 
    if self.isex is not None:
8954 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8955 
      self.isex.write(oprot)
8956 
      oprot.writeFieldEnd()
8957 
    oprot.writeFieldStop()
8958 
    oprot.writeStructEnd()
8959 
 
8960 
  def validate(self):
8961 
    return
8962 
 
8963 
 
8964 
  def __repr__(self):
8965 
    L = ['%s=%r' % (key, value)
8966 
      for key, value in self.__dict__.iteritems()]
8967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8968 
 
8969 
  def __eq__(self, other):
8970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8971 
 
8972 
  def __ne__(self, other):
8973 
    return not (self == other)
8974 
 
8975 
class getBestDealsCatalogIds_args:
8976 
  """
8977 
  Attributes:
8978 
   - beginIndex
8979 
   - totalItems
8980 
   - brand
8981 
   - category
8982 
  """
8983 
 
8984 
  thrift_spec = (
8985 
    None, # 0
8986 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8987 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8988 
    (3, TType.STRING, 'brand', None, None, ), # 3
8989 
    (4, TType.I64, 'category', None, None, ), # 4
8990 
  )
8991 
 
8992 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8993 
    self.beginIndex = beginIndex
8994 
    self.totalItems = totalItems
8995 
    self.brand = brand
8996 
    self.category = category
8997 
 
8998 
  def read(self, iprot):
8999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9001 
      return
9002 
    iprot.readStructBegin()
9003 
    while True:
9004 
      (fname, ftype, fid) = iprot.readFieldBegin()
9005 
      if ftype == TType.STOP:
9006 
        break
9007 
      if fid == 1:
9008 
        if ftype == TType.I64:
9009 
          self.beginIndex = iprot.readI64();
9010 
        else:
9011 
          iprot.skip(ftype)
9012 
      elif fid == 2:
9013 
        if ftype == TType.I64:
9014 
          self.totalItems = iprot.readI64();
9015 
        else:
9016 
          iprot.skip(ftype)
9017 
      elif fid == 3:
9018 
        if ftype == TType.STRING:
9019 
          self.brand = iprot.readString();
9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      elif fid == 4:
9023 
        if ftype == TType.I64:
9024 
          self.category = iprot.readI64();
9025 
        else:
9026 
          iprot.skip(ftype)
9027 
      else:
9028 
        iprot.skip(ftype)
9029 
      iprot.readFieldEnd()
9030 
    iprot.readStructEnd()
9031 
 
9032 
  def write(self, oprot):
9033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9035 
      return
9036 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9037 
    if self.beginIndex is not None:
9038 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9039 
      oprot.writeI64(self.beginIndex)
9040 
      oprot.writeFieldEnd()
9041 
    if self.totalItems is not None:
9042 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9043 
      oprot.writeI64(self.totalItems)
9044 
      oprot.writeFieldEnd()
9045 
    if self.brand is not None:
9046 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9047 
      oprot.writeString(self.brand)
9048 
      oprot.writeFieldEnd()
9049 
    if self.category is not None:
9050 
      oprot.writeFieldBegin('category', TType.I64, 4)
9051 
      oprot.writeI64(self.category)
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 getBestDealsCatalogIds_result:
9072 
  """
9073 
  Attributes:
9074 
   - success
9075 
   - cex
9076 
  """
9077 
 
9078 
  thrift_spec = (
9079 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9080 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9081 
  )
9082 
 
9083 
  def __init__(self, success=None, cex=None,):
9084 
    self.success = success
9085 
    self.cex = cex
9086 
 
9087 
  def read(self, iprot):
9088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9090 
      return
9091 
    iprot.readStructBegin()
9092 
    while True:
9093 
      (fname, ftype, fid) = iprot.readFieldBegin()
9094 
      if ftype == TType.STOP:
9095 
        break
9096 
      if fid == 0:
9097 
        if ftype == TType.LIST:
9098 
          self.success = []
7438 amit.gupta 9099 
          (_etype98, _size95) = iprot.readListBegin()
9100 
          for _i99 in xrange(_size95):
9101 
            _elem100 = iprot.readI64();
9102 
            self.success.append(_elem100)
5944 mandeep.dh 9103 
          iprot.readListEnd()
9104 
        else:
9105 
          iprot.skip(ftype)
9106 
      elif fid == 1:
9107 
        if ftype == TType.STRUCT:
9108 
          self.cex = CatalogServiceException()
9109 
          self.cex.read(iprot)
9110 
        else:
9111 
          iprot.skip(ftype)
9112 
      else:
9113 
        iprot.skip(ftype)
9114 
      iprot.readFieldEnd()
9115 
    iprot.readStructEnd()
9116 
 
9117 
  def write(self, oprot):
9118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9120 
      return
9121 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9122 
    if self.success is not None:
9123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9124 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9125 
      for iter101 in self.success:
9126 
        oprot.writeI64(iter101)
5944 mandeep.dh 9127 
      oprot.writeListEnd()
9128 
      oprot.writeFieldEnd()
9129 
    if self.cex is not None:
9130 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9131 
      self.cex.write(oprot)
9132 
      oprot.writeFieldEnd()
9133 
    oprot.writeFieldStop()
9134 
    oprot.writeStructEnd()
9135 
 
9136 
  def validate(self):
9137 
    return
9138 
 
9139 
 
9140 
  def __repr__(self):
9141 
    L = ['%s=%r' % (key, value)
9142 
      for key, value in self.__dict__.iteritems()]
9143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9144 
 
9145 
  def __eq__(self, other):
9146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9147 
 
9148 
  def __ne__(self, other):
9149 
    return not (self == other)
9150 
 
9151 
class getBestDealsCount_args:
9152 
 
9153 
  thrift_spec = (
9154 
  )
9155 
 
9156 
  def read(self, iprot):
9157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9159 
      return
9160 
    iprot.readStructBegin()
9161 
    while True:
9162 
      (fname, ftype, fid) = iprot.readFieldBegin()
9163 
      if ftype == TType.STOP:
9164 
        break
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('getBestDealsCount_args')
9175 
    oprot.writeFieldStop()
9176 
    oprot.writeStructEnd()
9177 
 
9178 
  def validate(self):
9179 
    return
9180 
 
9181 
 
9182 
  def __repr__(self):
9183 
    L = ['%s=%r' % (key, value)
9184 
      for key, value in self.__dict__.iteritems()]
9185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9186 
 
9187 
  def __eq__(self, other):
9188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9189 
 
9190 
  def __ne__(self, other):
9191 
    return not (self == other)
9192 
 
9193 
class getBestDealsCount_result:
9194 
  """
9195 
  Attributes:
9196 
   - success
9197 
   - cex
9198 
  """
9199 
 
9200 
  thrift_spec = (
9201 
    (0, TType.I64, 'success', None, None, ), # 0
9202 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9203 
  )
9204 
 
9205 
  def __init__(self, success=None, cex=None,):
9206 
    self.success = success
9207 
    self.cex = cex
9208 
 
9209 
  def read(self, iprot):
9210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9212 
      return
9213 
    iprot.readStructBegin()
9214 
    while True:
9215 
      (fname, ftype, fid) = iprot.readFieldBegin()
9216 
      if ftype == TType.STOP:
9217 
        break
9218 
      if fid == 0:
9219 
        if ftype == TType.I64:
9220 
          self.success = iprot.readI64();
9221 
        else:
9222 
          iprot.skip(ftype)
9223 
      elif fid == 1:
9224 
        if ftype == TType.STRUCT:
9225 
          self.cex = CatalogServiceException()
9226 
          self.cex.read(iprot)
9227 
        else:
9228 
          iprot.skip(ftype)
9229 
      else:
9230 
        iprot.skip(ftype)
9231 
      iprot.readFieldEnd()
9232 
    iprot.readStructEnd()
9233 
 
9234 
  def write(self, oprot):
9235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9237 
      return
9238 
    oprot.writeStructBegin('getBestDealsCount_result')
9239 
    if self.success is not None:
9240 
      oprot.writeFieldBegin('success', TType.I64, 0)
9241 
      oprot.writeI64(self.success)
9242 
      oprot.writeFieldEnd()
9243 
    if self.cex is not None:
9244 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9245 
      self.cex.write(oprot)
9246 
      oprot.writeFieldEnd()
9247 
    oprot.writeFieldStop()
9248 
    oprot.writeStructEnd()
9249 
 
9250 
  def validate(self):
9251 
    return
9252 
 
9253 
 
9254 
  def __repr__(self):
9255 
    L = ['%s=%r' % (key, value)
9256 
      for key, value in self.__dict__.iteritems()]
9257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9258 
 
9259 
  def __eq__(self, other):
9260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9261 
 
9262 
  def __ne__(self, other):
9263 
    return not (self == other)
9264 
 
9265 
class getComingSoon_args:
9266 
 
9267 
  thrift_spec = (
9268 
  )
9269 
 
9270 
  def read(self, iprot):
9271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9273 
      return
9274 
    iprot.readStructBegin()
9275 
    while True:
9276 
      (fname, ftype, fid) = iprot.readFieldBegin()
9277 
      if ftype == TType.STOP:
9278 
        break
9279 
      else:
9280 
        iprot.skip(ftype)
9281 
      iprot.readFieldEnd()
9282 
    iprot.readStructEnd()
9283 
 
9284 
  def write(self, oprot):
9285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9287 
      return
9288 
    oprot.writeStructBegin('getComingSoon_args')
9289 
    oprot.writeFieldStop()
9290 
    oprot.writeStructEnd()
9291 
 
9292 
  def validate(self):
9293 
    return
9294 
 
9295 
 
9296 
  def __repr__(self):
9297 
    L = ['%s=%r' % (key, value)
9298 
      for key, value in self.__dict__.iteritems()]
9299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9300 
 
9301 
  def __eq__(self, other):
9302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9303 
 
9304 
  def __ne__(self, other):
9305 
    return not (self == other)
9306 
 
9307 
class getComingSoon_result:
9308 
  """
9309 
  Attributes:
9310 
   - success
9311 
   - isex
9312 
  """
9313 
 
9314 
  thrift_spec = (
9315 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9316 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9317 
  )
9318 
 
9319 
  def __init__(self, success=None, isex=None,):
9320 
    self.success = success
9321 
    self.isex = isex
9322 
 
9323 
  def read(self, iprot):
9324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9326 
      return
9327 
    iprot.readStructBegin()
9328 
    while True:
9329 
      (fname, ftype, fid) = iprot.readFieldBegin()
9330 
      if ftype == TType.STOP:
9331 
        break
9332 
      if fid == 0:
9333 
        if ftype == TType.LIST:
9334 
          self.success = []
7438 amit.gupta 9335 
          (_etype105, _size102) = iprot.readListBegin()
9336 
          for _i106 in xrange(_size102):
9337 
            _elem107 = Item()
9338 
            _elem107.read(iprot)
9339 
            self.success.append(_elem107)
5944 mandeep.dh 9340 
          iprot.readListEnd()
9341 
        else:
9342 
          iprot.skip(ftype)
9343 
      elif fid == 1:
9344 
        if ftype == TType.STRUCT:
9345 
          self.isex = CatalogServiceException()
9346 
          self.isex.read(iprot)
9347 
        else:
9348 
          iprot.skip(ftype)
9349 
      else:
9350 
        iprot.skip(ftype)
9351 
      iprot.readFieldEnd()
9352 
    iprot.readStructEnd()
9353 
 
9354 
  def write(self, oprot):
9355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9357 
      return
9358 
    oprot.writeStructBegin('getComingSoon_result')
9359 
    if self.success is not None:
9360 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9361 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9362 
      for iter108 in self.success:
9363 
        iter108.write(oprot)
5944 mandeep.dh 9364 
      oprot.writeListEnd()
9365 
      oprot.writeFieldEnd()
9366 
    if self.isex is not None:
9367 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9368 
      self.isex.write(oprot)
9369 
      oprot.writeFieldEnd()
9370 
    oprot.writeFieldStop()
9371 
    oprot.writeStructEnd()
9372 
 
9373 
  def validate(self):
9374 
    return
9375 
 
9376 
 
9377 
  def __repr__(self):
9378 
    L = ['%s=%r' % (key, value)
9379 
      for key, value in self.__dict__.iteritems()]
9380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9381 
 
9382 
  def __eq__(self, other):
9383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9384 
 
9385 
  def __ne__(self, other):
9386 
    return not (self == other)
9387 
 
9388 
class getComingSoonCatalogIds_args:
9389 
  """
9390 
  Attributes:
9391 
   - beginIndex
9392 
   - totalItems
9393 
   - brand
9394 
   - category
9395 
  """
9396 
 
9397 
  thrift_spec = (
9398 
    None, # 0
9399 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9400 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9401 
    (3, TType.STRING, 'brand', None, None, ), # 3
9402 
    (4, TType.I64, 'category', None, None, ), # 4
9403 
  )
9404 
 
9405 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9406 
    self.beginIndex = beginIndex
9407 
    self.totalItems = totalItems
9408 
    self.brand = brand
9409 
    self.category = category
9410 
 
9411 
  def read(self, iprot):
9412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9414 
      return
9415 
    iprot.readStructBegin()
9416 
    while True:
9417 
      (fname, ftype, fid) = iprot.readFieldBegin()
9418 
      if ftype == TType.STOP:
9419 
        break
9420 
      if fid == 1:
9421 
        if ftype == TType.I64:
9422 
          self.beginIndex = iprot.readI64();
9423 
        else:
9424 
          iprot.skip(ftype)
9425 
      elif fid == 2:
9426 
        if ftype == TType.I64:
9427 
          self.totalItems = iprot.readI64();
9428 
        else:
9429 
          iprot.skip(ftype)
9430 
      elif fid == 3:
9431 
        if ftype == TType.STRING:
9432 
          self.brand = iprot.readString();
9433 
        else:
9434 
          iprot.skip(ftype)
9435 
      elif fid == 4:
9436 
        if ftype == TType.I64:
9437 
          self.category = iprot.readI64();
9438 
        else:
9439 
          iprot.skip(ftype)
9440 
      else:
9441 
        iprot.skip(ftype)
9442 
      iprot.readFieldEnd()
9443 
    iprot.readStructEnd()
9444 
 
9445 
  def write(self, oprot):
9446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9448 
      return
9449 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9450 
    if self.beginIndex is not None:
9451 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9452 
      oprot.writeI64(self.beginIndex)
9453 
      oprot.writeFieldEnd()
9454 
    if self.totalItems is not None:
9455 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9456 
      oprot.writeI64(self.totalItems)
9457 
      oprot.writeFieldEnd()
9458 
    if self.brand is not None:
9459 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9460 
      oprot.writeString(self.brand)
9461 
      oprot.writeFieldEnd()
9462 
    if self.category is not None:
9463 
      oprot.writeFieldBegin('category', TType.I64, 4)
9464 
      oprot.writeI64(self.category)
9465 
      oprot.writeFieldEnd()
9466 
    oprot.writeFieldStop()
9467 
    oprot.writeStructEnd()
9468 
 
9469 
  def validate(self):
9470 
    return
9471 
 
9472 
 
9473 
  def __repr__(self):
9474 
    L = ['%s=%r' % (key, value)
9475 
      for key, value in self.__dict__.iteritems()]
9476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9477 
 
9478 
  def __eq__(self, other):
9479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9480 
 
9481 
  def __ne__(self, other):
9482 
    return not (self == other)
9483 
 
9484 
class getComingSoonCatalogIds_result:
9485 
  """
9486 
  Attributes:
9487 
   - success
9488 
   - cex
9489 
  """
9490 
 
9491 
  thrift_spec = (
9492 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9493 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9494 
  )
9495 
 
9496 
  def __init__(self, success=None, cex=None,):
9497 
    self.success = success
9498 
    self.cex = cex
9499 
 
9500 
  def read(self, iprot):
9501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9503 
      return
9504 
    iprot.readStructBegin()
9505 
    while True:
9506 
      (fname, ftype, fid) = iprot.readFieldBegin()
9507 
      if ftype == TType.STOP:
9508 
        break
9509 
      if fid == 0:
9510 
        if ftype == TType.LIST:
9511 
          self.success = []
7438 amit.gupta 9512 
          (_etype112, _size109) = iprot.readListBegin()
9513 
          for _i113 in xrange(_size109):
9514 
            _elem114 = iprot.readI64();
9515 
            self.success.append(_elem114)
5944 mandeep.dh 9516 
          iprot.readListEnd()
9517 
        else:
9518 
          iprot.skip(ftype)
9519 
      elif fid == 1:
9520 
        if ftype == TType.STRUCT:
9521 
          self.cex = CatalogServiceException()
9522 
          self.cex.read(iprot)
9523 
        else:
9524 
          iprot.skip(ftype)
9525 
      else:
9526 
        iprot.skip(ftype)
9527 
      iprot.readFieldEnd()
9528 
    iprot.readStructEnd()
9529 
 
9530 
  def write(self, oprot):
9531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9533 
      return
9534 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9535 
    if self.success is not None:
9536 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9537 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9538 
      for iter115 in self.success:
9539 
        oprot.writeI64(iter115)
5944 mandeep.dh 9540 
      oprot.writeListEnd()
9541 
      oprot.writeFieldEnd()
9542 
    if self.cex is not None:
9543 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9544 
      self.cex.write(oprot)
9545 
      oprot.writeFieldEnd()
9546 
    oprot.writeFieldStop()
9547 
    oprot.writeStructEnd()
9548 
 
9549 
  def validate(self):
9550 
    return
9551 
 
9552 
 
9553 
  def __repr__(self):
9554 
    L = ['%s=%r' % (key, value)
9555 
      for key, value in self.__dict__.iteritems()]
9556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9557 
 
9558 
  def __eq__(self, other):
9559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9560 
 
9561 
  def __ne__(self, other):
9562 
    return not (self == other)
9563 
 
9564 
class getComingSoonCount_args:
9565 
 
9566 
  thrift_spec = (
9567 
  )
9568 
 
9569 
  def read(self, iprot):
9570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9572 
      return
9573 
    iprot.readStructBegin()
9574 
    while True:
9575 
      (fname, ftype, fid) = iprot.readFieldBegin()
9576 
      if ftype == TType.STOP:
9577 
        break
9578 
      else:
9579 
        iprot.skip(ftype)
9580 
      iprot.readFieldEnd()
9581 
    iprot.readStructEnd()
9582 
 
9583 
  def write(self, oprot):
9584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9586 
      return
9587 
    oprot.writeStructBegin('getComingSoonCount_args')
9588 
    oprot.writeFieldStop()
9589 
    oprot.writeStructEnd()
9590 
 
9591 
  def validate(self):
9592 
    return
9593 
 
9594 
 
9595 
  def __repr__(self):
9596 
    L = ['%s=%r' % (key, value)
9597 
      for key, value in self.__dict__.iteritems()]
9598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9599 
 
9600 
  def __eq__(self, other):
9601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9602 
 
9603 
  def __ne__(self, other):
9604 
    return not (self == other)
9605 
 
9606 
class getComingSoonCount_result:
9607 
  """
9608 
  Attributes:
9609 
   - success
9610 
   - cex
9611 
  """
9612 
 
9613 
  thrift_spec = (
9614 
    (0, TType.I64, 'success', None, None, ), # 0
9615 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9616 
  )
9617 
 
9618 
  def __init__(self, success=None, cex=None,):
9619 
    self.success = success
9620 
    self.cex = cex
9621 
 
9622 
  def read(self, iprot):
9623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9625 
      return
9626 
    iprot.readStructBegin()
9627 
    while True:
9628 
      (fname, ftype, fid) = iprot.readFieldBegin()
9629 
      if ftype == TType.STOP:
9630 
        break
9631 
      if fid == 0:
9632 
        if ftype == TType.I64:
9633 
          self.success = iprot.readI64();
9634 
        else:
9635 
          iprot.skip(ftype)
9636 
      elif fid == 1:
9637 
        if ftype == TType.STRUCT:
9638 
          self.cex = CatalogServiceException()
9639 
          self.cex.read(iprot)
9640 
        else:
9641 
          iprot.skip(ftype)
9642 
      else:
9643 
        iprot.skip(ftype)
9644 
      iprot.readFieldEnd()
9645 
    iprot.readStructEnd()
9646 
 
9647 
  def write(self, oprot):
9648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9650 
      return
9651 
    oprot.writeStructBegin('getComingSoonCount_result')
9652 
    if self.success is not None:
9653 
      oprot.writeFieldBegin('success', TType.I64, 0)
9654 
      oprot.writeI64(self.success)
9655 
      oprot.writeFieldEnd()
9656 
    if self.cex is not None:
9657 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9658 
      self.cex.write(oprot)
9659 
      oprot.writeFieldEnd()
9660 
    oprot.writeFieldStop()
9661 
    oprot.writeStructEnd()
9662 
 
9663 
  def validate(self):
9664 
    return
9665 
 
9666 
 
9667 
  def __repr__(self):
9668 
    L = ['%s=%r' % (key, value)
9669 
      for key, value in self.__dict__.iteritems()]
9670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9671 
 
9672 
  def __eq__(self, other):
9673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9674 
 
9675 
  def __ne__(self, other):
9676 
    return not (self == other)
9677 
 
9678 
class getLatestArrivals_args:
9679 
 
9680 
  thrift_spec = (
9681 
  )
9682 
 
9683 
  def read(self, iprot):
9684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9686 
      return
9687 
    iprot.readStructBegin()
9688 
    while True:
9689 
      (fname, ftype, fid) = iprot.readFieldBegin()
9690 
      if ftype == TType.STOP:
9691 
        break
9692 
      else:
9693 
        iprot.skip(ftype)
9694 
      iprot.readFieldEnd()
9695 
    iprot.readStructEnd()
9696 
 
9697 
  def write(self, oprot):
9698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9700 
      return
9701 
    oprot.writeStructBegin('getLatestArrivals_args')
9702 
    oprot.writeFieldStop()
9703 
    oprot.writeStructEnd()
9704 
 
9705 
  def validate(self):
9706 
    return
9707 
 
9708 
 
9709 
  def __repr__(self):
9710 
    L = ['%s=%r' % (key, value)
9711 
      for key, value in self.__dict__.iteritems()]
9712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9713 
 
9714 
  def __eq__(self, other):
9715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9716 
 
9717 
  def __ne__(self, other):
9718 
    return not (self == other)
9719 
 
9720 
class getLatestArrivals_result:
9721 
  """
9722 
  Attributes:
9723 
   - success
9724 
   - isex
9725 
  """
9726 
 
9727 
  thrift_spec = (
9728 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9729 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9730 
  )
9731 
 
9732 
  def __init__(self, success=None, isex=None,):
9733 
    self.success = success
9734 
    self.isex = isex
9735 
 
9736 
  def read(self, iprot):
9737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9739 
      return
9740 
    iprot.readStructBegin()
9741 
    while True:
9742 
      (fname, ftype, fid) = iprot.readFieldBegin()
9743 
      if ftype == TType.STOP:
9744 
        break
9745 
      if fid == 0:
9746 
        if ftype == TType.LIST:
9747 
          self.success = []
7438 amit.gupta 9748 
          (_etype119, _size116) = iprot.readListBegin()
9749 
          for _i120 in xrange(_size116):
9750 
            _elem121 = Item()
9751 
            _elem121.read(iprot)
9752 
            self.success.append(_elem121)
5944 mandeep.dh 9753 
          iprot.readListEnd()
9754 
        else:
9755 
          iprot.skip(ftype)
9756 
      elif fid == 1:
9757 
        if ftype == TType.STRUCT:
9758 
          self.isex = CatalogServiceException()
9759 
          self.isex.read(iprot)
9760 
        else:
9761 
          iprot.skip(ftype)
9762 
      else:
9763 
        iprot.skip(ftype)
9764 
      iprot.readFieldEnd()
9765 
    iprot.readStructEnd()
9766 
 
9767 
  def write(self, oprot):
9768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9770 
      return
9771 
    oprot.writeStructBegin('getLatestArrivals_result')
9772 
    if self.success is not None:
9773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9775 
      for iter122 in self.success:
9776 
        iter122.write(oprot)
5944 mandeep.dh 9777 
      oprot.writeListEnd()
9778 
      oprot.writeFieldEnd()
9779 
    if self.isex is not None:
9780 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9781 
      self.isex.write(oprot)
9782 
      oprot.writeFieldEnd()
9783 
    oprot.writeFieldStop()
9784 
    oprot.writeStructEnd()
9785 
 
9786 
  def validate(self):
9787 
    return
9788 
 
9789 
 
9790 
  def __repr__(self):
9791 
    L = ['%s=%r' % (key, value)
9792 
      for key, value in self.__dict__.iteritems()]
9793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9794 
 
9795 
  def __eq__(self, other):
9796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9797 
 
9798 
  def __ne__(self, other):
9799 
    return not (self == other)
9800 
 
9801 
class getLatestArrivalsCatalogIds_args:
9802 
  """
9803 
  Attributes:
9804 
   - beginIndex
9805 
   - totalItems
9806 
   - brand
9807 
   - categories
9808 
  """
9809 
 
9810 
  thrift_spec = (
9811 
    None, # 0
9812 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9813 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9814 
    (3, TType.STRING, 'brand', None, None, ), # 3
9815 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9816 
  )
9817 
 
9818 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9819 
    self.beginIndex = beginIndex
9820 
    self.totalItems = totalItems
9821 
    self.brand = brand
9822 
    self.categories = categories
9823 
 
9824 
  def read(self, iprot):
9825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9827 
      return
9828 
    iprot.readStructBegin()
9829 
    while True:
9830 
      (fname, ftype, fid) = iprot.readFieldBegin()
9831 
      if ftype == TType.STOP:
9832 
        break
9833 
      if fid == 1:
9834 
        if ftype == TType.I64:
9835 
          self.beginIndex = iprot.readI64();
9836 
        else:
9837 
          iprot.skip(ftype)
9838 
      elif fid == 2:
9839 
        if ftype == TType.I64:
9840 
          self.totalItems = iprot.readI64();
9841 
        else:
9842 
          iprot.skip(ftype)
9843 
      elif fid == 3:
9844 
        if ftype == TType.STRING:
9845 
          self.brand = iprot.readString();
9846 
        else:
9847 
          iprot.skip(ftype)
9848 
      elif fid == 4:
9849 
        if ftype == TType.LIST:
9850 
          self.categories = []
7438 amit.gupta 9851 
          (_etype126, _size123) = iprot.readListBegin()
9852 
          for _i127 in xrange(_size123):
9853 
            _elem128 = iprot.readI64();
9854 
            self.categories.append(_elem128)
5944 mandeep.dh 9855 
          iprot.readListEnd()
9856 
        else:
9857 
          iprot.skip(ftype)
9858 
      else:
9859 
        iprot.skip(ftype)
9860 
      iprot.readFieldEnd()
9861 
    iprot.readStructEnd()
9862 
 
9863 
  def write(self, oprot):
9864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9866 
      return
9867 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9868 
    if self.beginIndex is not None:
9869 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9870 
      oprot.writeI64(self.beginIndex)
9871 
      oprot.writeFieldEnd()
9872 
    if self.totalItems is not None:
9873 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9874 
      oprot.writeI64(self.totalItems)
9875 
      oprot.writeFieldEnd()
9876 
    if self.brand is not None:
9877 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9878 
      oprot.writeString(self.brand)
9879 
      oprot.writeFieldEnd()
9880 
    if self.categories is not None:
9881 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9882 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9883 
      for iter129 in self.categories:
9884 
        oprot.writeI64(iter129)
5944 mandeep.dh 9885 
      oprot.writeListEnd()
9886 
      oprot.writeFieldEnd()
9887 
    oprot.writeFieldStop()
9888 
    oprot.writeStructEnd()
9889 
 
9890 
  def validate(self):
9891 
    return
9892 
 
9893 
 
9894 
  def __repr__(self):
9895 
    L = ['%s=%r' % (key, value)
9896 
      for key, value in self.__dict__.iteritems()]
9897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9898 
 
9899 
  def __eq__(self, other):
9900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9901 
 
9902 
  def __ne__(self, other):
9903 
    return not (self == other)
9904 
 
9905 
class getLatestArrivalsCatalogIds_result:
9906 
  """
9907 
  Attributes:
9908 
   - success
9909 
   - cex
9910 
  """
9911 
 
9912 
  thrift_spec = (
9913 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9914 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9915 
  )
9916 
 
9917 
  def __init__(self, success=None, cex=None,):
9918 
    self.success = success
9919 
    self.cex = cex
9920 
 
9921 
  def read(self, iprot):
9922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9924 
      return
9925 
    iprot.readStructBegin()
9926 
    while True:
9927 
      (fname, ftype, fid) = iprot.readFieldBegin()
9928 
      if ftype == TType.STOP:
9929 
        break
9930 
      if fid == 0:
9931 
        if ftype == TType.LIST:
9932 
          self.success = []
7438 amit.gupta 9933 
          (_etype133, _size130) = iprot.readListBegin()
9934 
          for _i134 in xrange(_size130):
9935 
            _elem135 = iprot.readI64();
9936 
            self.success.append(_elem135)
5944 mandeep.dh 9937 
          iprot.readListEnd()
9938 
        else:
9939 
          iprot.skip(ftype)
9940 
      elif fid == 1:
9941 
        if ftype == TType.STRUCT:
9942 
          self.cex = CatalogServiceException()
9943 
          self.cex.read(iprot)
9944 
        else:
9945 
          iprot.skip(ftype)
9946 
      else:
9947 
        iprot.skip(ftype)
9948 
      iprot.readFieldEnd()
9949 
    iprot.readStructEnd()
9950 
 
9951 
  def write(self, oprot):
9952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9954 
      return
9955 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9956 
    if self.success is not None:
9957 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9958 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9959 
      for iter136 in self.success:
9960 
        oprot.writeI64(iter136)
5944 mandeep.dh 9961 
      oprot.writeListEnd()
9962 
      oprot.writeFieldEnd()
9963 
    if self.cex is not None:
9964 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9965 
      self.cex.write(oprot)
9966 
      oprot.writeFieldEnd()
9967 
    oprot.writeFieldStop()
9968 
    oprot.writeStructEnd()
9969 
 
9970 
  def validate(self):
9971 
    return
9972 
 
9973 
 
9974 
  def __repr__(self):
9975 
    L = ['%s=%r' % (key, value)
9976 
      for key, value in self.__dict__.iteritems()]
9977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9978 
 
9979 
  def __eq__(self, other):
9980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9981 
 
9982 
  def __ne__(self, other):
9983 
    return not (self == other)
9984 
 
9985 
class getLatestArrivalsCount_args:
9986 
 
9987 
  thrift_spec = (
9988 
  )
9989 
 
9990 
  def read(self, iprot):
9991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9993 
      return
9994 
    iprot.readStructBegin()
9995 
    while True:
9996 
      (fname, ftype, fid) = iprot.readFieldBegin()
9997 
      if ftype == TType.STOP:
9998 
        break
9999 
      else:
10000 
        iprot.skip(ftype)
10001 
      iprot.readFieldEnd()
10002 
    iprot.readStructEnd()
10003 
 
10004 
  def write(self, oprot):
10005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10007 
      return
10008 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10009 
    oprot.writeFieldStop()
10010 
    oprot.writeStructEnd()
10011 
 
10012 
  def validate(self):
10013 
    return
10014 
 
10015 
 
10016 
  def __repr__(self):
10017 
    L = ['%s=%r' % (key, value)
10018 
      for key, value in self.__dict__.iteritems()]
10019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10020 
 
10021 
  def __eq__(self, other):
10022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10023 
 
10024 
  def __ne__(self, other):
10025 
    return not (self == other)
10026 
 
10027 
class getLatestArrivalsCount_result:
10028 
  """
10029 
  Attributes:
10030 
   - success
10031 
   - cex
10032 
  """
10033 
 
10034 
  thrift_spec = (
10035 
    (0, TType.I64, 'success', None, None, ), # 0
10036 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10037 
  )
10038 
 
10039 
  def __init__(self, success=None, cex=None,):
10040 
    self.success = success
10041 
    self.cex = cex
10042 
 
10043 
  def read(self, iprot):
10044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10046 
      return
10047 
    iprot.readStructBegin()
10048 
    while True:
10049 
      (fname, ftype, fid) = iprot.readFieldBegin()
10050 
      if ftype == TType.STOP:
10051 
        break
10052 
      if fid == 0:
10053 
        if ftype == TType.I64:
10054 
          self.success = iprot.readI64();
10055 
        else:
10056 
          iprot.skip(ftype)
10057 
      elif fid == 1:
10058 
        if ftype == TType.STRUCT:
10059 
          self.cex = CatalogServiceException()
10060 
          self.cex.read(iprot)
10061 
        else:
10062 
          iprot.skip(ftype)
10063 
      else:
10064 
        iprot.skip(ftype)
10065 
      iprot.readFieldEnd()
10066 
    iprot.readStructEnd()
10067 
 
10068 
  def write(self, oprot):
10069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10071 
      return
10072 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10073 
    if self.success is not None:
10074 
      oprot.writeFieldBegin('success', TType.I64, 0)
10075 
      oprot.writeI64(self.success)
10076 
      oprot.writeFieldEnd()
10077 
    if self.cex is not None:
10078 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10079 
      self.cex.write(oprot)
10080 
      oprot.writeFieldEnd()
10081 
    oprot.writeFieldStop()
10082 
    oprot.writeStructEnd()
10083 
 
10084 
  def validate(self):
10085 
    return
10086 
 
10087 
 
10088 
  def __repr__(self):
10089 
    L = ['%s=%r' % (key, value)
10090 
      for key, value in self.__dict__.iteritems()]
10091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10092 
 
10093 
  def __eq__(self, other):
10094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10095 
 
10096 
  def __ne__(self, other):
10097 
    return not (self == other)
10098 
 
10099 
class generateNewEntityID_args:
10100 
 
10101 
  thrift_spec = (
10102 
  )
10103 
 
10104 
  def read(self, iprot):
10105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10107 
      return
10108 
    iprot.readStructBegin()
10109 
    while True:
10110 
      (fname, ftype, fid) = iprot.readFieldBegin()
10111 
      if ftype == TType.STOP:
10112 
        break
10113 
      else:
10114 
        iprot.skip(ftype)
10115 
      iprot.readFieldEnd()
10116 
    iprot.readStructEnd()
10117 
 
10118 
  def write(self, oprot):
10119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10121 
      return
10122 
    oprot.writeStructBegin('generateNewEntityID_args')
10123 
    oprot.writeFieldStop()
10124 
    oprot.writeStructEnd()
10125 
 
10126 
  def validate(self):
10127 
    return
10128 
 
10129 
 
10130 
  def __repr__(self):
10131 
    L = ['%s=%r' % (key, value)
10132 
      for key, value in self.__dict__.iteritems()]
10133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10134 
 
10135 
  def __eq__(self, other):
10136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10137 
 
10138 
  def __ne__(self, other):
10139 
    return not (self == other)
10140 
 
10141 
class generateNewEntityID_result:
10142 
  """
10143 
  Attributes:
10144 
   - success
10145 
  """
10146 
 
10147 
  thrift_spec = (
10148 
    (0, TType.I64, 'success', None, None, ), # 0
10149 
  )
10150 
 
10151 
  def __init__(self, success=None,):
10152 
    self.success = success
10153 
 
10154 
  def read(self, iprot):
10155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10157 
      return
10158 
    iprot.readStructBegin()
10159 
    while True:
10160 
      (fname, ftype, fid) = iprot.readFieldBegin()
10161 
      if ftype == TType.STOP:
10162 
        break
10163 
      if fid == 0:
10164 
        if ftype == TType.I64:
10165 
          self.success = iprot.readI64();
10166 
        else:
10167 
          iprot.skip(ftype)
10168 
      else:
10169 
        iprot.skip(ftype)
10170 
      iprot.readFieldEnd()
10171 
    iprot.readStructEnd()
10172 
 
10173 
  def write(self, oprot):
10174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10176 
      return
10177 
    oprot.writeStructBegin('generateNewEntityID_result')
10178 
    if self.success is not None:
10179 
      oprot.writeFieldBegin('success', TType.I64, 0)
10180 
      oprot.writeI64(self.success)
10181 
      oprot.writeFieldEnd()
10182 
    oprot.writeFieldStop()
10183 
    oprot.writeStructEnd()
10184 
 
10185 
  def validate(self):
10186 
    return
10187 
 
10188 
 
10189 
  def __repr__(self):
10190 
    L = ['%s=%r' % (key, value)
10191 
      for key, value in self.__dict__.iteritems()]
10192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10193 
 
10194 
  def __eq__(self, other):
10195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10196 
 
10197 
  def __ne__(self, other):
10198 
    return not (self == other)
10199 
 
10200 
class addCategory_args:
10201 
  """
10202 
  Attributes:
10203 
   - category
10204 
  """
10205 
 
10206 
  thrift_spec = (
10207 
    None, # 0
10208 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10209 
  )
10210 
 
10211 
  def __init__(self, category=None,):
10212 
    self.category = category
10213 
 
10214 
  def read(self, iprot):
10215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10217 
      return
10218 
    iprot.readStructBegin()
10219 
    while True:
10220 
      (fname, ftype, fid) = iprot.readFieldBegin()
10221 
      if ftype == TType.STOP:
10222 
        break
10223 
      if fid == 1:
10224 
        if ftype == TType.STRUCT:
10225 
          self.category = Category()
10226 
          self.category.read(iprot)
10227 
        else:
10228 
          iprot.skip(ftype)
10229 
      else:
10230 
        iprot.skip(ftype)
10231 
      iprot.readFieldEnd()
10232 
    iprot.readStructEnd()
10233 
 
10234 
  def write(self, oprot):
10235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10237 
      return
10238 
    oprot.writeStructBegin('addCategory_args')
10239 
    if self.category is not None:
10240 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10241 
      self.category.write(oprot)
10242 
      oprot.writeFieldEnd()
10243 
    oprot.writeFieldStop()
10244 
    oprot.writeStructEnd()
10245 
 
10246 
  def validate(self):
10247 
    return
10248 
 
10249 
 
10250 
  def __repr__(self):
10251 
    L = ['%s=%r' % (key, value)
10252 
      for key, value in self.__dict__.iteritems()]
10253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10254 
 
10255 
  def __eq__(self, other):
10256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10257 
 
10258 
  def __ne__(self, other):
10259 
    return not (self == other)
10260 
 
10261 
class addCategory_result:
10262 
  """
10263 
  Attributes:
10264 
   - success
10265 
  """
10266 
 
10267 
  thrift_spec = (
10268 
    (0, TType.BOOL, 'success', None, None, ), # 0
10269 
  )
10270 
 
10271 
  def __init__(self, success=None,):
10272 
    self.success = success
10273 
 
10274 
  def read(self, iprot):
10275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10277 
      return
10278 
    iprot.readStructBegin()
10279 
    while True:
10280 
      (fname, ftype, fid) = iprot.readFieldBegin()
10281 
      if ftype == TType.STOP:
10282 
        break
10283 
      if fid == 0:
10284 
        if ftype == TType.BOOL:
10285 
          self.success = iprot.readBool();
10286 
        else:
10287 
          iprot.skip(ftype)
10288 
      else:
10289 
        iprot.skip(ftype)
10290 
      iprot.readFieldEnd()
10291 
    iprot.readStructEnd()
10292 
 
10293 
  def write(self, oprot):
10294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10296 
      return
10297 
    oprot.writeStructBegin('addCategory_result')
10298 
    if self.success is not None:
10299 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10300 
      oprot.writeBool(self.success)
10301 
      oprot.writeFieldEnd()
10302 
    oprot.writeFieldStop()
10303 
    oprot.writeStructEnd()
10304 
 
10305 
  def validate(self):
10306 
    return
10307 
 
10308 
 
10309 
  def __repr__(self):
10310 
    L = ['%s=%r' % (key, value)
10311 
      for key, value in self.__dict__.iteritems()]
10312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10313 
 
10314 
  def __eq__(self, other):
10315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10316 
 
10317 
  def __ne__(self, other):
10318 
    return not (self == other)
10319 
 
10320 
class getCategory_args:
10321 
  """
10322 
  Attributes:
10323 
   - id
10324 
  """
10325 
 
10326 
  thrift_spec = (
10327 
    None, # 0
10328 
    (1, TType.I64, 'id', None, None, ), # 1
10329 
  )
10330 
 
10331 
  def __init__(self, id=None,):
10332 
    self.id = id
10333 
 
10334 
  def read(self, iprot):
10335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10337 
      return
10338 
    iprot.readStructBegin()
10339 
    while True:
10340 
      (fname, ftype, fid) = iprot.readFieldBegin()
10341 
      if ftype == TType.STOP:
10342 
        break
10343 
      if fid == 1:
10344 
        if ftype == TType.I64:
10345 
          self.id = iprot.readI64();
10346 
        else:
10347 
          iprot.skip(ftype)
10348 
      else:
10349 
        iprot.skip(ftype)
10350 
      iprot.readFieldEnd()
10351 
    iprot.readStructEnd()
10352 
 
10353 
  def write(self, oprot):
10354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10356 
      return
10357 
    oprot.writeStructBegin('getCategory_args')
10358 
    if self.id is not None:
10359 
      oprot.writeFieldBegin('id', TType.I64, 1)
10360 
      oprot.writeI64(self.id)
10361 
      oprot.writeFieldEnd()
10362 
    oprot.writeFieldStop()
10363 
    oprot.writeStructEnd()
10364 
 
10365 
  def validate(self):
10366 
    return
10367 
 
10368 
 
10369 
  def __repr__(self):
10370 
    L = ['%s=%r' % (key, value)
10371 
      for key, value in self.__dict__.iteritems()]
10372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10373 
 
10374 
  def __eq__(self, other):
10375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10376 
 
10377 
  def __ne__(self, other):
10378 
    return not (self == other)
10379 
 
10380 
class getCategory_result:
10381 
  """
10382 
  Attributes:
10383 
   - success
10384 
  """
10385 
 
10386 
  thrift_spec = (
10387 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
10388 
  )
10389 
 
10390 
  def __init__(self, success=None,):
10391 
    self.success = success
10392 
 
10393 
  def read(self, iprot):
10394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10396 
      return
10397 
    iprot.readStructBegin()
10398 
    while True:
10399 
      (fname, ftype, fid) = iprot.readFieldBegin()
10400 
      if ftype == TType.STOP:
10401 
        break
10402 
      if fid == 0:
10403 
        if ftype == TType.STRUCT:
10404 
          self.success = Category()
10405 
          self.success.read(iprot)
10406 
        else:
10407 
          iprot.skip(ftype)
10408 
      else:
10409 
        iprot.skip(ftype)
10410 
      iprot.readFieldEnd()
10411 
    iprot.readStructEnd()
10412 
 
10413 
  def write(self, oprot):
10414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10416 
      return
10417 
    oprot.writeStructBegin('getCategory_result')
10418 
    if self.success is not None:
10419 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10420 
      self.success.write(oprot)
10421 
      oprot.writeFieldEnd()
10422 
    oprot.writeFieldStop()
10423 
    oprot.writeStructEnd()
10424 
 
10425 
  def validate(self):
10426 
    return
10427 
 
10428 
 
10429 
  def __repr__(self):
10430 
    L = ['%s=%r' % (key, value)
10431 
      for key, value in self.__dict__.iteritems()]
10432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10433 
 
10434 
  def __eq__(self, other):
10435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10436 
 
10437 
  def __ne__(self, other):
10438 
    return not (self == other)
10439 
 
10440 
class getAllCategories_args:
10441 
 
10442 
  thrift_spec = (
10443 
  )
10444 
 
10445 
  def read(self, iprot):
10446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10448 
      return
10449 
    iprot.readStructBegin()
10450 
    while True:
10451 
      (fname, ftype, fid) = iprot.readFieldBegin()
10452 
      if ftype == TType.STOP:
10453 
        break
10454 
      else:
10455 
        iprot.skip(ftype)
10456 
      iprot.readFieldEnd()
10457 
    iprot.readStructEnd()
10458 
 
10459 
  def write(self, oprot):
10460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10462 
      return
10463 
    oprot.writeStructBegin('getAllCategories_args')
10464 
    oprot.writeFieldStop()
10465 
    oprot.writeStructEnd()
10466 
 
10467 
  def validate(self):
10468 
    return
10469 
 
10470 
 
10471 
  def __repr__(self):
10472 
    L = ['%s=%r' % (key, value)
10473 
      for key, value in self.__dict__.iteritems()]
10474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10475 
 
10476 
  def __eq__(self, other):
10477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10478 
 
10479 
  def __ne__(self, other):
10480 
    return not (self == other)
10481 
 
10482 
class getAllCategories_result:
10483 
  """
10484 
  Attributes:
10485 
   - success
10486 
  """
10487 
 
10488 
  thrift_spec = (
10489 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10490 
  )
10491 
 
10492 
  def __init__(self, success=None,):
10493 
    self.success = success
10494 
 
10495 
  def read(self, iprot):
10496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10498 
      return
10499 
    iprot.readStructBegin()
10500 
    while True:
10501 
      (fname, ftype, fid) = iprot.readFieldBegin()
10502 
      if ftype == TType.STOP:
10503 
        break
10504 
      if fid == 0:
10505 
        if ftype == TType.LIST:
10506 
          self.success = []
7438 amit.gupta 10507 
          (_etype140, _size137) = iprot.readListBegin()
10508 
          for _i141 in xrange(_size137):
10509 
            _elem142 = Category()
10510 
            _elem142.read(iprot)
10511 
            self.success.append(_elem142)
5944 mandeep.dh 10512 
          iprot.readListEnd()
10513 
        else:
10514 
          iprot.skip(ftype)
10515 
      else:
10516 
        iprot.skip(ftype)
10517 
      iprot.readFieldEnd()
10518 
    iprot.readStructEnd()
10519 
 
10520 
  def write(self, oprot):
10521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10523 
      return
10524 
    oprot.writeStructBegin('getAllCategories_result')
10525 
    if self.success is not None:
10526 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10527 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10528 
      for iter143 in self.success:
10529 
        iter143.write(oprot)
5944 mandeep.dh 10530 
      oprot.writeListEnd()
10531 
      oprot.writeFieldEnd()
10532 
    oprot.writeFieldStop()
10533 
    oprot.writeStructEnd()
10534 
 
10535 
  def validate(self):
10536 
    return
10537 
 
10538 
 
10539 
  def __repr__(self):
10540 
    L = ['%s=%r' % (key, value)
10541 
      for key, value in self.__dict__.iteritems()]
10542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10543 
 
10544 
  def __eq__(self, other):
10545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10546 
 
10547 
  def __ne__(self, other):
10548 
    return not (self == other)
10549 
 
10550 
class getAllSimilarItems_args:
10551 
  """
10552 
  Attributes:
10553 
   - itemId
10554 
  """
10555 
 
10556 
  thrift_spec = (
10557 
    None, # 0
10558 
    (1, TType.I64, 'itemId', None, None, ), # 1
10559 
  )
10560 
 
10561 
  def __init__(self, itemId=None,):
10562 
    self.itemId = itemId
10563 
 
10564 
  def read(self, iprot):
10565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10567 
      return
10568 
    iprot.readStructBegin()
10569 
    while True:
10570 
      (fname, ftype, fid) = iprot.readFieldBegin()
10571 
      if ftype == TType.STOP:
10572 
        break
10573 
      if fid == 1:
10574 
        if ftype == TType.I64:
10575 
          self.itemId = iprot.readI64();
10576 
        else:
10577 
          iprot.skip(ftype)
10578 
      else:
10579 
        iprot.skip(ftype)
10580 
      iprot.readFieldEnd()
10581 
    iprot.readStructEnd()
10582 
 
10583 
  def write(self, oprot):
10584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10586 
      return
10587 
    oprot.writeStructBegin('getAllSimilarItems_args')
10588 
    if self.itemId is not None:
10589 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10590 
      oprot.writeI64(self.itemId)
10591 
      oprot.writeFieldEnd()
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
10595 
  def validate(self):
10596 
    return
10597 
 
10598 
 
10599 
  def __repr__(self):
10600 
    L = ['%s=%r' % (key, value)
10601 
      for key, value in self.__dict__.iteritems()]
10602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10603 
 
10604 
  def __eq__(self, other):
10605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10606 
 
10607 
  def __ne__(self, other):
10608 
    return not (self == other)
10609 
 
10610 
class getAllSimilarItems_result:
10611 
  """
10612 
  Attributes:
10613 
   - success
10614 
  """
10615 
 
10616 
  thrift_spec = (
10617 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10618 
  )
10619 
 
10620 
  def __init__(self, success=None,):
10621 
    self.success = success
10622 
 
10623 
  def read(self, iprot):
10624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10626 
      return
10627 
    iprot.readStructBegin()
10628 
    while True:
10629 
      (fname, ftype, fid) = iprot.readFieldBegin()
10630 
      if ftype == TType.STOP:
10631 
        break
10632 
      if fid == 0:
10633 
        if ftype == TType.LIST:
10634 
          self.success = []
7438 amit.gupta 10635 
          (_etype147, _size144) = iprot.readListBegin()
10636 
          for _i148 in xrange(_size144):
10637 
            _elem149 = Item()
10638 
            _elem149.read(iprot)
10639 
            self.success.append(_elem149)
5944 mandeep.dh 10640 
          iprot.readListEnd()
10641 
        else:
10642 
          iprot.skip(ftype)
10643 
      else:
10644 
        iprot.skip(ftype)
10645 
      iprot.readFieldEnd()
10646 
    iprot.readStructEnd()
10647 
 
10648 
  def write(self, oprot):
10649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10651 
      return
10652 
    oprot.writeStructBegin('getAllSimilarItems_result')
10653 
    if self.success is not None:
10654 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10655 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10656 
      for iter150 in self.success:
10657 
        iter150.write(oprot)
5944 mandeep.dh 10658 
      oprot.writeListEnd()
10659 
      oprot.writeFieldEnd()
10660 
    oprot.writeFieldStop()
10661 
    oprot.writeStructEnd()
10662 
 
10663 
  def validate(self):
10664 
    return
10665 
 
10666 
 
10667 
  def __repr__(self):
10668 
    L = ['%s=%r' % (key, value)
10669 
      for key, value in self.__dict__.iteritems()]
10670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10671 
 
10672 
  def __eq__(self, other):
10673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10674 
 
10675 
  def __ne__(self, other):
10676 
    return not (self == other)
10677 
 
10678 
class addSimilarItem_args:
10679 
  """
10680 
  Attributes:
10681 
   - itemId
10682 
   - catalogItemId
10683 
  """
10684 
 
10685 
  thrift_spec = (
10686 
    None, # 0
10687 
    (1, TType.I64, 'itemId', None, None, ), # 1
10688 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10689 
  )
10690 
 
10691 
  def __init__(self, itemId=None, catalogItemId=None,):
10692 
    self.itemId = itemId
10693 
    self.catalogItemId = catalogItemId
10694 
 
10695 
  def read(self, iprot):
10696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10698 
      return
10699 
    iprot.readStructBegin()
10700 
    while True:
10701 
      (fname, ftype, fid) = iprot.readFieldBegin()
10702 
      if ftype == TType.STOP:
10703 
        break
10704 
      if fid == 1:
10705 
        if ftype == TType.I64:
10706 
          self.itemId = iprot.readI64();
10707 
        else:
10708 
          iprot.skip(ftype)
10709 
      elif fid == 2:
10710 
        if ftype == TType.I64:
10711 
          self.catalogItemId = iprot.readI64();
10712 
        else:
10713 
          iprot.skip(ftype)
10714 
      else:
10715 
        iprot.skip(ftype)
10716 
      iprot.readFieldEnd()
10717 
    iprot.readStructEnd()
10718 
 
10719 
  def write(self, oprot):
10720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10722 
      return
10723 
    oprot.writeStructBegin('addSimilarItem_args')
10724 
    if self.itemId is not None:
10725 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10726 
      oprot.writeI64(self.itemId)
10727 
      oprot.writeFieldEnd()
10728 
    if self.catalogItemId is not None:
10729 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10730 
      oprot.writeI64(self.catalogItemId)
10731 
      oprot.writeFieldEnd()
10732 
    oprot.writeFieldStop()
10733 
    oprot.writeStructEnd()
10734 
 
10735 
  def validate(self):
10736 
    return
10737 
 
10738 
 
10739 
  def __repr__(self):
10740 
    L = ['%s=%r' % (key, value)
10741 
      for key, value in self.__dict__.iteritems()]
10742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10743 
 
10744 
  def __eq__(self, other):
10745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10746 
 
10747 
  def __ne__(self, other):
10748 
    return not (self == other)
10749 
 
10750 
class addSimilarItem_result:
10751 
  """
10752 
  Attributes:
10753 
   - success
10754 
   - cex
10755 
  """
10756 
 
10757 
  thrift_spec = (
10758 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10759 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10760 
  )
10761 
 
10762 
  def __init__(self, success=None, cex=None,):
10763 
    self.success = success
10764 
    self.cex = cex
10765 
 
10766 
  def read(self, iprot):
10767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10769 
      return
10770 
    iprot.readStructBegin()
10771 
    while True:
10772 
      (fname, ftype, fid) = iprot.readFieldBegin()
10773 
      if ftype == TType.STOP:
10774 
        break
10775 
      if fid == 0:
10776 
        if ftype == TType.STRUCT:
10777 
          self.success = Item()
10778 
          self.success.read(iprot)
10779 
        else:
10780 
          iprot.skip(ftype)
10781 
      elif fid == 1:
10782 
        if ftype == TType.STRUCT:
10783 
          self.cex = CatalogServiceException()
10784 
          self.cex.read(iprot)
10785 
        else:
10786 
          iprot.skip(ftype)
10787 
      else:
10788 
        iprot.skip(ftype)
10789 
      iprot.readFieldEnd()
10790 
    iprot.readStructEnd()
10791 
 
10792 
  def write(self, oprot):
10793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10795 
      return
10796 
    oprot.writeStructBegin('addSimilarItem_result')
10797 
    if self.success is not None:
10798 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10799 
      self.success.write(oprot)
10800 
      oprot.writeFieldEnd()
10801 
    if self.cex is not None:
10802 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10803 
      self.cex.write(oprot)
10804 
      oprot.writeFieldEnd()
10805 
    oprot.writeFieldStop()
10806 
    oprot.writeStructEnd()
10807 
 
10808 
  def validate(self):
10809 
    return
10810 
 
10811 
 
10812 
  def __repr__(self):
10813 
    L = ['%s=%r' % (key, value)
10814 
      for key, value in self.__dict__.iteritems()]
10815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10816 
 
10817 
  def __eq__(self, other):
10818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10819 
 
10820 
  def __ne__(self, other):
10821 
    return not (self == other)
10822 
 
6512 kshitij.so 10823 
class addTag_args:
10824 
  """
10825 
  Attributes:
10826 
   - displayName
10827 
   - itemId
10828 
  """
10829 
 
10830 
  thrift_spec = (
10831 
    None, # 0
10832 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10833 
    (2, TType.I64, 'itemId', None, None, ), # 2
10834 
  )
10835 
 
10836 
  def __init__(self, displayName=None, itemId=None,):
10837 
    self.displayName = displayName
10838 
    self.itemId = itemId
10839 
 
10840 
  def read(self, iprot):
10841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10843 
      return
10844 
    iprot.readStructBegin()
10845 
    while True:
10846 
      (fname, ftype, fid) = iprot.readFieldBegin()
10847 
      if ftype == TType.STOP:
10848 
        break
10849 
      if fid == 1:
10850 
        if ftype == TType.STRING:
10851 
          self.displayName = iprot.readString();
10852 
        else:
10853 
          iprot.skip(ftype)
10854 
      elif fid == 2:
10855 
        if ftype == TType.I64:
10856 
          self.itemId = 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('addTag_args')
10869 
    if self.displayName is not None:
10870 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10871 
      oprot.writeString(self.displayName)
10872 
      oprot.writeFieldEnd()
10873 
    if self.itemId is not None:
10874 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10875 
      oprot.writeI64(self.itemId)
10876 
      oprot.writeFieldEnd()
10877 
    oprot.writeFieldStop()
10878 
    oprot.writeStructEnd()
10879 
 
10880 
  def validate(self):
10881 
    return
10882 
 
10883 
 
10884 
  def __repr__(self):
10885 
    L = ['%s=%r' % (key, value)
10886 
      for key, value in self.__dict__.iteritems()]
10887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10888 
 
10889 
  def __eq__(self, other):
10890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10891 
 
10892 
  def __ne__(self, other):
10893 
    return not (self == other)
10894 
 
10895 
class addTag_result:
10896 
  """
10897 
  Attributes:
10898 
   - success
10899 
  """
10900 
 
10901 
  thrift_spec = (
10902 
    (0, TType.BOOL, 'success', None, None, ), # 0
10903 
  )
10904 
 
10905 
  def __init__(self, success=None,):
10906 
    self.success = success
10907 
 
10908 
  def read(self, iprot):
10909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10911 
      return
10912 
    iprot.readStructBegin()
10913 
    while True:
10914 
      (fname, ftype, fid) = iprot.readFieldBegin()
10915 
      if ftype == TType.STOP:
10916 
        break
10917 
      if fid == 0:
10918 
        if ftype == TType.BOOL:
10919 
          self.success = iprot.readBool();
10920 
        else:
10921 
          iprot.skip(ftype)
10922 
      else:
10923 
        iprot.skip(ftype)
10924 
      iprot.readFieldEnd()
10925 
    iprot.readStructEnd()
10926 
 
10927 
  def write(self, oprot):
10928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10930 
      return
10931 
    oprot.writeStructBegin('addTag_result')
10932 
    if self.success is not None:
10933 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10934 
      oprot.writeBool(self.success)
10935 
      oprot.writeFieldEnd()
10936 
    oprot.writeFieldStop()
10937 
    oprot.writeStructEnd()
10938 
 
10939 
  def validate(self):
10940 
    return
10941 
 
10942 
 
10943 
  def __repr__(self):
10944 
    L = ['%s=%r' % (key, value)
10945 
      for key, value in self.__dict__.iteritems()]
10946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10947 
 
10948 
  def __eq__(self, other):
10949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10950 
 
10951 
  def __ne__(self, other):
10952 
    return not (self == other)
10953 
 
10954 
class deleteEntityTag_args:
10955 
  """
10956 
  Attributes:
10957 
   - displayName
10958 
   - itemId
10959 
  """
10960 
 
10961 
  thrift_spec = (
10962 
    None, # 0
10963 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10964 
    (2, TType.I64, 'itemId', None, None, ), # 2
10965 
  )
10966 
 
10967 
  def __init__(self, displayName=None, itemId=None,):
10968 
    self.displayName = displayName
10969 
    self.itemId = itemId
10970 
 
10971 
  def read(self, iprot):
10972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10974 
      return
10975 
    iprot.readStructBegin()
10976 
    while True:
10977 
      (fname, ftype, fid) = iprot.readFieldBegin()
10978 
      if ftype == TType.STOP:
10979 
        break
10980 
      if fid == 1:
10981 
        if ftype == TType.STRING:
10982 
          self.displayName = iprot.readString();
10983 
        else:
10984 
          iprot.skip(ftype)
10985 
      elif fid == 2:
10986 
        if ftype == TType.I64:
10987 
          self.itemId = iprot.readI64();
10988 
        else:
10989 
          iprot.skip(ftype)
10990 
      else:
10991 
        iprot.skip(ftype)
10992 
      iprot.readFieldEnd()
10993 
    iprot.readStructEnd()
10994 
 
10995 
  def write(self, oprot):
10996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10998 
      return
10999 
    oprot.writeStructBegin('deleteEntityTag_args')
11000 
    if self.displayName is not None:
11001 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11002 
      oprot.writeString(self.displayName)
11003 
      oprot.writeFieldEnd()
11004 
    if self.itemId is not None:
11005 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11006 
      oprot.writeI64(self.itemId)
11007 
      oprot.writeFieldEnd()
11008 
    oprot.writeFieldStop()
11009 
    oprot.writeStructEnd()
11010 
 
11011 
  def validate(self):
11012 
    return
11013 
 
11014 
 
11015 
  def __repr__(self):
11016 
    L = ['%s=%r' % (key, value)
11017 
      for key, value in self.__dict__.iteritems()]
11018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11019 
 
11020 
  def __eq__(self, other):
11021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11022 
 
11023 
  def __ne__(self, other):
11024 
    return not (self == other)
11025 
 
11026 
class deleteEntityTag_result:
11027 
  """
11028 
  Attributes:
11029 
   - success
11030 
  """
11031 
 
11032 
  thrift_spec = (
11033 
    (0, TType.BOOL, 'success', None, None, ), # 0
11034 
  )
11035 
 
11036 
  def __init__(self, success=None,):
11037 
    self.success = success
11038 
 
11039 
  def read(self, iprot):
11040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11042 
      return
11043 
    iprot.readStructBegin()
11044 
    while True:
11045 
      (fname, ftype, fid) = iprot.readFieldBegin()
11046 
      if ftype == TType.STOP:
11047 
        break
11048 
      if fid == 0:
11049 
        if ftype == TType.BOOL:
11050 
          self.success = iprot.readBool();
11051 
        else:
11052 
          iprot.skip(ftype)
11053 
      else:
11054 
        iprot.skip(ftype)
11055 
      iprot.readFieldEnd()
11056 
    iprot.readStructEnd()
11057 
 
11058 
  def write(self, oprot):
11059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11061 
      return
11062 
    oprot.writeStructBegin('deleteEntityTag_result')
11063 
    if self.success is not None:
11064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11065 
      oprot.writeBool(self.success)
11066 
      oprot.writeFieldEnd()
11067 
    oprot.writeFieldStop()
11068 
    oprot.writeStructEnd()
11069 
 
11070 
  def validate(self):
11071 
    return
11072 
 
11073 
 
11074 
  def __repr__(self):
11075 
    L = ['%s=%r' % (key, value)
11076 
      for key, value in self.__dict__.iteritems()]
11077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11078 
 
11079 
  def __eq__(self, other):
11080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11081 
 
11082 
  def __ne__(self, other):
11083 
    return not (self == other)
11084 
 
11085 
class deleteTag_args:
11086 
  """
11087 
  Attributes:
11088 
   - displayName
11089 
  """
11090 
 
11091 
  thrift_spec = (
11092 
    None, # 0
11093 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11094 
  )
11095 
 
11096 
  def __init__(self, displayName=None,):
11097 
    self.displayName = displayName
11098 
 
11099 
  def read(self, iprot):
11100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11102 
      return
11103 
    iprot.readStructBegin()
11104 
    while True:
11105 
      (fname, ftype, fid) = iprot.readFieldBegin()
11106 
      if ftype == TType.STOP:
11107 
        break
11108 
      if fid == 1:
11109 
        if ftype == TType.STRING:
11110 
          self.displayName = iprot.readString();
11111 
        else:
11112 
          iprot.skip(ftype)
11113 
      else:
11114 
        iprot.skip(ftype)
11115 
      iprot.readFieldEnd()
11116 
    iprot.readStructEnd()
11117 
 
11118 
  def write(self, oprot):
11119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11121 
      return
11122 
    oprot.writeStructBegin('deleteTag_args')
11123 
    if self.displayName is not None:
11124 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11125 
      oprot.writeString(self.displayName)
11126 
      oprot.writeFieldEnd()
11127 
    oprot.writeFieldStop()
11128 
    oprot.writeStructEnd()
11129 
 
11130 
  def validate(self):
11131 
    return
11132 
 
11133 
 
11134 
  def __repr__(self):
11135 
    L = ['%s=%r' % (key, value)
11136 
      for key, value in self.__dict__.iteritems()]
11137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11138 
 
11139 
  def __eq__(self, other):
11140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11141 
 
11142 
  def __ne__(self, other):
11143 
    return not (self == other)
11144 
 
11145 
class deleteTag_result:
11146 
  """
11147 
  Attributes:
11148 
   - success
11149 
  """
11150 
 
11151 
  thrift_spec = (
11152 
    (0, TType.BOOL, 'success', None, None, ), # 0
11153 
  )
11154 
 
11155 
  def __init__(self, success=None,):
11156 
    self.success = success
11157 
 
11158 
  def read(self, iprot):
11159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11161 
      return
11162 
    iprot.readStructBegin()
11163 
    while True:
11164 
      (fname, ftype, fid) = iprot.readFieldBegin()
11165 
      if ftype == TType.STOP:
11166 
        break
11167 
      if fid == 0:
11168 
        if ftype == TType.BOOL:
11169 
          self.success = iprot.readBool();
11170 
        else:
11171 
          iprot.skip(ftype)
11172 
      else:
11173 
        iprot.skip(ftype)
11174 
      iprot.readFieldEnd()
11175 
    iprot.readStructEnd()
11176 
 
11177 
  def write(self, oprot):
11178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11180 
      return
11181 
    oprot.writeStructBegin('deleteTag_result')
11182 
    if self.success is not None:
11183 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11184 
      oprot.writeBool(self.success)
11185 
      oprot.writeFieldEnd()
11186 
    oprot.writeFieldStop()
11187 
    oprot.writeStructEnd()
11188 
 
11189 
  def validate(self):
11190 
    return
11191 
 
11192 
 
11193 
  def __repr__(self):
11194 
    L = ['%s=%r' % (key, value)
11195 
      for key, value in self.__dict__.iteritems()]
11196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11197 
 
11198 
  def __eq__(self, other):
11199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11200 
 
11201 
  def __ne__(self, other):
11202 
    return not (self == other)
11203 
 
11204 
class getAllTags_args:
11205 
 
11206 
  thrift_spec = (
11207 
  )
11208 
 
11209 
  def read(self, iprot):
11210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11212 
      return
11213 
    iprot.readStructBegin()
11214 
    while True:
11215 
      (fname, ftype, fid) = iprot.readFieldBegin()
11216 
      if ftype == TType.STOP:
11217 
        break
11218 
      else:
11219 
        iprot.skip(ftype)
11220 
      iprot.readFieldEnd()
11221 
    iprot.readStructEnd()
11222 
 
11223 
  def write(self, oprot):
11224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11226 
      return
11227 
    oprot.writeStructBegin('getAllTags_args')
11228 
    oprot.writeFieldStop()
11229 
    oprot.writeStructEnd()
11230 
 
11231 
  def validate(self):
11232 
    return
11233 
 
11234 
 
11235 
  def __repr__(self):
11236 
    L = ['%s=%r' % (key, value)
11237 
      for key, value in self.__dict__.iteritems()]
11238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11239 
 
11240 
  def __eq__(self, other):
11241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11242 
 
11243 
  def __ne__(self, other):
11244 
    return not (self == other)
11245 
 
11246 
class getAllTags_result:
11247 
  """
11248 
  Attributes:
11249 
   - success
11250 
  """
11251 
 
11252 
  thrift_spec = (
11253 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11254 
  )
11255 
 
11256 
  def __init__(self, success=None,):
11257 
    self.success = success
11258 
 
11259 
  def read(self, iprot):
11260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11262 
      return
11263 
    iprot.readStructBegin()
11264 
    while True:
11265 
      (fname, ftype, fid) = iprot.readFieldBegin()
11266 
      if ftype == TType.STOP:
11267 
        break
11268 
      if fid == 0:
11269 
        if ftype == TType.LIST:
11270 
          self.success = []
7438 amit.gupta 11271 
          (_etype154, _size151) = iprot.readListBegin()
11272 
          for _i155 in xrange(_size151):
11273 
            _elem156 = iprot.readString();
11274 
            self.success.append(_elem156)
6512 kshitij.so 11275 
          iprot.readListEnd()
11276 
        else:
11277 
          iprot.skip(ftype)
11278 
      else:
11279 
        iprot.skip(ftype)
11280 
      iprot.readFieldEnd()
11281 
    iprot.readStructEnd()
11282 
 
11283 
  def write(self, oprot):
11284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11286 
      return
11287 
    oprot.writeStructBegin('getAllTags_result')
11288 
    if self.success is not None:
11289 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11290 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11291 
      for iter157 in self.success:
11292 
        oprot.writeString(iter157)
6512 kshitij.so 11293 
      oprot.writeListEnd()
11294 
      oprot.writeFieldEnd()
11295 
    oprot.writeFieldStop()
11296 
    oprot.writeStructEnd()
11297 
 
11298 
  def validate(self):
11299 
    return
11300 
 
11301 
 
11302 
  def __repr__(self):
11303 
    L = ['%s=%r' % (key, value)
11304 
      for key, value in self.__dict__.iteritems()]
11305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11306 
 
11307 
  def __eq__(self, other):
11308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11309 
 
11310 
  def __ne__(self, other):
11311 
    return not (self == other)
11312 
 
11313 
class getAllEntitiesByTagName_args:
11314 
  """
11315 
  Attributes:
11316 
   - displayName
11317 
  """
11318 
 
11319 
  thrift_spec = (
11320 
    None, # 0
11321 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11322 
  )
11323 
 
11324 
  def __init__(self, displayName=None,):
11325 
    self.displayName = displayName
11326 
 
11327 
  def read(self, iprot):
11328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11330 
      return
11331 
    iprot.readStructBegin()
11332 
    while True:
11333 
      (fname, ftype, fid) = iprot.readFieldBegin()
11334 
      if ftype == TType.STOP:
11335 
        break
11336 
      if fid == 1:
11337 
        if ftype == TType.STRING:
11338 
          self.displayName = iprot.readString();
11339 
        else:
11340 
          iprot.skip(ftype)
11341 
      else:
11342 
        iprot.skip(ftype)
11343 
      iprot.readFieldEnd()
11344 
    iprot.readStructEnd()
11345 
 
11346 
  def write(self, oprot):
11347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11349 
      return
11350 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11351 
    if self.displayName is not None:
11352 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11353 
      oprot.writeString(self.displayName)
11354 
      oprot.writeFieldEnd()
11355 
    oprot.writeFieldStop()
11356 
    oprot.writeStructEnd()
11357 
 
11358 
  def validate(self):
11359 
    return
11360 
 
11361 
 
11362 
  def __repr__(self):
11363 
    L = ['%s=%r' % (key, value)
11364 
      for key, value in self.__dict__.iteritems()]
11365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11366 
 
11367 
  def __eq__(self, other):
11368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11369 
 
11370 
  def __ne__(self, other):
11371 
    return not (self == other)
11372 
 
11373 
class getAllEntitiesByTagName_result:
11374 
  """
11375 
  Attributes:
11376 
   - success
11377 
  """
11378 
 
11379 
  thrift_spec = (
11380 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11381 
  )
11382 
 
11383 
  def __init__(self, success=None,):
11384 
    self.success = success
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 == 0:
11396 
        if ftype == TType.LIST:
11397 
          self.success = []
7438 amit.gupta 11398 
          (_etype161, _size158) = iprot.readListBegin()
11399 
          for _i162 in xrange(_size158):
11400 
            _elem163 = iprot.readI64();
11401 
            self.success.append(_elem163)
6512 kshitij.so 11402 
          iprot.readListEnd()
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('getAllEntitiesByTagName_result')
11415 
    if self.success is not None:
11416 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11417 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 11418 
      for iter164 in self.success:
11419 
        oprot.writeI64(iter164)
6512 kshitij.so 11420 
      oprot.writeListEnd()
11421 
      oprot.writeFieldEnd()
11422 
    oprot.writeFieldStop()
11423 
    oprot.writeStructEnd()
11424 
 
11425 
  def validate(self):
11426 
    return
11427 
 
11428 
 
11429 
  def __repr__(self):
11430 
    L = ['%s=%r' % (key, value)
11431 
      for key, value in self.__dict__.iteritems()]
11432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11433 
 
11434 
  def __eq__(self, other):
11435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11436 
 
11437 
  def __ne__(self, other):
11438 
    return not (self == other)
11439 
 
6845 amit.gupta 11440 
class getAllEntityTags_args:
11441 
 
11442 
  thrift_spec = (
11443 
  )
11444 
 
11445 
  def read(self, iprot):
11446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11448 
      return
11449 
    iprot.readStructBegin()
11450 
    while True:
11451 
      (fname, ftype, fid) = iprot.readFieldBegin()
11452 
      if ftype == TType.STOP:
11453 
        break
11454 
      else:
11455 
        iprot.skip(ftype)
11456 
      iprot.readFieldEnd()
11457 
    iprot.readStructEnd()
11458 
 
11459 
  def write(self, oprot):
11460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11462 
      return
11463 
    oprot.writeStructBegin('getAllEntityTags_args')
11464 
    oprot.writeFieldStop()
11465 
    oprot.writeStructEnd()
11466 
 
11467 
  def validate(self):
11468 
    return
11469 
 
11470 
 
11471 
  def __repr__(self):
11472 
    L = ['%s=%r' % (key, value)
11473 
      for key, value in self.__dict__.iteritems()]
11474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11475 
 
11476 
  def __eq__(self, other):
11477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11478 
 
11479 
  def __ne__(self, other):
11480 
    return not (self == other)
11481 
 
11482 
class getAllEntityTags_result:
11483 
  """
11484 
  Attributes:
11485 
   - success
11486 
  """
11487 
 
11488 
  thrift_spec = (
11489 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11490 
  )
11491 
 
11492 
  def __init__(self, success=None,):
11493 
    self.success = success
11494 
 
11495 
  def read(self, iprot):
11496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11498 
      return
11499 
    iprot.readStructBegin()
11500 
    while True:
11501 
      (fname, ftype, fid) = iprot.readFieldBegin()
11502 
      if ftype == TType.STOP:
11503 
        break
11504 
      if fid == 0:
11505 
        if ftype == TType.MAP:
11506 
          self.success = {}
7438 amit.gupta 11507 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11508 
          for _i169 in xrange(_size165):
11509 
            _key170 = iprot.readI64();
11510 
            _val171 = []
11511 
            (_etype175, _size172) = iprot.readListBegin()
11512 
            for _i176 in xrange(_size172):
11513 
              _elem177 = iprot.readString();
11514 
              _val171.append(_elem177)
6845 amit.gupta 11515 
            iprot.readListEnd()
7438 amit.gupta 11516 
            self.success[_key170] = _val171
6845 amit.gupta 11517 
          iprot.readMapEnd()
11518 
        else:
11519 
          iprot.skip(ftype)
11520 
      else:
11521 
        iprot.skip(ftype)
11522 
      iprot.readFieldEnd()
11523 
    iprot.readStructEnd()
11524 
 
11525 
  def write(self, oprot):
11526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11528 
      return
11529 
    oprot.writeStructBegin('getAllEntityTags_result')
11530 
    if self.success is not None:
11531 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11532 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 11533 
      for kiter178,viter179 in self.success.items():
11534 
        oprot.writeI64(kiter178)
11535 
        oprot.writeListBegin(TType.STRING, len(viter179))
11536 
        for iter180 in viter179:
11537 
          oprot.writeString(iter180)
6845 amit.gupta 11538 
        oprot.writeListEnd()
11539 
      oprot.writeMapEnd()
11540 
      oprot.writeFieldEnd()
11541 
    oprot.writeFieldStop()
11542 
    oprot.writeStructEnd()
11543 
 
11544 
  def validate(self):
11545 
    return
11546 
 
11547 
 
11548 
  def __repr__(self):
11549 
    L = ['%s=%r' % (key, value)
11550 
      for key, value in self.__dict__.iteritems()]
11551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11552 
 
11553 
  def __eq__(self, other):
11554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11555 
 
11556 
  def __ne__(self, other):
11557 
    return not (self == other)
11558 
 
6850 kshitij.so 11559 
class addBanner_args:
11560 
  """
11561 
  Attributes:
8579 kshitij.so 11562 
   - banner
6850 kshitij.so 11563 
  """
11564 
 
11565 
  thrift_spec = (
11566 
    None, # 0
8579 kshitij.so 11567 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
6850 kshitij.so 11568 
  )
11569 
 
8579 kshitij.so 11570 
  def __init__(self, banner=None,):
11571 
    self.banner = banner
6850 kshitij.so 11572 
 
11573 
  def read(self, iprot):
11574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11576 
      return
11577 
    iprot.readStructBegin()
11578 
    while True:
11579 
      (fname, ftype, fid) = iprot.readFieldBegin()
11580 
      if ftype == TType.STOP:
11581 
        break
11582 
      if fid == 1:
8579 kshitij.so 11583 
        if ftype == TType.STRUCT:
11584 
          self.banner = Banner()
11585 
          self.banner.read(iprot)
6850 kshitij.so 11586 
        else:
11587 
          iprot.skip(ftype)
8579 kshitij.so 11588 
      else:
11589 
        iprot.skip(ftype)
11590 
      iprot.readFieldEnd()
11591 
    iprot.readStructEnd()
11592 
 
11593 
  def write(self, oprot):
11594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11596 
      return
11597 
    oprot.writeStructBegin('addBanner_args')
11598 
    if self.banner is not None:
11599 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
11600 
      self.banner.write(oprot)
11601 
      oprot.writeFieldEnd()
11602 
    oprot.writeFieldStop()
11603 
    oprot.writeStructEnd()
11604 
 
11605 
  def validate(self):
11606 
    return
11607 
 
11608 
 
11609 
  def __repr__(self):
11610 
    L = ['%s=%r' % (key, value)
11611 
      for key, value in self.__dict__.iteritems()]
11612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11613 
 
11614 
  def __eq__(self, other):
11615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11616 
 
11617 
  def __ne__(self, other):
11618 
    return not (self == other)
11619 
 
11620 
class addBanner_result:
11621 
  """
11622 
  Attributes:
11623 
   - success
11624 
  """
11625 
 
11626 
  thrift_spec = (
11627 
    (0, TType.BOOL, 'success', None, None, ), # 0
11628 
  )
11629 
 
11630 
  def __init__(self, success=None,):
11631 
    self.success = success
11632 
 
11633 
  def read(self, iprot):
11634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11636 
      return
11637 
    iprot.readStructBegin()
11638 
    while True:
11639 
      (fname, ftype, fid) = iprot.readFieldBegin()
11640 
      if ftype == TType.STOP:
11641 
        break
11642 
      if fid == 0:
6850 kshitij.so 11643 
        if ftype == TType.BOOL:
8579 kshitij.so 11644 
          self.success = iprot.readBool();
6850 kshitij.so 11645 
        else:
11646 
          iprot.skip(ftype)
8579 kshitij.so 11647 
      else:
11648 
        iprot.skip(ftype)
11649 
      iprot.readFieldEnd()
11650 
    iprot.readStructEnd()
11651 
 
11652 
  def write(self, oprot):
11653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11655 
      return
11656 
    oprot.writeStructBegin('addBanner_result')
11657 
    if self.success is not None:
11658 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11659 
      oprot.writeBool(self.success)
11660 
      oprot.writeFieldEnd()
11661 
    oprot.writeFieldStop()
11662 
    oprot.writeStructEnd()
11663 
 
11664 
  def validate(self):
11665 
    return
11666 
 
11667 
 
11668 
  def __repr__(self):
11669 
    L = ['%s=%r' % (key, value)
11670 
      for key, value in self.__dict__.iteritems()]
11671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11672 
 
11673 
  def __eq__(self, other):
11674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11675 
 
11676 
  def __ne__(self, other):
11677 
    return not (self == other)
11678 
 
11679 
class updateBanner_args:
11680 
  """
11681 
  Attributes:
11682 
   - banner
11683 
  """
11684 
 
11685 
  thrift_spec = (
11686 
    None, # 0
11687 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
11688 
  )
11689 
 
11690 
  def __init__(self, banner=None,):
11691 
    self.banner = banner
11692 
 
11693 
  def read(self, iprot):
11694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11696 
      return
11697 
    iprot.readStructBegin()
11698 
    while True:
11699 
      (fname, ftype, fid) = iprot.readFieldBegin()
11700 
      if ftype == TType.STOP:
11701 
        break
11702 
      if fid == 1:
11703 
        if ftype == TType.STRUCT:
11704 
          self.banner = Banner()
11705 
          self.banner.read(iprot)
6850 kshitij.so 11706 
        else:
11707 
          iprot.skip(ftype)
11708 
      else:
11709 
        iprot.skip(ftype)
11710 
      iprot.readFieldEnd()
11711 
    iprot.readStructEnd()
11712 
 
11713 
  def write(self, oprot):
11714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11716 
      return
8579 kshitij.so 11717 
    oprot.writeStructBegin('updateBanner_args')
11718 
    if self.banner is not None:
11719 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
11720 
      self.banner.write(oprot)
6850 kshitij.so 11721 
      oprot.writeFieldEnd()
11722 
    oprot.writeFieldStop()
11723 
    oprot.writeStructEnd()
11724 
 
11725 
  def validate(self):
11726 
    return
11727 
 
11728 
 
11729 
  def __repr__(self):
11730 
    L = ['%s=%r' % (key, value)
11731 
      for key, value in self.__dict__.iteritems()]
11732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11733 
 
11734 
  def __eq__(self, other):
11735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11736 
 
11737 
  def __ne__(self, other):
11738 
    return not (self == other)
11739 
 
8579 kshitij.so 11740 
class updateBanner_result:
6850 kshitij.so 11741 
  """
11742 
  Attributes:
11743 
   - success
11744 
  """
11745 
 
11746 
  thrift_spec = (
11747 
    (0, TType.BOOL, 'success', None, None, ), # 0
11748 
  )
11749 
 
11750 
  def __init__(self, success=None,):
11751 
    self.success = success
11752 
 
11753 
  def read(self, iprot):
11754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11756 
      return
11757 
    iprot.readStructBegin()
11758 
    while True:
11759 
      (fname, ftype, fid) = iprot.readFieldBegin()
11760 
      if ftype == TType.STOP:
11761 
        break
11762 
      if fid == 0:
11763 
        if ftype == TType.BOOL:
11764 
          self.success = iprot.readBool();
11765 
        else:
11766 
          iprot.skip(ftype)
11767 
      else:
11768 
        iprot.skip(ftype)
11769 
      iprot.readFieldEnd()
11770 
    iprot.readStructEnd()
11771 
 
11772 
  def write(self, oprot):
11773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11775 
      return
8579 kshitij.so 11776 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 11777 
    if self.success is not None:
11778 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11779 
      oprot.writeBool(self.success)
11780 
      oprot.writeFieldEnd()
11781 
    oprot.writeFieldStop()
11782 
    oprot.writeStructEnd()
11783 
 
11784 
  def validate(self):
11785 
    return
11786 
 
11787 
 
11788 
  def __repr__(self):
11789 
    L = ['%s=%r' % (key, value)
11790 
      for key, value in self.__dict__.iteritems()]
11791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11792 
 
11793 
  def __eq__(self, other):
11794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11795 
 
11796 
  def __ne__(self, other):
11797 
    return not (self == other)
11798 
 
11799 
class getAllBanners_args:
11800 
 
11801 
  thrift_spec = (
11802 
  )
11803 
 
11804 
  def read(self, iprot):
11805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11807 
      return
11808 
    iprot.readStructBegin()
11809 
    while True:
11810 
      (fname, ftype, fid) = iprot.readFieldBegin()
11811 
      if ftype == TType.STOP:
11812 
        break
11813 
      else:
11814 
        iprot.skip(ftype)
11815 
      iprot.readFieldEnd()
11816 
    iprot.readStructEnd()
11817 
 
11818 
  def write(self, oprot):
11819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11821 
      return
11822 
    oprot.writeStructBegin('getAllBanners_args')
11823 
    oprot.writeFieldStop()
11824 
    oprot.writeStructEnd()
11825 
 
11826 
  def validate(self):
11827 
    return
11828 
 
11829 
 
11830 
  def __repr__(self):
11831 
    L = ['%s=%r' % (key, value)
11832 
      for key, value in self.__dict__.iteritems()]
11833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11834 
 
11835 
  def __eq__(self, other):
11836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11837 
 
11838 
  def __ne__(self, other):
11839 
    return not (self == other)
11840 
 
11841 
class getAllBanners_result:
11842 
  """
11843 
  Attributes:
11844 
   - success
11845 
  """
11846 
 
11847 
  thrift_spec = (
8579 kshitij.so 11848 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 11849 
  )
11850 
 
11851 
  def __init__(self, success=None,):
11852 
    self.success = success
11853 
 
11854 
  def read(self, iprot):
11855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11857 
      return
11858 
    iprot.readStructBegin()
11859 
    while True:
11860 
      (fname, ftype, fid) = iprot.readFieldBegin()
11861 
      if ftype == TType.STOP:
11862 
        break
11863 
      if fid == 0:
11864 
        if ftype == TType.LIST:
11865 
          self.success = []
7438 amit.gupta 11866 
          (_etype184, _size181) = iprot.readListBegin()
11867 
          for _i185 in xrange(_size181):
8579 kshitij.so 11868 
            _elem186 = Banner()
11869 
            _elem186.read(iprot)
7438 amit.gupta 11870 
            self.success.append(_elem186)
6850 kshitij.so 11871 
          iprot.readListEnd()
11872 
        else:
11873 
          iprot.skip(ftype)
11874 
      else:
11875 
        iprot.skip(ftype)
11876 
      iprot.readFieldEnd()
11877 
    iprot.readStructEnd()
11878 
 
11879 
  def write(self, oprot):
11880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11882 
      return
11883 
    oprot.writeStructBegin('getAllBanners_result')
11884 
    if self.success is not None:
11885 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 11886 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11887 
      for iter187 in self.success:
8579 kshitij.so 11888 
        iter187.write(oprot)
6850 kshitij.so 11889 
      oprot.writeListEnd()
11890 
      oprot.writeFieldEnd()
11891 
    oprot.writeFieldStop()
11892 
    oprot.writeStructEnd()
11893 
 
11894 
  def validate(self):
11895 
    return
11896 
 
11897 
 
11898 
  def __repr__(self):
11899 
    L = ['%s=%r' % (key, value)
11900 
      for key, value in self.__dict__.iteritems()]
11901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11902 
 
11903 
  def __eq__(self, other):
11904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11905 
 
11906 
  def __ne__(self, other):
11907 
    return not (self == other)
11908 
 
11909 
class deleteBanner_args:
11910 
  """
11911 
  Attributes:
11912 
   - bannerName
11913 
  """
11914 
 
11915 
  thrift_spec = (
11916 
    None, # 0
11917 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11918 
  )
11919 
 
11920 
  def __init__(self, bannerName=None,):
11921 
    self.bannerName = bannerName
11922 
 
11923 
  def read(self, iprot):
11924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11926 
      return
11927 
    iprot.readStructBegin()
11928 
    while True:
11929 
      (fname, ftype, fid) = iprot.readFieldBegin()
11930 
      if ftype == TType.STOP:
11931 
        break
11932 
      if fid == 1:
11933 
        if ftype == TType.STRING:
11934 
          self.bannerName = iprot.readString();
11935 
        else:
11936 
          iprot.skip(ftype)
11937 
      else:
11938 
        iprot.skip(ftype)
11939 
      iprot.readFieldEnd()
11940 
    iprot.readStructEnd()
11941 
 
11942 
  def write(self, oprot):
11943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11945 
      return
11946 
    oprot.writeStructBegin('deleteBanner_args')
11947 
    if self.bannerName is not None:
11948 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11949 
      oprot.writeString(self.bannerName)
11950 
      oprot.writeFieldEnd()
11951 
    oprot.writeFieldStop()
11952 
    oprot.writeStructEnd()
11953 
 
11954 
  def validate(self):
11955 
    return
11956 
 
11957 
 
11958 
  def __repr__(self):
11959 
    L = ['%s=%r' % (key, value)
11960 
      for key, value in self.__dict__.iteritems()]
11961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11962 
 
11963 
  def __eq__(self, other):
11964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11965 
 
11966 
  def __ne__(self, other):
11967 
    return not (self == other)
11968 
 
11969 
class deleteBanner_result:
11970 
  """
11971 
  Attributes:
11972 
   - success
11973 
  """
11974 
 
11975 
  thrift_spec = (
11976 
    (0, TType.BOOL, 'success', None, None, ), # 0
11977 
  )
11978 
 
11979 
  def __init__(self, success=None,):
11980 
    self.success = success
11981 
 
11982 
  def read(self, iprot):
11983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11985 
      return
11986 
    iprot.readStructBegin()
11987 
    while True:
11988 
      (fname, ftype, fid) = iprot.readFieldBegin()
11989 
      if ftype == TType.STOP:
11990 
        break
11991 
      if fid == 0:
11992 
        if ftype == TType.BOOL:
11993 
          self.success = iprot.readBool();
11994 
        else:
11995 
          iprot.skip(ftype)
11996 
      else:
11997 
        iprot.skip(ftype)
11998 
      iprot.readFieldEnd()
11999 
    iprot.readStructEnd()
12000 
 
12001 
  def write(self, oprot):
12002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12004 
      return
12005 
    oprot.writeStructBegin('deleteBanner_result')
12006 
    if self.success is not None:
12007 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12008 
      oprot.writeBool(self.success)
12009 
      oprot.writeFieldEnd()
12010 
    oprot.writeFieldStop()
12011 
    oprot.writeStructEnd()
12012 
 
12013 
  def validate(self):
12014 
    return
12015 
 
12016 
 
12017 
  def __repr__(self):
12018 
    L = ['%s=%r' % (key, value)
12019 
      for key, value in self.__dict__.iteritems()]
12020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12021 
 
12022 
  def __eq__(self, other):
12023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12024 
 
12025 
  def __ne__(self, other):
12026 
    return not (self == other)
12027 
 
12028 
class getBannerDetails_args:
12029 
  """
12030 
  Attributes:
12031 
   - bannerName
12032 
  """
12033 
 
12034 
  thrift_spec = (
12035 
    None, # 0
12036 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12037 
  )
12038 
 
12039 
  def __init__(self, bannerName=None,):
12040 
    self.bannerName = bannerName
12041 
 
12042 
  def read(self, iprot):
12043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12045 
      return
12046 
    iprot.readStructBegin()
12047 
    while True:
12048 
      (fname, ftype, fid) = iprot.readFieldBegin()
12049 
      if ftype == TType.STOP:
12050 
        break
12051 
      if fid == 1:
12052 
        if ftype == TType.STRING:
12053 
          self.bannerName = iprot.readString();
12054 
        else:
12055 
          iprot.skip(ftype)
12056 
      else:
12057 
        iprot.skip(ftype)
12058 
      iprot.readFieldEnd()
12059 
    iprot.readStructEnd()
12060 
 
12061 
  def write(self, oprot):
12062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12064 
      return
12065 
    oprot.writeStructBegin('getBannerDetails_args')
12066 
    if self.bannerName is not None:
12067 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12068 
      oprot.writeString(self.bannerName)
12069 
      oprot.writeFieldEnd()
12070 
    oprot.writeFieldStop()
12071 
    oprot.writeStructEnd()
12072 
 
12073 
  def validate(self):
12074 
    return
12075 
 
12076 
 
12077 
  def __repr__(self):
12078 
    L = ['%s=%r' % (key, value)
12079 
      for key, value in self.__dict__.iteritems()]
12080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12081 
 
12082 
  def __eq__(self, other):
12083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12084 
 
12085 
  def __ne__(self, other):
12086 
    return not (self == other)
12087 
 
12088 
class getBannerDetails_result:
12089 
  """
12090 
  Attributes:
12091 
   - success
12092 
  """
12093 
 
12094 
  thrift_spec = (
12095 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12096 
  )
12097 
 
12098 
  def __init__(self, success=None,):
12099 
    self.success = success
12100 
 
12101 
  def read(self, iprot):
12102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12104 
      return
12105 
    iprot.readStructBegin()
12106 
    while True:
12107 
      (fname, ftype, fid) = iprot.readFieldBegin()
12108 
      if ftype == TType.STOP:
12109 
        break
12110 
      if fid == 0:
12111 
        if ftype == TType.STRUCT:
12112 
          self.success = Banner()
12113 
          self.success.read(iprot)
12114 
        else:
12115 
          iprot.skip(ftype)
12116 
      else:
12117 
        iprot.skip(ftype)
12118 
      iprot.readFieldEnd()
12119 
    iprot.readStructEnd()
12120 
 
12121 
  def write(self, oprot):
12122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12124 
      return
12125 
    oprot.writeStructBegin('getBannerDetails_result')
12126 
    if self.success is not None:
12127 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12128 
      self.success.write(oprot)
12129 
      oprot.writeFieldEnd()
12130 
    oprot.writeFieldStop()
12131 
    oprot.writeStructEnd()
12132 
 
12133 
  def validate(self):
12134 
    return
12135 
 
12136 
 
12137 
  def __repr__(self):
12138 
    L = ['%s=%r' % (key, value)
12139 
      for key, value in self.__dict__.iteritems()]
12140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12141 
 
12142 
  def __eq__(self, other):
12143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12144 
 
12145 
  def __ne__(self, other):
12146 
    return not (self == other)
12147 
 
12148 
class getActiveBanners_args:
12149 
 
12150 
  thrift_spec = (
12151 
  )
12152 
 
12153 
  def read(self, iprot):
12154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12156 
      return
12157 
    iprot.readStructBegin()
12158 
    while True:
12159 
      (fname, ftype, fid) = iprot.readFieldBegin()
12160 
      if ftype == TType.STOP:
12161 
        break
12162 
      else:
12163 
        iprot.skip(ftype)
12164 
      iprot.readFieldEnd()
12165 
    iprot.readStructEnd()
12166 
 
12167 
  def write(self, oprot):
12168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12170 
      return
12171 
    oprot.writeStructBegin('getActiveBanners_args')
12172 
    oprot.writeFieldStop()
12173 
    oprot.writeStructEnd()
12174 
 
12175 
  def validate(self):
12176 
    return
12177 
 
12178 
 
12179 
  def __repr__(self):
12180 
    L = ['%s=%r' % (key, value)
12181 
      for key, value in self.__dict__.iteritems()]
12182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12183 
 
12184 
  def __eq__(self, other):
12185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12186 
 
12187 
  def __ne__(self, other):
12188 
    return not (self == other)
12189 
 
12190 
class getActiveBanners_result:
12191 
  """
12192 
  Attributes:
12193 
   - success
12194 
  """
12195 
 
12196 
  thrift_spec = (
8579 kshitij.so 12197 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12198 
  )
12199 
 
12200 
  def __init__(self, success=None,):
12201 
    self.success = success
12202 
 
12203 
  def read(self, iprot):
12204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12206 
      return
12207 
    iprot.readStructBegin()
12208 
    while True:
12209 
      (fname, ftype, fid) = iprot.readFieldBegin()
12210 
      if ftype == TType.STOP:
12211 
        break
12212 
      if fid == 0:
8579 kshitij.so 12213 
        if ftype == TType.MAP:
12214 
          self.success = {}
12215 
          (_ktype189, _vtype190, _size188 ) = iprot.readMapBegin()
7438 amit.gupta 12216 
          for _i192 in xrange(_size188):
8579 kshitij.so 12217 
            _key193 = iprot.readString();
12218 
            _val194 = []
12219 
            (_etype198, _size195) = iprot.readListBegin()
12220 
            for _i199 in xrange(_size195):
12221 
              _elem200 = Banner()
12222 
              _elem200.read(iprot)
12223 
              _val194.append(_elem200)
12224 
            iprot.readListEnd()
12225 
            self.success[_key193] = _val194
12226 
          iprot.readMapEnd()
6850 kshitij.so 12227 
        else:
12228 
          iprot.skip(ftype)
12229 
      else:
12230 
        iprot.skip(ftype)
12231 
      iprot.readFieldEnd()
12232 
    iprot.readStructEnd()
12233 
 
12234 
  def write(self, oprot):
12235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12237 
      return
12238 
    oprot.writeStructBegin('getActiveBanners_result')
12239 
    if self.success is not None:
8579 kshitij.so 12240 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12241 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
12242 
      for kiter201,viter202 in self.success.items():
12243 
        oprot.writeString(kiter201)
12244 
        oprot.writeListBegin(TType.STRUCT, len(viter202))
12245 
        for iter203 in viter202:
12246 
          iter203.write(oprot)
12247 
        oprot.writeListEnd()
12248 
      oprot.writeMapEnd()
6850 kshitij.so 12249 
      oprot.writeFieldEnd()
12250 
    oprot.writeFieldStop()
12251 
    oprot.writeStructEnd()
12252 
 
12253 
  def validate(self):
12254 
    return
12255 
 
12256 
 
12257 
  def __repr__(self):
12258 
    L = ['%s=%r' % (key, value)
12259 
      for key, value in self.__dict__.iteritems()]
12260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12261 
 
12262 
  def __eq__(self, other):
12263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12264 
 
12265 
  def __ne__(self, other):
12266 
    return not (self == other)
12267 
 
6849 kshitij.so 12268 
class addBannerMap_args:
12269 
  """
12270 
  Attributes:
8579 kshitij.so 12271 
   - bannerMaps
6849 kshitij.so 12272 
  """
12273 
 
12274 
  thrift_spec = (
12275 
    None, # 0
8579 kshitij.so 12276 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12277 
  )
12278 
 
8579 kshitij.so 12279 
  def __init__(self, bannerMaps=None,):
12280 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12281 
 
12282 
  def read(self, iprot):
12283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12285 
      return
12286 
    iprot.readStructBegin()
12287 
    while True:
12288 
      (fname, ftype, fid) = iprot.readFieldBegin()
12289 
      if ftype == TType.STOP:
12290 
        break
12291 
      if fid == 1:
8579 kshitij.so 12292 
        if ftype == TType.LIST:
12293 
          self.bannerMaps = []
12294 
          (_etype207, _size204) = iprot.readListBegin()
12295 
          for _i208 in xrange(_size204):
12296 
            _elem209 = BannerMap()
12297 
            _elem209.read(iprot)
12298 
            self.bannerMaps.append(_elem209)
12299 
          iprot.readListEnd()
6849 kshitij.so 12300 
        else:
12301 
          iprot.skip(ftype)
8579 kshitij.so 12302 
      else:
12303 
        iprot.skip(ftype)
12304 
      iprot.readFieldEnd()
12305 
    iprot.readStructEnd()
12306 
 
12307 
  def write(self, oprot):
12308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12310 
      return
12311 
    oprot.writeStructBegin('addBannerMap_args')
12312 
    if self.bannerMaps is not None:
12313 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12314 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
12315 
      for iter210 in self.bannerMaps:
12316 
        iter210.write(oprot)
12317 
      oprot.writeListEnd()
12318 
      oprot.writeFieldEnd()
12319 
    oprot.writeFieldStop()
12320 
    oprot.writeStructEnd()
12321 
 
12322 
  def validate(self):
12323 
    return
12324 
 
12325 
 
12326 
  def __repr__(self):
12327 
    L = ['%s=%r' % (key, value)
12328 
      for key, value in self.__dict__.iteritems()]
12329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12330 
 
12331 
  def __eq__(self, other):
12332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12333 
 
12334 
  def __ne__(self, other):
12335 
    return not (self == other)
12336 
 
12337 
class addBannerMap_result:
12338 
  """
12339 
  Attributes:
12340 
   - success
12341 
  """
12342 
 
12343 
  thrift_spec = (
12344 
    (0, TType.BOOL, 'success', None, None, ), # 0
12345 
  )
12346 
 
12347 
  def __init__(self, success=None,):
12348 
    self.success = success
12349 
 
12350 
  def read(self, iprot):
12351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12353 
      return
12354 
    iprot.readStructBegin()
12355 
    while True:
12356 
      (fname, ftype, fid) = iprot.readFieldBegin()
12357 
      if ftype == TType.STOP:
12358 
        break
12359 
      if fid == 0:
12360 
        if ftype == TType.BOOL:
12361 
          self.success = iprot.readBool();
6849 kshitij.so 12362 
        else:
12363 
          iprot.skip(ftype)
8579 kshitij.so 12364 
      else:
12365 
        iprot.skip(ftype)
12366 
      iprot.readFieldEnd()
12367 
    iprot.readStructEnd()
12368 
 
12369 
  def write(self, oprot):
12370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12372 
      return
12373 
    oprot.writeStructBegin('addBannerMap_result')
12374 
    if self.success is not None:
12375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12376 
      oprot.writeBool(self.success)
12377 
      oprot.writeFieldEnd()
12378 
    oprot.writeFieldStop()
12379 
    oprot.writeStructEnd()
12380 
 
12381 
  def validate(self):
12382 
    return
12383 
 
12384 
 
12385 
  def __repr__(self):
12386 
    L = ['%s=%r' % (key, value)
12387 
      for key, value in self.__dict__.iteritems()]
12388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12389 
 
12390 
  def __eq__(self, other):
12391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12392 
 
12393 
  def __ne__(self, other):
12394 
    return not (self == other)
12395 
 
12396 
class updateBannerMap_args:
12397 
  """
12398 
  Attributes:
12399 
   - bannerMap
12400 
  """
12401 
 
12402 
  thrift_spec = (
12403 
    None, # 0
12404 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
12405 
  )
12406 
 
12407 
  def __init__(self, bannerMap=None,):
12408 
    self.bannerMap = bannerMap
12409 
 
12410 
  def read(self, iprot):
12411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12413 
      return
12414 
    iprot.readStructBegin()
12415 
    while True:
12416 
      (fname, ftype, fid) = iprot.readFieldBegin()
12417 
      if ftype == TType.STOP:
12418 
        break
12419 
      if fid == 1:
12420 
        if ftype == TType.STRUCT:
12421 
          self.bannerMap = BannerMap()
12422 
          self.bannerMap.read(iprot)
6849 kshitij.so 12423 
        else:
12424 
          iprot.skip(ftype)
12425 
      else:
12426 
        iprot.skip(ftype)
12427 
      iprot.readFieldEnd()
12428 
    iprot.readStructEnd()
12429 
 
12430 
  def write(self, oprot):
12431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12433 
      return
8579 kshitij.so 12434 
    oprot.writeStructBegin('updateBannerMap_args')
12435 
    if self.bannerMap is not None:
12436 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
12437 
      self.bannerMap.write(oprot)
6849 kshitij.so 12438 
      oprot.writeFieldEnd()
12439 
    oprot.writeFieldStop()
12440 
    oprot.writeStructEnd()
12441 
 
12442 
  def validate(self):
12443 
    return
12444 
 
12445 
 
12446 
  def __repr__(self):
12447 
    L = ['%s=%r' % (key, value)
12448 
      for key, value in self.__dict__.iteritems()]
12449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12450 
 
12451 
  def __eq__(self, other):
12452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12453 
 
12454 
  def __ne__(self, other):
12455 
    return not (self == other)
12456 
 
8579 kshitij.so 12457 
class updateBannerMap_result:
6849 kshitij.so 12458 
  """
12459 
  Attributes:
12460 
   - success
12461 
  """
12462 
 
12463 
  thrift_spec = (
12464 
    (0, TType.BOOL, 'success', None, None, ), # 0
12465 
  )
12466 
 
12467 
  def __init__(self, success=None,):
12468 
    self.success = success
12469 
 
12470 
  def read(self, iprot):
12471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12473 
      return
12474 
    iprot.readStructBegin()
12475 
    while True:
12476 
      (fname, ftype, fid) = iprot.readFieldBegin()
12477 
      if ftype == TType.STOP:
12478 
        break
12479 
      if fid == 0:
12480 
        if ftype == TType.BOOL:
12481 
          self.success = iprot.readBool();
12482 
        else:
12483 
          iprot.skip(ftype)
12484 
      else:
12485 
        iprot.skip(ftype)
12486 
      iprot.readFieldEnd()
12487 
    iprot.readStructEnd()
12488 
 
12489 
  def write(self, oprot):
12490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12492 
      return
8579 kshitij.so 12493 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 12494 
    if self.success is not None:
12495 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12496 
      oprot.writeBool(self.success)
12497 
      oprot.writeFieldEnd()
12498 
    oprot.writeFieldStop()
12499 
    oprot.writeStructEnd()
12500 
 
12501 
  def validate(self):
12502 
    return
12503 
 
12504 
 
12505 
  def __repr__(self):
12506 
    L = ['%s=%r' % (key, value)
12507 
      for key, value in self.__dict__.iteritems()]
12508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12509 
 
12510 
  def __eq__(self, other):
12511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12512 
 
12513 
  def __ne__(self, other):
12514 
    return not (self == other)
12515 
 
12516 
class deleteBannerMap_args:
12517 
  """
12518 
  Attributes:
12519 
   - bannerName
12520 
  """
12521 
 
12522 
  thrift_spec = (
12523 
    None, # 0
12524 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12525 
  )
12526 
 
12527 
  def __init__(self, bannerName=None,):
12528 
    self.bannerName = bannerName
12529 
 
12530 
  def read(self, iprot):
12531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12533 
      return
12534 
    iprot.readStructBegin()
12535 
    while True:
12536 
      (fname, ftype, fid) = iprot.readFieldBegin()
12537 
      if ftype == TType.STOP:
12538 
        break
12539 
      if fid == 1:
12540 
        if ftype == TType.STRING:
12541 
          self.bannerName = iprot.readString();
12542 
        else:
12543 
          iprot.skip(ftype)
12544 
      else:
12545 
        iprot.skip(ftype)
12546 
      iprot.readFieldEnd()
12547 
    iprot.readStructEnd()
12548 
 
12549 
  def write(self, oprot):
12550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12552 
      return
12553 
    oprot.writeStructBegin('deleteBannerMap_args')
12554 
    if self.bannerName is not None:
12555 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12556 
      oprot.writeString(self.bannerName)
12557 
      oprot.writeFieldEnd()
12558 
    oprot.writeFieldStop()
12559 
    oprot.writeStructEnd()
12560 
 
12561 
  def validate(self):
12562 
    return
12563 
 
12564 
 
12565 
  def __repr__(self):
12566 
    L = ['%s=%r' % (key, value)
12567 
      for key, value in self.__dict__.iteritems()]
12568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12569 
 
12570 
  def __eq__(self, other):
12571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12572 
 
12573 
  def __ne__(self, other):
12574 
    return not (self == other)
12575 
 
12576 
class deleteBannerMap_result:
12577 
  """
12578 
  Attributes:
12579 
   - success
12580 
  """
12581 
 
12582 
  thrift_spec = (
12583 
    (0, TType.BOOL, 'success', None, None, ), # 0
12584 
  )
12585 
 
12586 
  def __init__(self, success=None,):
12587 
    self.success = success
12588 
 
12589 
  def read(self, iprot):
12590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12592 
      return
12593 
    iprot.readStructBegin()
12594 
    while True:
12595 
      (fname, ftype, fid) = iprot.readFieldBegin()
12596 
      if ftype == TType.STOP:
12597 
        break
12598 
      if fid == 0:
12599 
        if ftype == TType.BOOL:
12600 
          self.success = iprot.readBool();
12601 
        else:
12602 
          iprot.skip(ftype)
12603 
      else:
12604 
        iprot.skip(ftype)
12605 
      iprot.readFieldEnd()
12606 
    iprot.readStructEnd()
12607 
 
12608 
  def write(self, oprot):
12609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12611 
      return
12612 
    oprot.writeStructBegin('deleteBannerMap_result')
12613 
    if self.success is not None:
12614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12615 
      oprot.writeBool(self.success)
12616 
      oprot.writeFieldEnd()
12617 
    oprot.writeFieldStop()
12618 
    oprot.writeStructEnd()
12619 
 
12620 
  def validate(self):
12621 
    return
12622 
 
12623 
 
12624 
  def __repr__(self):
12625 
    L = ['%s=%r' % (key, value)
12626 
      for key, value in self.__dict__.iteritems()]
12627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12628 
 
12629 
  def __eq__(self, other):
12630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12631 
 
12632 
  def __ne__(self, other):
12633 
    return not (self == other)
12634 
 
12635 
class getBannerMapDetails_args:
12636 
  """
12637 
  Attributes:
12638 
   - bannerName
12639 
  """
12640 
 
12641 
  thrift_spec = (
12642 
    None, # 0
12643 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12644 
  )
12645 
 
12646 
  def __init__(self, bannerName=None,):
12647 
    self.bannerName = bannerName
12648 
 
12649 
  def read(self, iprot):
12650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12652 
      return
12653 
    iprot.readStructBegin()
12654 
    while True:
12655 
      (fname, ftype, fid) = iprot.readFieldBegin()
12656 
      if ftype == TType.STOP:
12657 
        break
12658 
      if fid == 1:
12659 
        if ftype == TType.STRING:
12660 
          self.bannerName = iprot.readString();
12661 
        else:
12662 
          iprot.skip(ftype)
12663 
      else:
12664 
        iprot.skip(ftype)
12665 
      iprot.readFieldEnd()
12666 
    iprot.readStructEnd()
12667 
 
12668 
  def write(self, oprot):
12669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12671 
      return
12672 
    oprot.writeStructBegin('getBannerMapDetails_args')
12673 
    if self.bannerName is not None:
12674 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12675 
      oprot.writeString(self.bannerName)
12676 
      oprot.writeFieldEnd()
12677 
    oprot.writeFieldStop()
12678 
    oprot.writeStructEnd()
12679 
 
12680 
  def validate(self):
12681 
    return
12682 
 
12683 
 
12684 
  def __repr__(self):
12685 
    L = ['%s=%r' % (key, value)
12686 
      for key, value in self.__dict__.iteritems()]
12687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12688 
 
12689 
  def __eq__(self, other):
12690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12691 
 
12692 
  def __ne__(self, other):
12693 
    return not (self == other)
12694 
 
12695 
class getBannerMapDetails_result:
12696 
  """
12697 
  Attributes:
12698 
   - success
12699 
  """
12700 
 
12701 
  thrift_spec = (
12702 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
12703 
  )
12704 
 
12705 
  def __init__(self, success=None,):
12706 
    self.success = success
12707 
 
12708 
  def read(self, iprot):
12709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12711 
      return
12712 
    iprot.readStructBegin()
12713 
    while True:
12714 
      (fname, ftype, fid) = iprot.readFieldBegin()
12715 
      if ftype == TType.STOP:
12716 
        break
12717 
      if fid == 0:
12718 
        if ftype == TType.LIST:
12719 
          self.success = []
8579 kshitij.so 12720 
          (_etype214, _size211) = iprot.readListBegin()
12721 
          for _i215 in xrange(_size211):
12722 
            _elem216 = BannerMap()
12723 
            _elem216.read(iprot)
12724 
            self.success.append(_elem216)
6849 kshitij.so 12725 
          iprot.readListEnd()
12726 
        else:
12727 
          iprot.skip(ftype)
12728 
      else:
12729 
        iprot.skip(ftype)
12730 
      iprot.readFieldEnd()
12731 
    iprot.readStructEnd()
12732 
 
12733 
  def write(self, oprot):
12734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12736 
      return
12737 
    oprot.writeStructBegin('getBannerMapDetails_result')
12738 
    if self.success is not None:
12739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12740 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 12741 
      for iter217 in self.success:
12742 
        iter217.write(oprot)
6849 kshitij.so 12743 
      oprot.writeListEnd()
12744 
      oprot.writeFieldEnd()
12745 
    oprot.writeFieldStop()
12746 
    oprot.writeStructEnd()
12747 
 
12748 
  def validate(self):
12749 
    return
12750 
 
12751 
 
12752 
  def __repr__(self):
12753 
    L = ['%s=%r' % (key, value)
12754 
      for key, value in self.__dict__.iteritems()]
12755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12756 
 
12757 
  def __eq__(self, other):
12758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12759 
 
12760 
  def __ne__(self, other):
12761 
    return not (self == other)
12762 
 
8579 kshitij.so 12763 
class addBannerUri_args:
12764 
  """
12765 
  Attributes:
12766 
   - bannerUriMappings
12767 
  """
12768 
 
12769 
  thrift_spec = (
12770 
    None, # 0
12771 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
12772 
  )
12773 
 
12774 
  def __init__(self, bannerUriMappings=None,):
12775 
    self.bannerUriMappings = bannerUriMappings
12776 
 
12777 
  def read(self, iprot):
12778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12780 
      return
12781 
    iprot.readStructBegin()
12782 
    while True:
12783 
      (fname, ftype, fid) = iprot.readFieldBegin()
12784 
      if ftype == TType.STOP:
12785 
        break
12786 
      if fid == 1:
12787 
        if ftype == TType.LIST:
12788 
          self.bannerUriMappings = []
12789 
          (_etype221, _size218) = iprot.readListBegin()
12790 
          for _i222 in xrange(_size218):
12791 
            _elem223 = BannerUriMapping()
12792 
            _elem223.read(iprot)
12793 
            self.bannerUriMappings.append(_elem223)
12794 
          iprot.readListEnd()
12795 
        else:
12796 
          iprot.skip(ftype)
12797 
      else:
12798 
        iprot.skip(ftype)
12799 
      iprot.readFieldEnd()
12800 
    iprot.readStructEnd()
12801 
 
12802 
  def write(self, oprot):
12803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12805 
      return
12806 
    oprot.writeStructBegin('addBannerUri_args')
12807 
    if self.bannerUriMappings is not None:
12808 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
12809 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
12810 
      for iter224 in self.bannerUriMappings:
12811 
        iter224.write(oprot)
12812 
      oprot.writeListEnd()
12813 
      oprot.writeFieldEnd()
12814 
    oprot.writeFieldStop()
12815 
    oprot.writeStructEnd()
12816 
 
12817 
  def validate(self):
12818 
    return
12819 
 
12820 
 
12821 
  def __repr__(self):
12822 
    L = ['%s=%r' % (key, value)
12823 
      for key, value in self.__dict__.iteritems()]
12824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12825 
 
12826 
  def __eq__(self, other):
12827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12828 
 
12829 
  def __ne__(self, other):
12830 
    return not (self == other)
12831 
 
12832 
class addBannerUri_result:
12833 
 
12834 
  thrift_spec = (
12835 
  )
12836 
 
12837 
  def read(self, iprot):
12838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12840 
      return
12841 
    iprot.readStructBegin()
12842 
    while True:
12843 
      (fname, ftype, fid) = iprot.readFieldBegin()
12844 
      if ftype == TType.STOP:
12845 
        break
12846 
      else:
12847 
        iprot.skip(ftype)
12848 
      iprot.readFieldEnd()
12849 
    iprot.readStructEnd()
12850 
 
12851 
  def write(self, oprot):
12852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12854 
      return
12855 
    oprot.writeStructBegin('addBannerUri_result')
12856 
    oprot.writeFieldStop()
12857 
    oprot.writeStructEnd()
12858 
 
12859 
  def validate(self):
12860 
    return
12861 
 
12862 
 
12863 
  def __repr__(self):
12864 
    L = ['%s=%r' % (key, value)
12865 
      for key, value in self.__dict__.iteritems()]
12866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12867 
 
12868 
  def __eq__(self, other):
12869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12870 
 
12871 
  def __ne__(self, other):
12872 
    return not (self == other)
12873 
 
12874 
class getUriMapping_args:
12875 
  """
12876 
  Attributes:
12877 
   - bannerName
12878 
  """
12879 
 
12880 
  thrift_spec = (
12881 
    None, # 0
12882 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12883 
  )
12884 
 
12885 
  def __init__(self, bannerName=None,):
12886 
    self.bannerName = bannerName
12887 
 
12888 
  def read(self, iprot):
12889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12891 
      return
12892 
    iprot.readStructBegin()
12893 
    while True:
12894 
      (fname, ftype, fid) = iprot.readFieldBegin()
12895 
      if ftype == TType.STOP:
12896 
        break
12897 
      if fid == 1:
12898 
        if ftype == TType.STRING:
12899 
          self.bannerName = iprot.readString();
12900 
        else:
12901 
          iprot.skip(ftype)
12902 
      else:
12903 
        iprot.skip(ftype)
12904 
      iprot.readFieldEnd()
12905 
    iprot.readStructEnd()
12906 
 
12907 
  def write(self, oprot):
12908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12910 
      return
12911 
    oprot.writeStructBegin('getUriMapping_args')
12912 
    if self.bannerName is not None:
12913 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12914 
      oprot.writeString(self.bannerName)
12915 
      oprot.writeFieldEnd()
12916 
    oprot.writeFieldStop()
12917 
    oprot.writeStructEnd()
12918 
 
12919 
  def validate(self):
12920 
    return
12921 
 
12922 
 
12923 
  def __repr__(self):
12924 
    L = ['%s=%r' % (key, value)
12925 
      for key, value in self.__dict__.iteritems()]
12926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12927 
 
12928 
  def __eq__(self, other):
12929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12930 
 
12931 
  def __ne__(self, other):
12932 
    return not (self == other)
12933 
 
12934 
class getUriMapping_result:
12935 
  """
12936 
  Attributes:
12937 
   - success
12938 
  """
12939 
 
12940 
  thrift_spec = (
12941 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
12942 
  )
12943 
 
12944 
  def __init__(self, success=None,):
12945 
    self.success = success
12946 
 
12947 
  def read(self, iprot):
12948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12950 
      return
12951 
    iprot.readStructBegin()
12952 
    while True:
12953 
      (fname, ftype, fid) = iprot.readFieldBegin()
12954 
      if ftype == TType.STOP:
12955 
        break
12956 
      if fid == 0:
12957 
        if ftype == TType.LIST:
12958 
          self.success = []
12959 
          (_etype228, _size225) = iprot.readListBegin()
12960 
          for _i229 in xrange(_size225):
12961 
            _elem230 = BannerUriMapping()
12962 
            _elem230.read(iprot)
12963 
            self.success.append(_elem230)
12964 
          iprot.readListEnd()
12965 
        else:
12966 
          iprot.skip(ftype)
12967 
      else:
12968 
        iprot.skip(ftype)
12969 
      iprot.readFieldEnd()
12970 
    iprot.readStructEnd()
12971 
 
12972 
  def write(self, oprot):
12973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12975 
      return
12976 
    oprot.writeStructBegin('getUriMapping_result')
12977 
    if self.success is not None:
12978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12979 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12980 
      for iter231 in self.success:
12981 
        iter231.write(oprot)
12982 
      oprot.writeListEnd()
12983 
      oprot.writeFieldEnd()
12984 
    oprot.writeFieldStop()
12985 
    oprot.writeStructEnd()
12986 
 
12987 
  def validate(self):
12988 
    return
12989 
 
12990 
 
12991 
  def __repr__(self):
12992 
    L = ['%s=%r' % (key, value)
12993 
      for key, value in self.__dict__.iteritems()]
12994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12995 
 
12996 
  def __eq__(self, other):
12997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12998 
 
12999 
  def __ne__(self, other):
13000 
    return not (self == other)
13001 
 
13002 
class addCampaign_args:
13003 
  """
13004 
  Attributes:
13005 
   - campaign
13006 
  """
13007 
 
13008 
  thrift_spec = (
13009 
    None, # 0
13010 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13011 
  )
13012 
 
13013 
  def __init__(self, campaign=None,):
13014 
    self.campaign = campaign
13015 
 
13016 
  def read(self, iprot):
13017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13019 
      return
13020 
    iprot.readStructBegin()
13021 
    while True:
13022 
      (fname, ftype, fid) = iprot.readFieldBegin()
13023 
      if ftype == TType.STOP:
13024 
        break
13025 
      if fid == 1:
13026 
        if ftype == TType.STRUCT:
13027 
          self.campaign = Campaign()
13028 
          self.campaign.read(iprot)
13029 
        else:
13030 
          iprot.skip(ftype)
13031 
      else:
13032 
        iprot.skip(ftype)
13033 
      iprot.readFieldEnd()
13034 
    iprot.readStructEnd()
13035 
 
13036 
  def write(self, oprot):
13037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13039 
      return
13040 
    oprot.writeStructBegin('addCampaign_args')
13041 
    if self.campaign is not None:
13042 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13043 
      self.campaign.write(oprot)
13044 
      oprot.writeFieldEnd()
13045 
    oprot.writeFieldStop()
13046 
    oprot.writeStructEnd()
13047 
 
13048 
  def validate(self):
13049 
    return
13050 
 
13051 
 
13052 
  def __repr__(self):
13053 
    L = ['%s=%r' % (key, value)
13054 
      for key, value in self.__dict__.iteritems()]
13055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13056 
 
13057 
  def __eq__(self, other):
13058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13059 
 
13060 
  def __ne__(self, other):
13061 
    return not (self == other)
13062 
 
13063 
class addCampaign_result:
13064 
 
13065 
  thrift_spec = (
13066 
  )
13067 
 
13068 
  def read(self, iprot):
13069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13071 
      return
13072 
    iprot.readStructBegin()
13073 
    while True:
13074 
      (fname, ftype, fid) = iprot.readFieldBegin()
13075 
      if ftype == TType.STOP:
13076 
        break
13077 
      else:
13078 
        iprot.skip(ftype)
13079 
      iprot.readFieldEnd()
13080 
    iprot.readStructEnd()
13081 
 
13082 
  def write(self, oprot):
13083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13085 
      return
13086 
    oprot.writeStructBegin('addCampaign_result')
13087 
    oprot.writeFieldStop()
13088 
    oprot.writeStructEnd()
13089 
 
13090 
  def validate(self):
13091 
    return
13092 
 
13093 
 
13094 
  def __repr__(self):
13095 
    L = ['%s=%r' % (key, value)
13096 
      for key, value in self.__dict__.iteritems()]
13097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13098 
 
13099 
  def __eq__(self, other):
13100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13101 
 
13102 
  def __ne__(self, other):
13103 
    return not (self == other)
13104 
 
13105 
class getCampaigns_args:
13106 
  """
13107 
  Attributes:
13108 
   - campaignName
13109 
  """
13110 
 
13111 
  thrift_spec = (
13112 
    None, # 0
13113 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13114 
  )
13115 
 
13116 
  def __init__(self, campaignName=None,):
13117 
    self.campaignName = campaignName
13118 
 
13119 
  def read(self, iprot):
13120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13122 
      return
13123 
    iprot.readStructBegin()
13124 
    while True:
13125 
      (fname, ftype, fid) = iprot.readFieldBegin()
13126 
      if ftype == TType.STOP:
13127 
        break
13128 
      if fid == 1:
13129 
        if ftype == TType.STRING:
13130 
          self.campaignName = iprot.readString();
13131 
        else:
13132 
          iprot.skip(ftype)
13133 
      else:
13134 
        iprot.skip(ftype)
13135 
      iprot.readFieldEnd()
13136 
    iprot.readStructEnd()
13137 
 
13138 
  def write(self, oprot):
13139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13141 
      return
13142 
    oprot.writeStructBegin('getCampaigns_args')
13143 
    if self.campaignName is not None:
13144 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13145 
      oprot.writeString(self.campaignName)
13146 
      oprot.writeFieldEnd()
13147 
    oprot.writeFieldStop()
13148 
    oprot.writeStructEnd()
13149 
 
13150 
  def validate(self):
13151 
    return
13152 
 
13153 
 
13154 
  def __repr__(self):
13155 
    L = ['%s=%r' % (key, value)
13156 
      for key, value in self.__dict__.iteritems()]
13157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13158 
 
13159 
  def __eq__(self, other):
13160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13161 
 
13162 
  def __ne__(self, other):
13163 
    return not (self == other)
13164 
 
13165 
class getCampaigns_result:
13166 
  """
13167 
  Attributes:
13168 
   - success
13169 
  """
13170 
 
13171 
  thrift_spec = (
13172 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13173 
  )
13174 
 
13175 
  def __init__(self, success=None,):
13176 
    self.success = success
13177 
 
13178 
  def read(self, iprot):
13179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13181 
      return
13182 
    iprot.readStructBegin()
13183 
    while True:
13184 
      (fname, ftype, fid) = iprot.readFieldBegin()
13185 
      if ftype == TType.STOP:
13186 
        break
13187 
      if fid == 0:
13188 
        if ftype == TType.LIST:
13189 
          self.success = []
13190 
          (_etype235, _size232) = iprot.readListBegin()
13191 
          for _i236 in xrange(_size232):
13192 
            _elem237 = Campaign()
13193 
            _elem237.read(iprot)
13194 
            self.success.append(_elem237)
13195 
          iprot.readListEnd()
13196 
        else:
13197 
          iprot.skip(ftype)
13198 
      else:
13199 
        iprot.skip(ftype)
13200 
      iprot.readFieldEnd()
13201 
    iprot.readStructEnd()
13202 
 
13203 
  def write(self, oprot):
13204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13206 
      return
13207 
    oprot.writeStructBegin('getCampaigns_result')
13208 
    if self.success is not None:
13209 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13210 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
13211 
      for iter238 in self.success:
13212 
        iter238.write(oprot)
13213 
      oprot.writeListEnd()
13214 
      oprot.writeFieldEnd()
13215 
    oprot.writeFieldStop()
13216 
    oprot.writeStructEnd()
13217 
 
13218 
  def validate(self):
13219 
    return
13220 
 
13221 
 
13222 
  def __repr__(self):
13223 
    L = ['%s=%r' % (key, value)
13224 
      for key, value in self.__dict__.iteritems()]
13225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13226 
 
13227 
  def __eq__(self, other):
13228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13229 
 
13230 
  def __ne__(self, other):
13231 
    return not (self == other)
13232 
 
13233 
class deleteCampaign_args:
13234 
  """
13235 
  Attributes:
13236 
   - campaignId
13237 
  """
13238 
 
13239 
  thrift_spec = (
13240 
    None, # 0
13241 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13242 
  )
13243 
 
13244 
  def __init__(self, campaignId=None,):
13245 
    self.campaignId = campaignId
13246 
 
13247 
  def read(self, iprot):
13248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13250 
      return
13251 
    iprot.readStructBegin()
13252 
    while True:
13253 
      (fname, ftype, fid) = iprot.readFieldBegin()
13254 
      if ftype == TType.STOP:
13255 
        break
13256 
      if fid == 1:
13257 
        if ftype == TType.I64:
13258 
          self.campaignId = iprot.readI64();
13259 
        else:
13260 
          iprot.skip(ftype)
13261 
      else:
13262 
        iprot.skip(ftype)
13263 
      iprot.readFieldEnd()
13264 
    iprot.readStructEnd()
13265 
 
13266 
  def write(self, oprot):
13267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13269 
      return
13270 
    oprot.writeStructBegin('deleteCampaign_args')
13271 
    if self.campaignId is not None:
13272 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13273 
      oprot.writeI64(self.campaignId)
13274 
      oprot.writeFieldEnd()
13275 
    oprot.writeFieldStop()
13276 
    oprot.writeStructEnd()
13277 
 
13278 
  def validate(self):
13279 
    return
13280 
 
13281 
 
13282 
  def __repr__(self):
13283 
    L = ['%s=%r' % (key, value)
13284 
      for key, value in self.__dict__.iteritems()]
13285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13286 
 
13287 
  def __eq__(self, other):
13288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13289 
 
13290 
  def __ne__(self, other):
13291 
    return not (self == other)
13292 
 
13293 
class deleteCampaign_result:
13294 
 
13295 
  thrift_spec = (
13296 
  )
13297 
 
13298 
  def read(self, iprot):
13299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13301 
      return
13302 
    iprot.readStructBegin()
13303 
    while True:
13304 
      (fname, ftype, fid) = iprot.readFieldBegin()
13305 
      if ftype == TType.STOP:
13306 
        break
13307 
      else:
13308 
        iprot.skip(ftype)
13309 
      iprot.readFieldEnd()
13310 
    iprot.readStructEnd()
13311 
 
13312 
  def write(self, oprot):
13313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13315 
      return
13316 
    oprot.writeStructBegin('deleteCampaign_result')
13317 
    oprot.writeFieldStop()
13318 
    oprot.writeStructEnd()
13319 
 
13320 
  def validate(self):
13321 
    return
13322 
 
13323 
 
13324 
  def __repr__(self):
13325 
    L = ['%s=%r' % (key, value)
13326 
      for key, value in self.__dict__.iteritems()]
13327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13328 
 
13329 
  def __eq__(self, other):
13330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13331 
 
13332 
  def __ne__(self, other):
13333 
    return not (self == other)
13334 
 
13335 
class getAllCampaigns_args:
13336 
 
13337 
  thrift_spec = (
13338 
  )
13339 
 
13340 
  def read(self, iprot):
13341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13343 
      return
13344 
    iprot.readStructBegin()
13345 
    while True:
13346 
      (fname, ftype, fid) = iprot.readFieldBegin()
13347 
      if ftype == TType.STOP:
13348 
        break
13349 
      else:
13350 
        iprot.skip(ftype)
13351 
      iprot.readFieldEnd()
13352 
    iprot.readStructEnd()
13353 
 
13354 
  def write(self, oprot):
13355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13357 
      return
13358 
    oprot.writeStructBegin('getAllCampaigns_args')
13359 
    oprot.writeFieldStop()
13360 
    oprot.writeStructEnd()
13361 
 
13362 
  def validate(self):
13363 
    return
13364 
 
13365 
 
13366 
  def __repr__(self):
13367 
    L = ['%s=%r' % (key, value)
13368 
      for key, value in self.__dict__.iteritems()]
13369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13370 
 
13371 
  def __eq__(self, other):
13372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13373 
 
13374 
  def __ne__(self, other):
13375 
    return not (self == other)
13376 
 
13377 
class getAllCampaigns_result:
13378 
  """
13379 
  Attributes:
13380 
   - success
13381 
  """
13382 
 
13383 
  thrift_spec = (
13384 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13385 
  )
13386 
 
13387 
  def __init__(self, success=None,):
13388 
    self.success = success
13389 
 
13390 
  def read(self, iprot):
13391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13393 
      return
13394 
    iprot.readStructBegin()
13395 
    while True:
13396 
      (fname, ftype, fid) = iprot.readFieldBegin()
13397 
      if ftype == TType.STOP:
13398 
        break
13399 
      if fid == 0:
13400 
        if ftype == TType.LIST:
13401 
          self.success = []
13402 
          (_etype242, _size239) = iprot.readListBegin()
13403 
          for _i243 in xrange(_size239):
13404 
            _elem244 = iprot.readString();
13405 
            self.success.append(_elem244)
13406 
          iprot.readListEnd()
13407 
        else:
13408 
          iprot.skip(ftype)
13409 
      else:
13410 
        iprot.skip(ftype)
13411 
      iprot.readFieldEnd()
13412 
    iprot.readStructEnd()
13413 
 
13414 
  def write(self, oprot):
13415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13417 
      return
13418 
    oprot.writeStructBegin('getAllCampaigns_result')
13419 
    if self.success is not None:
13420 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13421 
      oprot.writeListBegin(TType.STRING, len(self.success))
13422 
      for iter245 in self.success:
13423 
        oprot.writeString(iter245)
13424 
      oprot.writeListEnd()
13425 
      oprot.writeFieldEnd()
13426 
    oprot.writeFieldStop()
13427 
    oprot.writeStructEnd()
13428 
 
13429 
  def validate(self):
13430 
    return
13431 
 
13432 
 
13433 
  def __repr__(self):
13434 
    L = ['%s=%r' % (key, value)
13435 
      for key, value in self.__dict__.iteritems()]
13436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13437 
 
13438 
  def __eq__(self, other):
13439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13440 
 
13441 
  def __ne__(self, other):
13442 
    return not (self == other)
13443 
 
5944 mandeep.dh 13444 
class deleteSimilarItem_args:
13445 
  """
13446 
  Attributes:
13447 
   - itemId
13448 
   - catalogItemId
13449 
  """
13450 
 
13451 
  thrift_spec = (
13452 
    None, # 0
13453 
    (1, TType.I64, 'itemId', None, None, ), # 1
13454 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
13455 
  )
13456 
 
13457 
  def __init__(self, itemId=None, catalogItemId=None,):
13458 
    self.itemId = itemId
13459 
    self.catalogItemId = catalogItemId
13460 
 
13461 
  def read(self, iprot):
13462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13464 
      return
13465 
    iprot.readStructBegin()
13466 
    while True:
13467 
      (fname, ftype, fid) = iprot.readFieldBegin()
13468 
      if ftype == TType.STOP:
13469 
        break
13470 
      if fid == 1:
13471 
        if ftype == TType.I64:
13472 
          self.itemId = iprot.readI64();
13473 
        else:
13474 
          iprot.skip(ftype)
13475 
      elif fid == 2:
13476 
        if ftype == TType.I64:
13477 
          self.catalogItemId = iprot.readI64();
13478 
        else:
13479 
          iprot.skip(ftype)
13480 
      else:
13481 
        iprot.skip(ftype)
13482 
      iprot.readFieldEnd()
13483 
    iprot.readStructEnd()
13484 
 
13485 
  def write(self, oprot):
13486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13488 
      return
13489 
    oprot.writeStructBegin('deleteSimilarItem_args')
13490 
    if self.itemId is not None:
13491 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13492 
      oprot.writeI64(self.itemId)
13493 
      oprot.writeFieldEnd()
13494 
    if self.catalogItemId is not None:
13495 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
13496 
      oprot.writeI64(self.catalogItemId)
13497 
      oprot.writeFieldEnd()
13498 
    oprot.writeFieldStop()
13499 
    oprot.writeStructEnd()
13500 
 
13501 
  def validate(self):
13502 
    return
13503 
 
13504 
 
13505 
  def __repr__(self):
13506 
    L = ['%s=%r' % (key, value)
13507 
      for key, value in self.__dict__.iteritems()]
13508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13509 
 
13510 
  def __eq__(self, other):
13511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13512 
 
13513 
  def __ne__(self, other):
13514 
    return not (self == other)
13515 
 
13516 
class deleteSimilarItem_result:
13517 
  """
13518 
  Attributes:
13519 
   - success
13520 
   - cex
13521 
  """
13522 
 
13523 
  thrift_spec = (
13524 
    (0, TType.BOOL, 'success', None, None, ), # 0
13525 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13526 
  )
13527 
 
13528 
  def __init__(self, success=None, cex=None,):
13529 
    self.success = success
13530 
    self.cex = cex
13531 
 
13532 
  def read(self, iprot):
13533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13535 
      return
13536 
    iprot.readStructBegin()
13537 
    while True:
13538 
      (fname, ftype, fid) = iprot.readFieldBegin()
13539 
      if ftype == TType.STOP:
13540 
        break
13541 
      if fid == 0:
13542 
        if ftype == TType.BOOL:
13543 
          self.success = iprot.readBool();
13544 
        else:
13545 
          iprot.skip(ftype)
13546 
      elif fid == 1:
13547 
        if ftype == TType.STRUCT:
13548 
          self.cex = CatalogServiceException()
13549 
          self.cex.read(iprot)
13550 
        else:
13551 
          iprot.skip(ftype)
13552 
      else:
13553 
        iprot.skip(ftype)
13554 
      iprot.readFieldEnd()
13555 
    iprot.readStructEnd()
13556 
 
13557 
  def write(self, oprot):
13558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13560 
      return
13561 
    oprot.writeStructBegin('deleteSimilarItem_result')
13562 
    if self.success is not None:
13563 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13564 
      oprot.writeBool(self.success)
13565 
      oprot.writeFieldEnd()
13566 
    if self.cex is not None:
13567 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13568 
      self.cex.write(oprot)
13569 
      oprot.writeFieldEnd()
13570 
    oprot.writeFieldStop()
13571 
    oprot.writeStructEnd()
13572 
 
13573 
  def validate(self):
13574 
    return
13575 
 
13576 
 
13577 
  def __repr__(self):
13578 
    L = ['%s=%r' % (key, value)
13579 
      for key, value in self.__dict__.iteritems()]
13580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13581 
 
13582 
  def __eq__(self, other):
13583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13584 
 
13585 
  def __ne__(self, other):
13586 
    return not (self == other)
13587 
 
13588 
class checkSimilarItem_args:
13589 
  """
13590 
  Attributes:
13591 
   - brand
13592 
   - modelNumber
13593 
   - modelName
13594 
   - color
13595 
  """
13596 
 
13597 
  thrift_spec = (
13598 
    None, # 0
13599 
    (1, TType.STRING, 'brand', None, None, ), # 1
13600 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
13601 
    (3, TType.STRING, 'modelName', None, None, ), # 3
13602 
    (4, TType.STRING, 'color', None, None, ), # 4
13603 
  )
13604 
 
13605 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
13606 
    self.brand = brand
13607 
    self.modelNumber = modelNumber
13608 
    self.modelName = modelName
13609 
    self.color = color
13610 
 
13611 
  def read(self, iprot):
13612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13614 
      return
13615 
    iprot.readStructBegin()
13616 
    while True:
13617 
      (fname, ftype, fid) = iprot.readFieldBegin()
13618 
      if ftype == TType.STOP:
13619 
        break
13620 
      if fid == 1:
13621 
        if ftype == TType.STRING:
13622 
          self.brand = iprot.readString();
13623 
        else:
13624 
          iprot.skip(ftype)
13625 
      elif fid == 2:
13626 
        if ftype == TType.STRING:
13627 
          self.modelNumber = iprot.readString();
13628 
        else:
13629 
          iprot.skip(ftype)
13630 
      elif fid == 3:
13631 
        if ftype == TType.STRING:
13632 
          self.modelName = iprot.readString();
13633 
        else:
13634 
          iprot.skip(ftype)
13635 
      elif fid == 4:
13636 
        if ftype == TType.STRING:
13637 
          self.color = iprot.readString();
13638 
        else:
13639 
          iprot.skip(ftype)
13640 
      else:
13641 
        iprot.skip(ftype)
13642 
      iprot.readFieldEnd()
13643 
    iprot.readStructEnd()
13644 
 
13645 
  def write(self, oprot):
13646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13648 
      return
13649 
    oprot.writeStructBegin('checkSimilarItem_args')
13650 
    if self.brand is not None:
13651 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
13652 
      oprot.writeString(self.brand)
13653 
      oprot.writeFieldEnd()
13654 
    if self.modelNumber is not None:
13655 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
13656 
      oprot.writeString(self.modelNumber)
13657 
      oprot.writeFieldEnd()
13658 
    if self.modelName is not None:
13659 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
13660 
      oprot.writeString(self.modelName)
13661 
      oprot.writeFieldEnd()
13662 
    if self.color is not None:
13663 
      oprot.writeFieldBegin('color', TType.STRING, 4)
13664 
      oprot.writeString(self.color)
13665 
      oprot.writeFieldEnd()
13666 
    oprot.writeFieldStop()
13667 
    oprot.writeStructEnd()
13668 
 
13669 
  def validate(self):
13670 
    return
13671 
 
13672 
 
13673 
  def __repr__(self):
13674 
    L = ['%s=%r' % (key, value)
13675 
      for key, value in self.__dict__.iteritems()]
13676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13677 
 
13678 
  def __eq__(self, other):
13679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13680 
 
13681 
  def __ne__(self, other):
13682 
    return not (self == other)
13683 
 
13684 
class checkSimilarItem_result:
13685 
  """
13686 
  Attributes:
13687 
   - success
13688 
  """
13689 
 
13690 
  thrift_spec = (
13691 
    (0, TType.I64, 'success', None, None, ), # 0
13692 
  )
13693 
 
13694 
  def __init__(self, success=None,):
13695 
    self.success = success
13696 
 
13697 
  def read(self, iprot):
13698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13700 
      return
13701 
    iprot.readStructBegin()
13702 
    while True:
13703 
      (fname, ftype, fid) = iprot.readFieldBegin()
13704 
      if ftype == TType.STOP:
13705 
        break
13706 
      if fid == 0:
13707 
        if ftype == TType.I64:
13708 
          self.success = iprot.readI64();
13709 
        else:
13710 
          iprot.skip(ftype)
13711 
      else:
13712 
        iprot.skip(ftype)
13713 
      iprot.readFieldEnd()
13714 
    iprot.readStructEnd()
13715 
 
13716 
  def write(self, oprot):
13717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13719 
      return
13720 
    oprot.writeStructBegin('checkSimilarItem_result')
13721 
    if self.success is not None:
13722 
      oprot.writeFieldBegin('success', TType.I64, 0)
13723 
      oprot.writeI64(self.success)
13724 
      oprot.writeFieldEnd()
13725 
    oprot.writeFieldStop()
13726 
    oprot.writeStructEnd()
13727 
 
13728 
  def validate(self):
13729 
    return
13730 
 
13731 
 
13732 
  def __repr__(self):
13733 
    L = ['%s=%r' % (key, value)
13734 
      for key, value in self.__dict__.iteritems()]
13735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13736 
 
13737 
  def __eq__(self, other):
13738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13739 
 
13740 
  def __ne__(self, other):
13741 
    return not (self == other)
13742 
 
13743 
class validateRiskyStatus_args:
13744 
  """
13745 
  Attributes:
13746 
   - itemId
13747 
  """
13748 
 
13749 
  thrift_spec = (
13750 
    None, # 0
13751 
    (1, TType.I64, 'itemId', None, None, ), # 1
13752 
  )
13753 
 
13754 
  def __init__(self, itemId=None,):
13755 
    self.itemId = itemId
13756 
 
13757 
  def read(self, iprot):
13758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13760 
      return
13761 
    iprot.readStructBegin()
13762 
    while True:
13763 
      (fname, ftype, fid) = iprot.readFieldBegin()
13764 
      if ftype == TType.STOP:
13765 
        break
13766 
      if fid == 1:
13767 
        if ftype == TType.I64:
13768 
          self.itemId = iprot.readI64();
13769 
        else:
13770 
          iprot.skip(ftype)
13771 
      else:
13772 
        iprot.skip(ftype)
13773 
      iprot.readFieldEnd()
13774 
    iprot.readStructEnd()
13775 
 
13776 
  def write(self, oprot):
13777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13779 
      return
13780 
    oprot.writeStructBegin('validateRiskyStatus_args')
13781 
    if self.itemId is not None:
13782 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13783 
      oprot.writeI64(self.itemId)
13784 
      oprot.writeFieldEnd()
13785 
    oprot.writeFieldStop()
13786 
    oprot.writeStructEnd()
13787 
 
13788 
  def validate(self):
13789 
    return
13790 
 
13791 
 
13792 
  def __repr__(self):
13793 
    L = ['%s=%r' % (key, value)
13794 
      for key, value in self.__dict__.iteritems()]
13795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13796 
 
13797 
  def __eq__(self, other):
13798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13799 
 
13800 
  def __ne__(self, other):
13801 
    return not (self == other)
13802 
 
13803 
class validateRiskyStatus_result:
13804 
 
13805 
  thrift_spec = (
13806 
  )
13807 
 
13808 
  def read(self, iprot):
13809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13811 
      return
13812 
    iprot.readStructBegin()
13813 
    while True:
13814 
      (fname, ftype, fid) = iprot.readFieldBegin()
13815 
      if ftype == TType.STOP:
13816 
        break
13817 
      else:
13818 
        iprot.skip(ftype)
13819 
      iprot.readFieldEnd()
13820 
    iprot.readStructEnd()
13821 
 
13822 
  def write(self, oprot):
13823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13825 
      return
13826 
    oprot.writeStructBegin('validateRiskyStatus_result')
13827 
    oprot.writeFieldStop()
13828 
    oprot.writeStructEnd()
13829 
 
13830 
  def validate(self):
13831 
    return
13832 
 
13833 
 
13834 
  def __repr__(self):
13835 
    L = ['%s=%r' % (key, value)
13836 
      for key, value in self.__dict__.iteritems()]
13837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13838 
 
13839 
  def __eq__(self, other):
13840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13841 
 
13842 
  def __ne__(self, other):
13843 
    return not (self == other)
13844 
 
13845 
class changeItemRiskyFlag_args:
13846 
  """
13847 
  Attributes:
13848 
   - itemId
13849 
   - risky
13850 
  """
13851 
 
13852 
  thrift_spec = (
13853 
    None, # 0
13854 
    (1, TType.I64, 'itemId', None, None, ), # 1
13855 
    (2, TType.BOOL, 'risky', None, None, ), # 2
13856 
  )
13857 
 
13858 
  def __init__(self, itemId=None, risky=None,):
13859 
    self.itemId = itemId
13860 
    self.risky = risky
13861 
 
13862 
  def read(self, iprot):
13863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13865 
      return
13866 
    iprot.readStructBegin()
13867 
    while True:
13868 
      (fname, ftype, fid) = iprot.readFieldBegin()
13869 
      if ftype == TType.STOP:
13870 
        break
13871 
      if fid == 1:
13872 
        if ftype == TType.I64:
13873 
          self.itemId = iprot.readI64();
13874 
        else:
13875 
          iprot.skip(ftype)
13876 
      elif fid == 2:
13877 
        if ftype == TType.BOOL:
13878 
          self.risky = iprot.readBool();
13879 
        else:
13880 
          iprot.skip(ftype)
13881 
      else:
13882 
        iprot.skip(ftype)
13883 
      iprot.readFieldEnd()
13884 
    iprot.readStructEnd()
13885 
 
13886 
  def write(self, oprot):
13887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13889 
      return
13890 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
13891 
    if self.itemId is not None:
13892 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13893 
      oprot.writeI64(self.itemId)
13894 
      oprot.writeFieldEnd()
13895 
    if self.risky is not None:
13896 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
13897 
      oprot.writeBool(self.risky)
13898 
      oprot.writeFieldEnd()
13899 
    oprot.writeFieldStop()
13900 
    oprot.writeStructEnd()
13901 
 
13902 
  def validate(self):
13903 
    return
13904 
 
13905 
 
13906 
  def __repr__(self):
13907 
    L = ['%s=%r' % (key, value)
13908 
      for key, value in self.__dict__.iteritems()]
13909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13910 
 
13911 
  def __eq__(self, other):
13912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13913 
 
13914 
  def __ne__(self, other):
13915 
    return not (self == other)
13916 
 
13917 
class changeItemRiskyFlag_result:
13918 
 
13919 
  thrift_spec = (
13920 
  )
13921 
 
13922 
  def read(self, iprot):
13923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13925 
      return
13926 
    iprot.readStructBegin()
13927 
    while True:
13928 
      (fname, ftype, fid) = iprot.readFieldBegin()
13929 
      if ftype == TType.STOP:
13930 
        break
13931 
      else:
13932 
        iprot.skip(ftype)
13933 
      iprot.readFieldEnd()
13934 
    iprot.readStructEnd()
13935 
 
13936 
  def write(self, oprot):
13937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13939 
      return
13940 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
13941 
    oprot.writeFieldStop()
13942 
    oprot.writeStructEnd()
13943 
 
13944 
  def validate(self):
13945 
    return
13946 
 
13947 
 
13948 
  def __repr__(self):
13949 
    L = ['%s=%r' % (key, value)
13950 
      for key, value in self.__dict__.iteritems()]
13951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13952 
 
13953 
  def __eq__(self, other):
13954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13955 
 
13956 
  def __ne__(self, other):
13957 
    return not (self == other)
13958 
 
13959 
class getItemsByRiskyFlag_args:
13960 
 
13961 
  thrift_spec = (
13962 
  )
13963 
 
13964 
  def read(self, iprot):
13965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13967 
      return
13968 
    iprot.readStructBegin()
13969 
    while True:
13970 
      (fname, ftype, fid) = iprot.readFieldBegin()
13971 
      if ftype == TType.STOP:
13972 
        break
13973 
      else:
13974 
        iprot.skip(ftype)
13975 
      iprot.readFieldEnd()
13976 
    iprot.readStructEnd()
13977 
 
13978 
  def write(self, oprot):
13979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13981 
      return
13982 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
13983 
    oprot.writeFieldStop()
13984 
    oprot.writeStructEnd()
13985 
 
13986 
  def validate(self):
13987 
    return
13988 
 
13989 
 
13990 
  def __repr__(self):
13991 
    L = ['%s=%r' % (key, value)
13992 
      for key, value in self.__dict__.iteritems()]
13993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13994 
 
13995 
  def __eq__(self, other):
13996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13997 
 
13998 
  def __ne__(self, other):
13999 
    return not (self == other)
14000 
 
14001 
class getItemsByRiskyFlag_result:
14002 
  """
14003 
  Attributes:
14004 
   - success
14005 
  """
14006 
 
14007 
  thrift_spec = (
14008 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14009 
  )
14010 
 
14011 
  def __init__(self, success=None,):
14012 
    self.success = success
14013 
 
14014 
  def read(self, iprot):
14015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14017 
      return
14018 
    iprot.readStructBegin()
14019 
    while True:
14020 
      (fname, ftype, fid) = iprot.readFieldBegin()
14021 
      if ftype == TType.STOP:
14022 
        break
14023 
      if fid == 0:
14024 
        if ftype == TType.LIST:
14025 
          self.success = []
8579 kshitij.so 14026 
          (_etype249, _size246) = iprot.readListBegin()
14027 
          for _i250 in xrange(_size246):
14028 
            _elem251 = Item()
14029 
            _elem251.read(iprot)
14030 
            self.success.append(_elem251)
5944 mandeep.dh 14031 
          iprot.readListEnd()
14032 
        else:
14033 
          iprot.skip(ftype)
14034 
      else:
14035 
        iprot.skip(ftype)
14036 
      iprot.readFieldEnd()
14037 
    iprot.readStructEnd()
14038 
 
14039 
  def write(self, oprot):
14040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14042 
      return
14043 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14044 
    if self.success is not None:
14045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 14047 
      for iter252 in self.success:
14048 
        iter252.write(oprot)
5944 mandeep.dh 14049 
      oprot.writeListEnd()
14050 
      oprot.writeFieldEnd()
14051 
    oprot.writeFieldStop()
14052 
    oprot.writeStructEnd()
14053 
 
14054 
  def validate(self):
14055 
    return
14056 
 
14057 
 
14058 
  def __repr__(self):
14059 
    L = ['%s=%r' % (key, value)
14060 
      for key, value in self.__dict__.iteritems()]
14061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14062 
 
14063 
  def __eq__(self, other):
14064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14065 
 
14066 
  def __ne__(self, other):
14067 
    return not (self == other)
14068 
 
14069 
class getItemsForMasterSheet_args:
14070 
  """
14071 
  Attributes:
14072 
   - category
14073 
   - brand
14074 
  """
14075 
 
14076 
  thrift_spec = (
14077 
    None, # 0
14078 
    (1, TType.STRING, 'category', None, None, ), # 1
14079 
    (2, TType.STRING, 'brand', None, None, ), # 2
14080 
  )
14081 
 
14082 
  def __init__(self, category=None, brand=None,):
14083 
    self.category = category
14084 
    self.brand = brand
14085 
 
14086 
  def read(self, iprot):
14087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14089 
      return
14090 
    iprot.readStructBegin()
14091 
    while True:
14092 
      (fname, ftype, fid) = iprot.readFieldBegin()
14093 
      if ftype == TType.STOP:
14094 
        break
14095 
      if fid == 1:
14096 
        if ftype == TType.STRING:
14097 
          self.category = iprot.readString();
14098 
        else:
14099 
          iprot.skip(ftype)
14100 
      elif fid == 2:
14101 
        if ftype == TType.STRING:
14102 
          self.brand = iprot.readString();
14103 
        else:
14104 
          iprot.skip(ftype)
14105 
      else:
14106 
        iprot.skip(ftype)
14107 
      iprot.readFieldEnd()
14108 
    iprot.readStructEnd()
14109 
 
14110 
  def write(self, oprot):
14111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14113 
      return
14114 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14115 
    if self.category is not None:
14116 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14117 
      oprot.writeString(self.category)
14118 
      oprot.writeFieldEnd()
14119 
    if self.brand is not None:
14120 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14121 
      oprot.writeString(self.brand)
14122 
      oprot.writeFieldEnd()
14123 
    oprot.writeFieldStop()
14124 
    oprot.writeStructEnd()
14125 
 
14126 
  def validate(self):
14127 
    return
14128 
 
14129 
 
14130 
  def __repr__(self):
14131 
    L = ['%s=%r' % (key, value)
14132 
      for key, value in self.__dict__.iteritems()]
14133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14134 
 
14135 
  def __eq__(self, other):
14136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14137 
 
14138 
  def __ne__(self, other):
14139 
    return not (self == other)
14140 
 
14141 
class getItemsForMasterSheet_result:
14142 
  """
14143 
  Attributes:
14144 
   - success
14145 
  """
14146 
 
14147 
  thrift_spec = (
14148 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14149 
  )
14150 
 
14151 
  def __init__(self, success=None,):
14152 
    self.success = success
14153 
 
14154 
  def read(self, iprot):
14155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14157 
      return
14158 
    iprot.readStructBegin()
14159 
    while True:
14160 
      (fname, ftype, fid) = iprot.readFieldBegin()
14161 
      if ftype == TType.STOP:
14162 
        break
14163 
      if fid == 0:
14164 
        if ftype == TType.LIST:
14165 
          self.success = []
8579 kshitij.so 14166 
          (_etype256, _size253) = iprot.readListBegin()
14167 
          for _i257 in xrange(_size253):
14168 
            _elem258 = Item()
14169 
            _elem258.read(iprot)
14170 
            self.success.append(_elem258)
5944 mandeep.dh 14171 
          iprot.readListEnd()
14172 
        else:
14173 
          iprot.skip(ftype)
14174 
      else:
14175 
        iprot.skip(ftype)
14176 
      iprot.readFieldEnd()
14177 
    iprot.readStructEnd()
14178 
 
14179 
  def write(self, oprot):
14180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14182 
      return
14183 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14184 
    if self.success is not None:
14185 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14186 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 14187 
      for iter259 in self.success:
14188 
        iter259.write(oprot)
5944 mandeep.dh 14189 
      oprot.writeListEnd()
14190 
      oprot.writeFieldEnd()
14191 
    oprot.writeFieldStop()
14192 
    oprot.writeStructEnd()
14193 
 
14194 
  def validate(self):
14195 
    return
14196 
 
14197 
 
14198 
  def __repr__(self):
14199 
    L = ['%s=%r' % (key, value)
14200 
      for key, value in self.__dict__.iteritems()]
14201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14202 
 
14203 
  def __eq__(self, other):
14204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14205 
 
14206 
  def __ne__(self, other):
14207 
    return not (self == other)
14208 
 
14209 
class getSimilarItemsCatalogIds_args:
14210 
  """
14211 
  Attributes:
14212 
   - beginIndex
14213 
   - totalItems
14214 
   - itemId
14215 
  """
14216 
 
14217 
  thrift_spec = (
14218 
    None, # 0
14219 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
14220 
    (2, TType.I64, 'totalItems', None, None, ), # 2
14221 
    (3, TType.I64, 'itemId', None, None, ), # 3
14222 
  )
14223 
 
14224 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
14225 
    self.beginIndex = beginIndex
14226 
    self.totalItems = totalItems
14227 
    self.itemId = itemId
14228 
 
14229 
  def read(self, iprot):
14230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14232 
      return
14233 
    iprot.readStructBegin()
14234 
    while True:
14235 
      (fname, ftype, fid) = iprot.readFieldBegin()
14236 
      if ftype == TType.STOP:
14237 
        break
14238 
      if fid == 1:
14239 
        if ftype == TType.I64:
14240 
          self.beginIndex = iprot.readI64();
14241 
        else:
14242 
          iprot.skip(ftype)
14243 
      elif fid == 2:
14244 
        if ftype == TType.I64:
14245 
          self.totalItems = iprot.readI64();
14246 
        else:
14247 
          iprot.skip(ftype)
14248 
      elif fid == 3:
14249 
        if ftype == TType.I64:
14250 
          self.itemId = iprot.readI64();
14251 
        else:
14252 
          iprot.skip(ftype)
14253 
      else:
14254 
        iprot.skip(ftype)
14255 
      iprot.readFieldEnd()
14256 
    iprot.readStructEnd()
14257 
 
14258 
  def write(self, oprot):
14259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14261 
      return
14262 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
14263 
    if self.beginIndex is not None:
14264 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
14265 
      oprot.writeI64(self.beginIndex)
14266 
      oprot.writeFieldEnd()
14267 
    if self.totalItems is not None:
14268 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
14269 
      oprot.writeI64(self.totalItems)
14270 
      oprot.writeFieldEnd()
14271 
    if self.itemId is not None:
14272 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
14273 
      oprot.writeI64(self.itemId)
14274 
      oprot.writeFieldEnd()
14275 
    oprot.writeFieldStop()
14276 
    oprot.writeStructEnd()
14277 
 
14278 
  def validate(self):
14279 
    return
14280 
 
14281 
 
14282 
  def __repr__(self):
14283 
    L = ['%s=%r' % (key, value)
14284 
      for key, value in self.__dict__.iteritems()]
14285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14286 
 
14287 
  def __eq__(self, other):
14288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14289 
 
14290 
  def __ne__(self, other):
14291 
    return not (self == other)
14292 
 
14293 
class getSimilarItemsCatalogIds_result:
14294 
  """
14295 
  Attributes:
14296 
   - success
14297 
  """
14298 
 
14299 
  thrift_spec = (
14300 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14301 
  )
14302 
 
14303 
  def __init__(self, success=None,):
14304 
    self.success = success
14305 
 
14306 
  def read(self, iprot):
14307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14309 
      return
14310 
    iprot.readStructBegin()
14311 
    while True:
14312 
      (fname, ftype, fid) = iprot.readFieldBegin()
14313 
      if ftype == TType.STOP:
14314 
        break
14315 
      if fid == 0:
14316 
        if ftype == TType.LIST:
14317 
          self.success = []
8579 kshitij.so 14318 
          (_etype263, _size260) = iprot.readListBegin()
14319 
          for _i264 in xrange(_size260):
14320 
            _elem265 = iprot.readI64();
14321 
            self.success.append(_elem265)
5944 mandeep.dh 14322 
          iprot.readListEnd()
14323 
        else:
14324 
          iprot.skip(ftype)
14325 
      else:
14326 
        iprot.skip(ftype)
14327 
      iprot.readFieldEnd()
14328 
    iprot.readStructEnd()
14329 
 
14330 
  def write(self, oprot):
14331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14333 
      return
14334 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
14335 
    if self.success is not None:
14336 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14337 
      oprot.writeListBegin(TType.I64, len(self.success))
8579 kshitij.so 14338 
      for iter266 in self.success:
14339 
        oprot.writeI64(iter266)
5944 mandeep.dh 14340 
      oprot.writeListEnd()
14341 
      oprot.writeFieldEnd()
14342 
    oprot.writeFieldStop()
14343 
    oprot.writeStructEnd()
14344 
 
14345 
  def validate(self):
14346 
    return
14347 
 
14348 
 
14349 
  def __repr__(self):
14350 
    L = ['%s=%r' % (key, value)
14351 
      for key, value in self.__dict__.iteritems()]
14352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14353 
 
14354 
  def __eq__(self, other):
14355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14356 
 
14357 
  def __ne__(self, other):
14358 
    return not (self == other)
14359 
 
14360 
class addProductNotification_args:
14361 
  """
14362 
  Attributes:
14363 
   - itemId
14364 
   - email
14365 
  """
14366 
 
14367 
  thrift_spec = None
14368 
  def __init__(self, itemId=None, email=None,):
14369 
    self.itemId = itemId
14370 
    self.email = email
14371 
 
14372 
  def read(self, iprot):
14373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14375 
      return
14376 
    iprot.readStructBegin()
14377 
    while True:
14378 
      (fname, ftype, fid) = iprot.readFieldBegin()
14379 
      if ftype == TType.STOP:
14380 
        break
14381 
      if fid == -1:
14382 
        if ftype == TType.I64:
14383 
          self.itemId = iprot.readI64();
14384 
        else:
14385 
          iprot.skip(ftype)
14386 
      elif fid == -2:
14387 
        if ftype == TType.STRING:
14388 
          self.email = iprot.readString();
14389 
        else:
14390 
          iprot.skip(ftype)
14391 
      else:
14392 
        iprot.skip(ftype)
14393 
      iprot.readFieldEnd()
14394 
    iprot.readStructEnd()
14395 
 
14396 
  def write(self, oprot):
14397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14399 
      return
14400 
    oprot.writeStructBegin('addProductNotification_args')
14401 
    if self.email is not None:
14402 
      oprot.writeFieldBegin('email', TType.STRING, -2)
14403 
      oprot.writeString(self.email)
14404 
      oprot.writeFieldEnd()
14405 
    if self.itemId is not None:
14406 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
14407 
      oprot.writeI64(self.itemId)
14408 
      oprot.writeFieldEnd()
14409 
    oprot.writeFieldStop()
14410 
    oprot.writeStructEnd()
14411 
 
14412 
  def validate(self):
14413 
    return
14414 
 
14415 
 
14416 
  def __repr__(self):
14417 
    L = ['%s=%r' % (key, value)
14418 
      for key, value in self.__dict__.iteritems()]
14419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14420 
 
14421 
  def __eq__(self, other):
14422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14423 
 
14424 
  def __ne__(self, other):
14425 
    return not (self == other)
14426 
 
14427 
class addProductNotification_result:
14428 
  """
14429 
  Attributes:
14430 
   - success
14431 
  """
14432 
 
14433 
  thrift_spec = (
14434 
    (0, TType.BOOL, 'success', None, None, ), # 0
14435 
  )
14436 
 
14437 
  def __init__(self, success=None,):
14438 
    self.success = success
14439 
 
14440 
  def read(self, iprot):
14441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14443 
      return
14444 
    iprot.readStructBegin()
14445 
    while True:
14446 
      (fname, ftype, fid) = iprot.readFieldBegin()
14447 
      if ftype == TType.STOP:
14448 
        break
14449 
      if fid == 0:
14450 
        if ftype == TType.BOOL:
14451 
          self.success = iprot.readBool();
14452 
        else:
14453 
          iprot.skip(ftype)
14454 
      else:
14455 
        iprot.skip(ftype)
14456 
      iprot.readFieldEnd()
14457 
    iprot.readStructEnd()
14458 
 
14459 
  def write(self, oprot):
14460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14462 
      return
14463 
    oprot.writeStructBegin('addProductNotification_result')
14464 
    if self.success is not None:
14465 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14466 
      oprot.writeBool(self.success)
14467 
      oprot.writeFieldEnd()
14468 
    oprot.writeFieldStop()
14469 
    oprot.writeStructEnd()
14470 
 
14471 
  def validate(self):
14472 
    return
14473 
 
14474 
 
14475 
  def __repr__(self):
14476 
    L = ['%s=%r' % (key, value)
14477 
      for key, value in self.__dict__.iteritems()]
14478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14479 
 
14480 
  def __eq__(self, other):
14481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14482 
 
14483 
  def __ne__(self, other):
14484 
    return not (self == other)
14485 
 
14486 
class sendProductNotifications_args:
14487 
 
14488 
  thrift_spec = (
14489 
  )
14490 
 
14491 
  def read(self, iprot):
14492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14494 
      return
14495 
    iprot.readStructBegin()
14496 
    while True:
14497 
      (fname, ftype, fid) = iprot.readFieldBegin()
14498 
      if ftype == TType.STOP:
14499 
        break
14500 
      else:
14501 
        iprot.skip(ftype)
14502 
      iprot.readFieldEnd()
14503 
    iprot.readStructEnd()
14504 
 
14505 
  def write(self, oprot):
14506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14508 
      return
14509 
    oprot.writeStructBegin('sendProductNotifications_args')
14510 
    oprot.writeFieldStop()
14511 
    oprot.writeStructEnd()
14512 
 
14513 
  def validate(self):
14514 
    return
14515 
 
14516 
 
14517 
  def __repr__(self):
14518 
    L = ['%s=%r' % (key, value)
14519 
      for key, value in self.__dict__.iteritems()]
14520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14521 
 
14522 
  def __eq__(self, other):
14523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14524 
 
14525 
  def __ne__(self, other):
14526 
    return not (self == other)
14527 
 
14528 
class sendProductNotifications_result:
14529 
  """
14530 
  Attributes:
14531 
   - success
14532 
  """
14533 
 
14534 
  thrift_spec = (
14535 
    (0, TType.BOOL, 'success', None, None, ), # 0
14536 
  )
14537 
 
14538 
  def __init__(self, success=None,):
14539 
    self.success = success
14540 
 
14541 
  def read(self, iprot):
14542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14544 
      return
14545 
    iprot.readStructBegin()
14546 
    while True:
14547 
      (fname, ftype, fid) = iprot.readFieldBegin()
14548 
      if ftype == TType.STOP:
14549 
        break
14550 
      if fid == 0:
14551 
        if ftype == TType.BOOL:
14552 
          self.success = iprot.readBool();
14553 
        else:
14554 
          iprot.skip(ftype)
14555 
      else:
14556 
        iprot.skip(ftype)
14557 
      iprot.readFieldEnd()
14558 
    iprot.readStructEnd()
14559 
 
14560 
  def write(self, oprot):
14561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14563 
      return
14564 
    oprot.writeStructBegin('sendProductNotifications_result')
14565 
    if self.success is not None:
14566 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14567 
      oprot.writeBool(self.success)
14568 
      oprot.writeFieldEnd()
14569 
    oprot.writeFieldStop()
14570 
    oprot.writeStructEnd()
14571 
 
14572 
  def validate(self):
14573 
    return
14574 
 
14575 
 
14576 
  def __repr__(self):
14577 
    L = ['%s=%r' % (key, value)
14578 
      for key, value in self.__dict__.iteritems()]
14579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14580 
 
14581 
  def __eq__(self, other):
14582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14583 
 
14584 
  def __ne__(self, other):
14585 
    return not (self == other)
14586 
 
14587 
class getAllBrandsByCategory_args:
14588 
  """
14589 
  Attributes:
14590 
   - categoryId
14591 
  """
14592 
 
14593 
  thrift_spec = (
14594 
    None, # 0
14595 
    (1, TType.I64, 'categoryId', None, None, ), # 1
14596 
  )
14597 
 
14598 
  def __init__(self, categoryId=None,):
14599 
    self.categoryId = categoryId
14600 
 
14601 
  def read(self, iprot):
14602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14604 
      return
14605 
    iprot.readStructBegin()
14606 
    while True:
14607 
      (fname, ftype, fid) = iprot.readFieldBegin()
14608 
      if ftype == TType.STOP:
14609 
        break
14610 
      if fid == 1:
14611 
        if ftype == TType.I64:
14612 
          self.categoryId = iprot.readI64();
14613 
        else:
14614 
          iprot.skip(ftype)
14615 
      else:
14616 
        iprot.skip(ftype)
14617 
      iprot.readFieldEnd()
14618 
    iprot.readStructEnd()
14619 
 
14620 
  def write(self, oprot):
14621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14623 
      return
14624 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
14625 
    if self.categoryId is not None:
14626 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
14627 
      oprot.writeI64(self.categoryId)
14628 
      oprot.writeFieldEnd()
14629 
    oprot.writeFieldStop()
14630 
    oprot.writeStructEnd()
14631 
 
14632 
  def validate(self):
14633 
    return
14634 
 
14635 
 
14636 
  def __repr__(self):
14637 
    L = ['%s=%r' % (key, value)
14638 
      for key, value in self.__dict__.iteritems()]
14639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14640 
 
14641 
  def __eq__(self, other):
14642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14643 
 
14644 
  def __ne__(self, other):
14645 
    return not (self == other)
14646 
 
14647 
class getAllBrandsByCategory_result:
14648 
  """
14649 
  Attributes:
14650 
   - success
14651 
  """
14652 
 
14653 
  thrift_spec = (
14654 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14655 
  )
14656 
 
14657 
  def __init__(self, success=None,):
14658 
    self.success = success
14659 
 
14660 
  def read(self, iprot):
14661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14663 
      return
14664 
    iprot.readStructBegin()
14665 
    while True:
14666 
      (fname, ftype, fid) = iprot.readFieldBegin()
14667 
      if ftype == TType.STOP:
14668 
        break
14669 
      if fid == 0:
14670 
        if ftype == TType.LIST:
14671 
          self.success = []
8579 kshitij.so 14672 
          (_etype270, _size267) = iprot.readListBegin()
14673 
          for _i271 in xrange(_size267):
14674 
            _elem272 = iprot.readString();
14675 
            self.success.append(_elem272)
5944 mandeep.dh 14676 
          iprot.readListEnd()
14677 
        else:
14678 
          iprot.skip(ftype)
14679 
      else:
14680 
        iprot.skip(ftype)
14681 
      iprot.readFieldEnd()
14682 
    iprot.readStructEnd()
14683 
 
14684 
  def write(self, oprot):
14685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14687 
      return
14688 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
14689 
    if self.success is not None:
14690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14691 
      oprot.writeListBegin(TType.STRING, len(self.success))
8579 kshitij.so 14692 
      for iter273 in self.success:
14693 
        oprot.writeString(iter273)
5944 mandeep.dh 14694 
      oprot.writeListEnd()
14695 
      oprot.writeFieldEnd()
14696 
    oprot.writeFieldStop()
14697 
    oprot.writeStructEnd()
14698 
 
14699 
  def validate(self):
14700 
    return
14701 
 
14702 
 
14703 
  def __repr__(self):
14704 
    L = ['%s=%r' % (key, value)
14705 
      for key, value in self.__dict__.iteritems()]
14706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14707 
 
14708 
  def __eq__(self, other):
14709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14710 
 
14711 
  def __ne__(self, other):
14712 
    return not (self == other)
14713 
 
14714 
class getAllBrands_args:
14715 
 
14716 
  thrift_spec = (
14717 
  )
14718 
 
14719 
  def read(self, iprot):
14720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14722 
      return
14723 
    iprot.readStructBegin()
14724 
    while True:
14725 
      (fname, ftype, fid) = iprot.readFieldBegin()
14726 
      if ftype == TType.STOP:
14727 
        break
14728 
      else:
14729 
        iprot.skip(ftype)
14730 
      iprot.readFieldEnd()
14731 
    iprot.readStructEnd()
14732 
 
14733 
  def write(self, oprot):
14734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14736 
      return
14737 
    oprot.writeStructBegin('getAllBrands_args')
14738 
    oprot.writeFieldStop()
14739 
    oprot.writeStructEnd()
14740 
 
14741 
  def validate(self):
14742 
    return
14743 
 
14744 
 
14745 
  def __repr__(self):
14746 
    L = ['%s=%r' % (key, value)
14747 
      for key, value in self.__dict__.iteritems()]
14748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14749 
 
14750 
  def __eq__(self, other):
14751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14752 
 
14753 
  def __ne__(self, other):
14754 
    return not (self == other)
14755 
 
14756 
class getAllBrands_result:
14757 
  """
14758 
  Attributes:
14759 
   - success
14760 
  """
14761 
 
14762 
  thrift_spec = (
14763 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14764 
  )
14765 
 
14766 
  def __init__(self, success=None,):
14767 
    self.success = success
14768 
 
14769 
  def read(self, iprot):
14770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14772 
      return
14773 
    iprot.readStructBegin()
14774 
    while True:
14775 
      (fname, ftype, fid) = iprot.readFieldBegin()
14776 
      if ftype == TType.STOP:
14777 
        break
14778 
      if fid == 0:
14779 
        if ftype == TType.LIST:
14780 
          self.success = []
8579 kshitij.so 14781 
          (_etype277, _size274) = iprot.readListBegin()
14782 
          for _i278 in xrange(_size274):
14783 
            _elem279 = iprot.readString();
14784 
            self.success.append(_elem279)
5944 mandeep.dh 14785 
          iprot.readListEnd()
14786 
        else:
14787 
          iprot.skip(ftype)
14788 
      else:
14789 
        iprot.skip(ftype)
14790 
      iprot.readFieldEnd()
14791 
    iprot.readStructEnd()
14792 
 
14793 
  def write(self, oprot):
14794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14796 
      return
14797 
    oprot.writeStructBegin('getAllBrands_result')
14798 
    if self.success is not None:
14799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14800 
      oprot.writeListBegin(TType.STRING, len(self.success))
8579 kshitij.so 14801 
      for iter280 in self.success:
14802 
        oprot.writeString(iter280)
5944 mandeep.dh 14803 
      oprot.writeListEnd()
14804 
      oprot.writeFieldEnd()
14805 
    oprot.writeFieldStop()
14806 
    oprot.writeStructEnd()
14807 
 
14808 
  def validate(self):
14809 
    return
14810 
 
14811 
 
14812 
  def __repr__(self):
14813 
    L = ['%s=%r' % (key, value)
14814 
      for key, value in self.__dict__.iteritems()]
14815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14816 
 
14817 
  def __eq__(self, other):
14818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14819 
 
14820 
  def __ne__(self, other):
14821 
    return not (self == other)
14822 
 
14823 
class getAllSources_args:
14824 
 
14825 
  thrift_spec = (
14826 
  )
14827 
 
14828 
  def read(self, iprot):
14829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14831 
      return
14832 
    iprot.readStructBegin()
14833 
    while True:
14834 
      (fname, ftype, fid) = iprot.readFieldBegin()
14835 
      if ftype == TType.STOP:
14836 
        break
14837 
      else:
14838 
        iprot.skip(ftype)
14839 
      iprot.readFieldEnd()
14840 
    iprot.readStructEnd()
14841 
 
14842 
  def write(self, oprot):
14843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14845 
      return
14846 
    oprot.writeStructBegin('getAllSources_args')
14847 
    oprot.writeFieldStop()
14848 
    oprot.writeStructEnd()
14849 
 
14850 
  def validate(self):
14851 
    return
14852 
 
14853 
 
14854 
  def __repr__(self):
14855 
    L = ['%s=%r' % (key, value)
14856 
      for key, value in self.__dict__.iteritems()]
14857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14858 
 
14859 
  def __eq__(self, other):
14860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14861 
 
14862 
  def __ne__(self, other):
14863 
    return not (self == other)
14864 
 
14865 
class getAllSources_result:
14866 
  """
14867 
  Attributes:
14868 
   - success
14869 
  """
14870 
 
14871 
  thrift_spec = (
14872 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
14873 
  )
14874 
 
14875 
  def __init__(self, success=None,):
14876 
    self.success = success
14877 
 
14878 
  def read(self, iprot):
14879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14881 
      return
14882 
    iprot.readStructBegin()
14883 
    while True:
14884 
      (fname, ftype, fid) = iprot.readFieldBegin()
14885 
      if ftype == TType.STOP:
14886 
        break
14887 
      if fid == 0:
14888 
        if ftype == TType.LIST:
14889 
          self.success = []
8579 kshitij.so 14890 
          (_etype284, _size281) = iprot.readListBegin()
14891 
          for _i285 in xrange(_size281):
14892 
            _elem286 = Source()
14893 
            _elem286.read(iprot)
14894 
            self.success.append(_elem286)
5944 mandeep.dh 14895 
          iprot.readListEnd()
14896 
        else:
14897 
          iprot.skip(ftype)
14898 
      else:
14899 
        iprot.skip(ftype)
14900 
      iprot.readFieldEnd()
14901 
    iprot.readStructEnd()
14902 
 
14903 
  def write(self, oprot):
14904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14906 
      return
14907 
    oprot.writeStructBegin('getAllSources_result')
14908 
    if self.success is not None:
14909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 14911 
      for iter287 in self.success:
14912 
        iter287.write(oprot)
5944 mandeep.dh 14913 
      oprot.writeListEnd()
14914 
      oprot.writeFieldEnd()
14915 
    oprot.writeFieldStop()
14916 
    oprot.writeStructEnd()
14917 
 
14918 
  def validate(self):
14919 
    return
14920 
 
14921 
 
14922 
  def __repr__(self):
14923 
    L = ['%s=%r' % (key, value)
14924 
      for key, value in self.__dict__.iteritems()]
14925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14926 
 
14927 
  def __eq__(self, other):
14928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14929 
 
14930 
  def __ne__(self, other):
14931 
    return not (self == other)
14932 
 
14933 
class getItemPricingBySource_args:
14934 
  """
14935 
  Attributes:
14936 
   - itemId
14937 
   - sourceId
14938 
  """
14939 
 
14940 
  thrift_spec = (
14941 
    None, # 0
14942 
    (1, TType.I64, 'itemId', None, None, ), # 1
14943 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14944 
  )
14945 
 
14946 
  def __init__(self, itemId=None, sourceId=None,):
14947 
    self.itemId = itemId
14948 
    self.sourceId = sourceId
14949 
 
14950 
  def read(self, iprot):
14951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14953 
      return
14954 
    iprot.readStructBegin()
14955 
    while True:
14956 
      (fname, ftype, fid) = iprot.readFieldBegin()
14957 
      if ftype == TType.STOP:
14958 
        break
14959 
      if fid == 1:
14960 
        if ftype == TType.I64:
14961 
          self.itemId = iprot.readI64();
14962 
        else:
14963 
          iprot.skip(ftype)
14964 
      elif fid == 2:
14965 
        if ftype == TType.I64:
14966 
          self.sourceId = iprot.readI64();
14967 
        else:
14968 
          iprot.skip(ftype)
14969 
      else:
14970 
        iprot.skip(ftype)
14971 
      iprot.readFieldEnd()
14972 
    iprot.readStructEnd()
14973 
 
14974 
  def write(self, oprot):
14975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14977 
      return
14978 
    oprot.writeStructBegin('getItemPricingBySource_args')
14979 
    if self.itemId is not None:
14980 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14981 
      oprot.writeI64(self.itemId)
14982 
      oprot.writeFieldEnd()
14983 
    if self.sourceId is not None:
14984 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14985 
      oprot.writeI64(self.sourceId)
14986 
      oprot.writeFieldEnd()
14987 
    oprot.writeFieldStop()
14988 
    oprot.writeStructEnd()
14989 
 
14990 
  def validate(self):
14991 
    return
14992 
 
14993 
 
14994 
  def __repr__(self):
14995 
    L = ['%s=%r' % (key, value)
14996 
      for key, value in self.__dict__.iteritems()]
14997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14998 
 
14999 
  def __eq__(self, other):
15000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15001 
 
15002 
  def __ne__(self, other):
15003 
    return not (self == other)
15004 
 
15005 
class getItemPricingBySource_result:
15006 
  """
15007 
  Attributes:
15008 
   - success
15009 
   - cex
15010 
  """
15011 
 
15012 
  thrift_spec = (
15013 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15014 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15015 
  )
15016 
 
15017 
  def __init__(self, success=None, cex=None,):
15018 
    self.success = success
15019 
    self.cex = cex
15020 
 
15021 
  def read(self, iprot):
15022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15024 
      return
15025 
    iprot.readStructBegin()
15026 
    while True:
15027 
      (fname, ftype, fid) = iprot.readFieldBegin()
15028 
      if ftype == TType.STOP:
15029 
        break
15030 
      if fid == 0:
15031 
        if ftype == TType.STRUCT:
15032 
          self.success = SourceItemPricing()
15033 
          self.success.read(iprot)
15034 
        else:
15035 
          iprot.skip(ftype)
15036 
      elif fid == 1:
15037 
        if ftype == TType.STRUCT:
15038 
          self.cex = CatalogServiceException()
15039 
          self.cex.read(iprot)
15040 
        else:
15041 
          iprot.skip(ftype)
15042 
      else:
15043 
        iprot.skip(ftype)
15044 
      iprot.readFieldEnd()
15045 
    iprot.readStructEnd()
15046 
 
15047 
  def write(self, oprot):
15048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15050 
      return
15051 
    oprot.writeStructBegin('getItemPricingBySource_result')
15052 
    if self.success is not None:
15053 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15054 
      self.success.write(oprot)
15055 
      oprot.writeFieldEnd()
15056 
    if self.cex is not None:
15057 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15058 
      self.cex.write(oprot)
15059 
      oprot.writeFieldEnd()
15060 
    oprot.writeFieldStop()
15061 
    oprot.writeStructEnd()
15062 
 
15063 
  def validate(self):
15064 
    return
15065 
 
15066 
 
15067 
  def __repr__(self):
15068 
    L = ['%s=%r' % (key, value)
15069 
      for key, value in self.__dict__.iteritems()]
15070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15071 
 
15072 
  def __eq__(self, other):
15073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15074 
 
15075 
  def __ne__(self, other):
15076 
    return not (self == other)
15077 
 
15078 
class addSourceItemPricing_args:
15079 
  """
15080 
  Attributes:
15081 
   - sourceItemPricing
15082 
  """
15083 
 
15084 
  thrift_spec = (
15085 
    None, # 0
15086 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15087 
  )
15088 
 
15089 
  def __init__(self, sourceItemPricing=None,):
15090 
    self.sourceItemPricing = sourceItemPricing
15091 
 
15092 
  def read(self, iprot):
15093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15095 
      return
15096 
    iprot.readStructBegin()
15097 
    while True:
15098 
      (fname, ftype, fid) = iprot.readFieldBegin()
15099 
      if ftype == TType.STOP:
15100 
        break
15101 
      if fid == 1:
15102 
        if ftype == TType.STRUCT:
15103 
          self.sourceItemPricing = SourceItemPricing()
15104 
          self.sourceItemPricing.read(iprot)
15105 
        else:
15106 
          iprot.skip(ftype)
15107 
      else:
15108 
        iprot.skip(ftype)
15109 
      iprot.readFieldEnd()
15110 
    iprot.readStructEnd()
15111 
 
15112 
  def write(self, oprot):
15113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15115 
      return
15116 
    oprot.writeStructBegin('addSourceItemPricing_args')
15117 
    if self.sourceItemPricing is not None:
15118 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15119 
      self.sourceItemPricing.write(oprot)
15120 
      oprot.writeFieldEnd()
15121 
    oprot.writeFieldStop()
15122 
    oprot.writeStructEnd()
15123 
 
15124 
  def validate(self):
15125 
    return
15126 
 
15127 
 
15128 
  def __repr__(self):
15129 
    L = ['%s=%r' % (key, value)
15130 
      for key, value in self.__dict__.iteritems()]
15131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15132 
 
15133 
  def __eq__(self, other):
15134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15135 
 
15136 
  def __ne__(self, other):
15137 
    return not (self == other)
15138 
 
15139 
class addSourceItemPricing_result:
15140 
  """
15141 
  Attributes:
15142 
   - cex
15143 
  """
15144 
 
15145 
  thrift_spec = (
15146 
    None, # 0
15147 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15148 
  )
15149 
 
15150 
  def __init__(self, cex=None,):
15151 
    self.cex = cex
15152 
 
15153 
  def read(self, iprot):
15154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15156 
      return
15157 
    iprot.readStructBegin()
15158 
    while True:
15159 
      (fname, ftype, fid) = iprot.readFieldBegin()
15160 
      if ftype == TType.STOP:
15161 
        break
15162 
      if fid == 1:
15163 
        if ftype == TType.STRUCT:
15164 
          self.cex = CatalogServiceException()
15165 
          self.cex.read(iprot)
15166 
        else:
15167 
          iprot.skip(ftype)
15168 
      else:
15169 
        iprot.skip(ftype)
15170 
      iprot.readFieldEnd()
15171 
    iprot.readStructEnd()
15172 
 
15173 
  def write(self, oprot):
15174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15176 
      return
15177 
    oprot.writeStructBegin('addSourceItemPricing_result')
15178 
    if self.cex is not None:
15179 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15180 
      self.cex.write(oprot)
15181 
      oprot.writeFieldEnd()
15182 
    oprot.writeFieldStop()
15183 
    oprot.writeStructEnd()
15184 
 
15185 
  def validate(self):
15186 
    return
15187 
 
15188 
 
15189 
  def __repr__(self):
15190 
    L = ['%s=%r' % (key, value)
15191 
      for key, value in self.__dict__.iteritems()]
15192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15193 
 
15194 
  def __eq__(self, other):
15195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15196 
 
15197 
  def __ne__(self, other):
15198 
    return not (self == other)
15199 
 
15200 
class getAllSourcePricing_args:
15201 
  """
15202 
  Attributes:
15203 
   - itemId
15204 
  """
15205 
 
15206 
  thrift_spec = (
15207 
    None, # 0
15208 
    (1, TType.I64, 'itemId', None, None, ), # 1
15209 
  )
15210 
 
15211 
  def __init__(self, itemId=None,):
15212 
    self.itemId = itemId
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 
      else:
15229 
        iprot.skip(ftype)
15230 
      iprot.readFieldEnd()
15231 
    iprot.readStructEnd()
15232 
 
15233 
  def write(self, oprot):
15234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15236 
      return
15237 
    oprot.writeStructBegin('getAllSourcePricing_args')
15238 
    if self.itemId is not None:
15239 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15240 
      oprot.writeI64(self.itemId)
15241 
      oprot.writeFieldEnd()
15242 
    oprot.writeFieldStop()
15243 
    oprot.writeStructEnd()
15244 
 
15245 
  def validate(self):
15246 
    return
15247 
 
15248 
 
15249 
  def __repr__(self):
15250 
    L = ['%s=%r' % (key, value)
15251 
      for key, value in self.__dict__.iteritems()]
15252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15253 
 
15254 
  def __eq__(self, other):
15255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15256 
 
15257 
  def __ne__(self, other):
15258 
    return not (self == other)
15259 
 
15260 
class getAllSourcePricing_result:
15261 
  """
15262 
  Attributes:
15263 
   - success
15264 
   - cex
15265 
  """
15266 
 
15267 
  thrift_spec = (
15268 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
15269 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15270 
  )
15271 
 
15272 
  def __init__(self, success=None, cex=None,):
15273 
    self.success = success
15274 
    self.cex = cex
15275 
 
15276 
  def read(self, iprot):
15277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15279 
      return
15280 
    iprot.readStructBegin()
15281 
    while True:
15282 
      (fname, ftype, fid) = iprot.readFieldBegin()
15283 
      if ftype == TType.STOP:
15284 
        break
15285 
      if fid == 0:
15286 
        if ftype == TType.LIST:
15287 
          self.success = []
8579 kshitij.so 15288 
          (_etype291, _size288) = iprot.readListBegin()
15289 
          for _i292 in xrange(_size288):
15290 
            _elem293 = SourceItemPricing()
15291 
            _elem293.read(iprot)
15292 
            self.success.append(_elem293)
5944 mandeep.dh 15293 
          iprot.readListEnd()
15294 
        else:
15295 
          iprot.skip(ftype)
15296 
      elif fid == 1:
15297 
        if ftype == TType.STRUCT:
15298 
          self.cex = CatalogServiceException()
15299 
          self.cex.read(iprot)
15300 
        else:
15301 
          iprot.skip(ftype)
15302 
      else:
15303 
        iprot.skip(ftype)
15304 
      iprot.readFieldEnd()
15305 
    iprot.readStructEnd()
15306 
 
15307 
  def write(self, oprot):
15308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15310 
      return
15311 
    oprot.writeStructBegin('getAllSourcePricing_result')
15312 
    if self.success is not None:
15313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 15315 
      for iter294 in self.success:
15316 
        iter294.write(oprot)
5944 mandeep.dh 15317 
      oprot.writeListEnd()
15318 
      oprot.writeFieldEnd()
15319 
    if self.cex is not None:
15320 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15321 
      self.cex.write(oprot)
15322 
      oprot.writeFieldEnd()
15323 
    oprot.writeFieldStop()
15324 
    oprot.writeStructEnd()
15325 
 
15326 
  def validate(self):
15327 
    return
15328 
 
15329 
 
15330 
  def __repr__(self):
15331 
    L = ['%s=%r' % (key, value)
15332 
      for key, value in self.__dict__.iteritems()]
15333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15334 
 
15335 
  def __eq__(self, other):
15336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15337 
 
15338 
  def __ne__(self, other):
15339 
    return not (self == other)
15340 
 
15341 
class getItemForSource_args:
15342 
  """
15343 
  Attributes:
15344 
   - item_id
15345 
   - sourceId
15346 
  """
15347 
 
15348 
  thrift_spec = (
15349 
    None, # 0
15350 
    (1, TType.I64, 'item_id', None, None, ), # 1
15351 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15352 
  )
15353 
 
15354 
  def __init__(self, item_id=None, sourceId=None,):
15355 
    self.item_id = item_id
15356 
    self.sourceId = sourceId
15357 
 
15358 
  def read(self, iprot):
15359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15361 
      return
15362 
    iprot.readStructBegin()
15363 
    while True:
15364 
      (fname, ftype, fid) = iprot.readFieldBegin()
15365 
      if ftype == TType.STOP:
15366 
        break
15367 
      if fid == 1:
15368 
        if ftype == TType.I64:
15369 
          self.item_id = iprot.readI64();
15370 
        else:
15371 
          iprot.skip(ftype)
15372 
      elif fid == 2:
15373 
        if ftype == TType.I64:
15374 
          self.sourceId = iprot.readI64();
15375 
        else:
15376 
          iprot.skip(ftype)
15377 
      else:
15378 
        iprot.skip(ftype)
15379 
      iprot.readFieldEnd()
15380 
    iprot.readStructEnd()
15381 
 
15382 
  def write(self, oprot):
15383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15385 
      return
15386 
    oprot.writeStructBegin('getItemForSource_args')
15387 
    if self.item_id is not None:
15388 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
15389 
      oprot.writeI64(self.item_id)
15390 
      oprot.writeFieldEnd()
15391 
    if self.sourceId is not None:
15392 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15393 
      oprot.writeI64(self.sourceId)
15394 
      oprot.writeFieldEnd()
15395 
    oprot.writeFieldStop()
15396 
    oprot.writeStructEnd()
15397 
 
15398 
  def validate(self):
15399 
    return
15400 
 
15401 
 
15402 
  def __repr__(self):
15403 
    L = ['%s=%r' % (key, value)
15404 
      for key, value in self.__dict__.iteritems()]
15405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15406 
 
15407 
  def __eq__(self, other):
15408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15409 
 
15410 
  def __ne__(self, other):
15411 
    return not (self == other)
15412 
 
15413 
class getItemForSource_result:
15414 
  """
15415 
  Attributes:
15416 
   - success
15417 
   - cex
15418 
  """
15419 
 
15420 
  thrift_spec = (
15421 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
15422 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15423 
  )
15424 
 
15425 
  def __init__(self, success=None, cex=None,):
15426 
    self.success = success
15427 
    self.cex = cex
15428 
 
15429 
  def read(self, iprot):
15430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15432 
      return
15433 
    iprot.readStructBegin()
15434 
    while True:
15435 
      (fname, ftype, fid) = iprot.readFieldBegin()
15436 
      if ftype == TType.STOP:
15437 
        break
15438 
      if fid == 0:
15439 
        if ftype == TType.STRUCT:
15440 
          self.success = Item()
15441 
          self.success.read(iprot)
15442 
        else:
15443 
          iprot.skip(ftype)
15444 
      elif fid == 1:
15445 
        if ftype == TType.STRUCT:
15446 
          self.cex = CatalogServiceException()
15447 
          self.cex.read(iprot)
15448 
        else:
15449 
          iprot.skip(ftype)
15450 
      else:
15451 
        iprot.skip(ftype)
15452 
      iprot.readFieldEnd()
15453 
    iprot.readStructEnd()
15454 
 
15455 
  def write(self, oprot):
15456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15458 
      return
15459 
    oprot.writeStructBegin('getItemForSource_result')
15460 
    if self.success is not None:
15461 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15462 
      self.success.write(oprot)
15463 
      oprot.writeFieldEnd()
15464 
    if self.cex is not None:
15465 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15466 
      self.cex.write(oprot)
15467 
      oprot.writeFieldEnd()
15468 
    oprot.writeFieldStop()
15469 
    oprot.writeStructEnd()
15470 
 
15471 
  def validate(self):
15472 
    return
15473 
 
15474 
 
15475 
  def __repr__(self):
15476 
    L = ['%s=%r' % (key, value)
15477 
      for key, value in self.__dict__.iteritems()]
15478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15479 
 
15480 
  def __eq__(self, other):
15481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15482 
 
15483 
  def __ne__(self, other):
15484 
    return not (self == other)
15485 
 
15486 
class searchItemsInRange_args:
15487 
  """
15488 
  Attributes:
15489 
   - searchTerms
15490 
   - offset
15491 
   - limit
15492 
  """
15493 
 
15494 
  thrift_spec = (
15495 
    None, # 0
15496 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15497 
    (2, TType.I64, 'offset', None, None, ), # 2
15498 
    (3, TType.I64, 'limit', None, None, ), # 3
15499 
  )
15500 
 
15501 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
15502 
    self.searchTerms = searchTerms
15503 
    self.offset = offset
15504 
    self.limit = limit
15505 
 
15506 
  def read(self, iprot):
15507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15509 
      return
15510 
    iprot.readStructBegin()
15511 
    while True:
15512 
      (fname, ftype, fid) = iprot.readFieldBegin()
15513 
      if ftype == TType.STOP:
15514 
        break
15515 
      if fid == 1:
15516 
        if ftype == TType.LIST:
15517 
          self.searchTerms = []
8579 kshitij.so 15518 
          (_etype298, _size295) = iprot.readListBegin()
15519 
          for _i299 in xrange(_size295):
15520 
            _elem300 = iprot.readString();
15521 
            self.searchTerms.append(_elem300)
5944 mandeep.dh 15522 
          iprot.readListEnd()
15523 
        else:
15524 
          iprot.skip(ftype)
15525 
      elif fid == 2:
15526 
        if ftype == TType.I64:
15527 
          self.offset = iprot.readI64();
15528 
        else:
15529 
          iprot.skip(ftype)
15530 
      elif fid == 3:
15531 
        if ftype == TType.I64:
15532 
          self.limit = iprot.readI64();
15533 
        else:
15534 
          iprot.skip(ftype)
15535 
      else:
15536 
        iprot.skip(ftype)
15537 
      iprot.readFieldEnd()
15538 
    iprot.readStructEnd()
15539 
 
15540 
  def write(self, oprot):
15541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15543 
      return
15544 
    oprot.writeStructBegin('searchItemsInRange_args')
15545 
    if self.searchTerms is not None:
15546 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15547 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8579 kshitij.so 15548 
      for iter301 in self.searchTerms:
15549 
        oprot.writeString(iter301)
5944 mandeep.dh 15550 
      oprot.writeListEnd()
15551 
      oprot.writeFieldEnd()
15552 
    if self.offset is not None:
15553 
      oprot.writeFieldBegin('offset', TType.I64, 2)
15554 
      oprot.writeI64(self.offset)
15555 
      oprot.writeFieldEnd()
15556 
    if self.limit is not None:
15557 
      oprot.writeFieldBegin('limit', TType.I64, 3)
15558 
      oprot.writeI64(self.limit)
15559 
      oprot.writeFieldEnd()
15560 
    oprot.writeFieldStop()
15561 
    oprot.writeStructEnd()
15562 
 
15563 
  def validate(self):
15564 
    return
15565 
 
15566 
 
15567 
  def __repr__(self):
15568 
    L = ['%s=%r' % (key, value)
15569 
      for key, value in self.__dict__.iteritems()]
15570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15571 
 
15572 
  def __eq__(self, other):
15573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15574 
 
15575 
  def __ne__(self, other):
15576 
    return not (self == other)
15577 
 
15578 
class searchItemsInRange_result:
15579 
  """
15580 
  Attributes:
15581 
   - success
15582 
  """
15583 
 
15584 
  thrift_spec = (
15585 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15586 
  )
15587 
 
15588 
  def __init__(self, success=None,):
15589 
    self.success = success
15590 
 
15591 
  def read(self, iprot):
15592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15594 
      return
15595 
    iprot.readStructBegin()
15596 
    while True:
15597 
      (fname, ftype, fid) = iprot.readFieldBegin()
15598 
      if ftype == TType.STOP:
15599 
        break
15600 
      if fid == 0:
15601 
        if ftype == TType.LIST:
15602 
          self.success = []
8579 kshitij.so 15603 
          (_etype305, _size302) = iprot.readListBegin()
15604 
          for _i306 in xrange(_size302):
15605 
            _elem307 = Item()
15606 
            _elem307.read(iprot)
15607 
            self.success.append(_elem307)
5944 mandeep.dh 15608 
          iprot.readListEnd()
15609 
        else:
15610 
          iprot.skip(ftype)
15611 
      else:
15612 
        iprot.skip(ftype)
15613 
      iprot.readFieldEnd()
15614 
    iprot.readStructEnd()
15615 
 
15616 
  def write(self, oprot):
15617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15619 
      return
15620 
    oprot.writeStructBegin('searchItemsInRange_result')
15621 
    if self.success is not None:
15622 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15623 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 15624 
      for iter308 in self.success:
15625 
        iter308.write(oprot)
5944 mandeep.dh 15626 
      oprot.writeListEnd()
15627 
      oprot.writeFieldEnd()
15628 
    oprot.writeFieldStop()
15629 
    oprot.writeStructEnd()
15630 
 
15631 
  def validate(self):
15632 
    return
15633 
 
15634 
 
15635 
  def __repr__(self):
15636 
    L = ['%s=%r' % (key, value)
15637 
      for key, value in self.__dict__.iteritems()]
15638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15639 
 
15640 
  def __eq__(self, other):
15641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15642 
 
15643 
  def __ne__(self, other):
15644 
    return not (self == other)
15645 
 
15646 
class getSearchResultCount_args:
15647 
  """
15648 
  Attributes:
15649 
   - searchTerms
15650 
  """
15651 
 
15652 
  thrift_spec = (
15653 
    None, # 0
15654 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15655 
  )
15656 
 
15657 
  def __init__(self, searchTerms=None,):
15658 
    self.searchTerms = searchTerms
15659 
 
15660 
  def read(self, iprot):
15661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15663 
      return
15664 
    iprot.readStructBegin()
15665 
    while True:
15666 
      (fname, ftype, fid) = iprot.readFieldBegin()
15667 
      if ftype == TType.STOP:
15668 
        break
15669 
      if fid == 1:
15670 
        if ftype == TType.LIST:
15671 
          self.searchTerms = []
8579 kshitij.so 15672 
          (_etype312, _size309) = iprot.readListBegin()
15673 
          for _i313 in xrange(_size309):
15674 
            _elem314 = iprot.readString();
15675 
            self.searchTerms.append(_elem314)
5944 mandeep.dh 15676 
          iprot.readListEnd()
15677 
        else:
15678 
          iprot.skip(ftype)
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('getSearchResultCount_args')
15689 
    if self.searchTerms is not None:
15690 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15691 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8579 kshitij.so 15692 
      for iter315 in self.searchTerms:
15693 
        oprot.writeString(iter315)
5944 mandeep.dh 15694 
      oprot.writeListEnd()
15695 
      oprot.writeFieldEnd()
15696 
    oprot.writeFieldStop()
15697 
    oprot.writeStructEnd()
15698 
 
15699 
  def validate(self):
15700 
    return
15701 
 
15702 
 
15703 
  def __repr__(self):
15704 
    L = ['%s=%r' % (key, value)
15705 
      for key, value in self.__dict__.iteritems()]
15706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15707 
 
15708 
  def __eq__(self, other):
15709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15710 
 
15711 
  def __ne__(self, other):
15712 
    return not (self == other)
15713 
 
15714 
class getSearchResultCount_result:
15715 
  """
15716 
  Attributes:
15717 
   - success
15718 
  """
15719 
 
15720 
  thrift_spec = (
15721 
    (0, TType.I32, 'success', None, None, ), # 0
15722 
  )
15723 
 
15724 
  def __init__(self, success=None,):
15725 
    self.success = success
15726 
 
15727 
  def read(self, iprot):
15728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15730 
      return
15731 
    iprot.readStructBegin()
15732 
    while True:
15733 
      (fname, ftype, fid) = iprot.readFieldBegin()
15734 
      if ftype == TType.STOP:
15735 
        break
15736 
      if fid == 0:
15737 
        if ftype == TType.I32:
15738 
          self.success = iprot.readI32();
15739 
        else:
15740 
          iprot.skip(ftype)
15741 
      else:
15742 
        iprot.skip(ftype)
15743 
      iprot.readFieldEnd()
15744 
    iprot.readStructEnd()
15745 
 
15746 
  def write(self, oprot):
15747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15749 
      return
15750 
    oprot.writeStructBegin('getSearchResultCount_result')
15751 
    if self.success is not None:
15752 
      oprot.writeFieldBegin('success', TType.I32, 0)
15753 
      oprot.writeI32(self.success)
15754 
      oprot.writeFieldEnd()
15755 
    oprot.writeFieldStop()
15756 
    oprot.writeStructEnd()
15757 
 
15758 
  def validate(self):
15759 
    return
15760 
 
15761 
 
15762 
  def __repr__(self):
15763 
    L = ['%s=%r' % (key, value)
15764 
      for key, value in self.__dict__.iteritems()]
15765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15766 
 
15767 
  def __eq__(self, other):
15768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15769 
 
15770 
  def __ne__(self, other):
15771 
    return not (self == other)
15772 
 
15773 
class getProductNotifications_args:
15774 
  """
15775 
  Attributes:
15776 
   - startDateTime
15777 
  """
15778 
 
15779 
  thrift_spec = (
15780 
    None, # 0
15781 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
15782 
  )
15783 
 
15784 
  def __init__(self, startDateTime=None,):
15785 
    self.startDateTime = startDateTime
15786 
 
15787 
  def read(self, iprot):
15788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15790 
      return
15791 
    iprot.readStructBegin()
15792 
    while True:
15793 
      (fname, ftype, fid) = iprot.readFieldBegin()
15794 
      if ftype == TType.STOP:
15795 
        break
15796 
      if fid == 1:
15797 
        if ftype == TType.I64:
15798 
          self.startDateTime = iprot.readI64();
15799 
        else:
15800 
          iprot.skip(ftype)
15801 
      else:
15802 
        iprot.skip(ftype)
15803 
      iprot.readFieldEnd()
15804 
    iprot.readStructEnd()
15805 
 
15806 
  def write(self, oprot):
15807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15809 
      return
15810 
    oprot.writeStructBegin('getProductNotifications_args')
15811 
    if self.startDateTime is not None:
15812 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
15813 
      oprot.writeI64(self.startDateTime)
15814 
      oprot.writeFieldEnd()
15815 
    oprot.writeFieldStop()
15816 
    oprot.writeStructEnd()
15817 
 
15818 
  def validate(self):
15819 
    return
15820 
 
15821 
 
15822 
  def __repr__(self):
15823 
    L = ['%s=%r' % (key, value)
15824 
      for key, value in self.__dict__.iteritems()]
15825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15826 
 
15827 
  def __eq__(self, other):
15828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15829 
 
15830 
  def __ne__(self, other):
15831 
    return not (self == other)
15832 
 
15833 
class getProductNotifications_result:
15834 
  """
15835 
  Attributes:
15836 
   - success
15837 
  """
15838 
 
15839 
  thrift_spec = (
15840 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
15841 
  )
15842 
 
15843 
  def __init__(self, success=None,):
15844 
    self.success = success
15845 
 
15846 
  def read(self, iprot):
15847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15849 
      return
15850 
    iprot.readStructBegin()
15851 
    while True:
15852 
      (fname, ftype, fid) = iprot.readFieldBegin()
15853 
      if ftype == TType.STOP:
15854 
        break
15855 
      if fid == 0:
15856 
        if ftype == TType.LIST:
15857 
          self.success = []
8579 kshitij.so 15858 
          (_etype319, _size316) = iprot.readListBegin()
15859 
          for _i320 in xrange(_size316):
15860 
            _elem321 = ProductNotificationRequest()
15861 
            _elem321.read(iprot)
15862 
            self.success.append(_elem321)
5944 mandeep.dh 15863 
          iprot.readListEnd()
15864 
        else:
15865 
          iprot.skip(ftype)
15866 
      else:
15867 
        iprot.skip(ftype)
15868 
      iprot.readFieldEnd()
15869 
    iprot.readStructEnd()
15870 
 
15871 
  def write(self, oprot):
15872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15874 
      return
15875 
    oprot.writeStructBegin('getProductNotifications_result')
15876 
    if self.success is not None:
15877 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15878 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 15879 
      for iter322 in self.success:
15880 
        iter322.write(oprot)
5944 mandeep.dh 15881 
      oprot.writeListEnd()
15882 
      oprot.writeFieldEnd()
15883 
    oprot.writeFieldStop()
15884 
    oprot.writeStructEnd()
15885 
 
15886 
  def validate(self):
15887 
    return
15888 
 
15889 
 
15890 
  def __repr__(self):
15891 
    L = ['%s=%r' % (key, value)
15892 
      for key, value in self.__dict__.iteritems()]
15893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15894 
 
15895 
  def __eq__(self, other):
15896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15897 
 
15898 
  def __ne__(self, other):
15899 
    return not (self == other)
15900 
 
15901 
class getProductNotificationRequestCount_args:
15902 
  """
15903 
  Attributes:
15904 
   - startDateTime
7897 amar.kumar 15905 
   - categoryId
5944 mandeep.dh 15906 
  """
15907 
 
15908 
  thrift_spec = (
15909 
    None, # 0
15910 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 15911 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 15912 
  )
15913 
 
7897 amar.kumar 15914 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 15915 
    self.startDateTime = startDateTime
7897 amar.kumar 15916 
    self.categoryId = categoryId
5944 mandeep.dh 15917 
 
15918 
  def read(self, iprot):
15919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15921 
      return
15922 
    iprot.readStructBegin()
15923 
    while True:
15924 
      (fname, ftype, fid) = iprot.readFieldBegin()
15925 
      if ftype == TType.STOP:
15926 
        break
15927 
      if fid == 1:
15928 
        if ftype == TType.I64:
15929 
          self.startDateTime = iprot.readI64();
15930 
        else:
15931 
          iprot.skip(ftype)
7897 amar.kumar 15932 
      elif fid == 2:
15933 
        if ftype == TType.I64:
15934 
          self.categoryId = iprot.readI64();
15935 
        else:
15936 
          iprot.skip(ftype)
5944 mandeep.dh 15937 
      else:
15938 
        iprot.skip(ftype)
15939 
      iprot.readFieldEnd()
15940 
    iprot.readStructEnd()
15941 
 
15942 
  def write(self, oprot):
15943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15945 
      return
15946 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
15947 
    if self.startDateTime is not None:
15948 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
15949 
      oprot.writeI64(self.startDateTime)
15950 
      oprot.writeFieldEnd()
7897 amar.kumar 15951 
    if self.categoryId is not None:
15952 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
15953 
      oprot.writeI64(self.categoryId)
15954 
      oprot.writeFieldEnd()
5944 mandeep.dh 15955 
    oprot.writeFieldStop()
15956 
    oprot.writeStructEnd()
15957 
 
15958 
  def validate(self):
15959 
    return
15960 
 
15961 
 
15962 
  def __repr__(self):
15963 
    L = ['%s=%r' % (key, value)
15964 
      for key, value in self.__dict__.iteritems()]
15965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15966 
 
15967 
  def __eq__(self, other):
15968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15969 
 
15970 
  def __ne__(self, other):
15971 
    return not (self == other)
15972 
 
15973 
class getProductNotificationRequestCount_result:
15974 
  """
15975 
  Attributes:
15976 
   - success
15977 
  """
15978 
 
15979 
  thrift_spec = (
15980 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
15981 
  )
15982 
 
15983 
  def __init__(self, success=None,):
15984 
    self.success = success
15985 
 
15986 
  def read(self, iprot):
15987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15989 
      return
15990 
    iprot.readStructBegin()
15991 
    while True:
15992 
      (fname, ftype, fid) = iprot.readFieldBegin()
15993 
      if ftype == TType.STOP:
15994 
        break
15995 
      if fid == 0:
15996 
        if ftype == TType.LIST:
15997 
          self.success = []
8579 kshitij.so 15998 
          (_etype326, _size323) = iprot.readListBegin()
15999 
          for _i327 in xrange(_size323):
16000 
            _elem328 = ProductNotificationRequestCount()
16001 
            _elem328.read(iprot)
16002 
            self.success.append(_elem328)
5944 mandeep.dh 16003 
          iprot.readListEnd()
16004 
        else:
16005 
          iprot.skip(ftype)
16006 
      else:
16007 
        iprot.skip(ftype)
16008 
      iprot.readFieldEnd()
16009 
    iprot.readStructEnd()
16010 
 
16011 
  def write(self, oprot):
16012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16014 
      return
16015 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16016 
    if self.success is not None:
16017 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16018 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 16019 
      for iter329 in self.success:
16020 
        iter329.write(oprot)
5944 mandeep.dh 16021 
      oprot.writeListEnd()
16022 
      oprot.writeFieldEnd()
16023 
    oprot.writeFieldStop()
16024 
    oprot.writeStructEnd()
16025 
 
16026 
  def validate(self):
16027 
    return
16028 
 
16029 
 
16030 
  def __repr__(self):
16031 
    L = ['%s=%r' % (key, value)
16032 
      for key, value in self.__dict__.iteritems()]
16033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16034 
 
16035 
  def __eq__(self, other):
16036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16037 
 
16038 
  def __ne__(self, other):
16039 
    return not (self == other)
16040 
 
16041 
class addAuthorizationLog_args:
16042 
  """
16043 
  Attributes:
16044 
   - itemId
16045 
   - username
16046 
   - reason
16047 
  """
16048 
 
16049 
  thrift_spec = (
16050 
    None, # 0
16051 
    (1, TType.I64, 'itemId', None, None, ), # 1
16052 
    (2, TType.STRING, 'username', None, None, ), # 2
16053 
    (3, TType.STRING, 'reason', None, None, ), # 3
16054 
  )
16055 
 
16056 
  def __init__(self, itemId=None, username=None, reason=None,):
16057 
    self.itemId = itemId
16058 
    self.username = username
16059 
    self.reason = reason
16060 
 
16061 
  def read(self, iprot):
16062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16064 
      return
16065 
    iprot.readStructBegin()
16066 
    while True:
16067 
      (fname, ftype, fid) = iprot.readFieldBegin()
16068 
      if ftype == TType.STOP:
16069 
        break
16070 
      if fid == 1:
16071 
        if ftype == TType.I64:
16072 
          self.itemId = iprot.readI64();
16073 
        else:
16074 
          iprot.skip(ftype)
16075 
      elif fid == 2:
16076 
        if ftype == TType.STRING:
16077 
          self.username = iprot.readString();
16078 
        else:
16079 
          iprot.skip(ftype)
16080 
      elif fid == 3:
16081 
        if ftype == TType.STRING:
16082 
          self.reason = iprot.readString();
16083 
        else:
16084 
          iprot.skip(ftype)
16085 
      else:
16086 
        iprot.skip(ftype)
16087 
      iprot.readFieldEnd()
16088 
    iprot.readStructEnd()
16089 
 
16090 
  def write(self, oprot):
16091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16093 
      return
16094 
    oprot.writeStructBegin('addAuthorizationLog_args')
16095 
    if self.itemId is not None:
16096 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16097 
      oprot.writeI64(self.itemId)
16098 
      oprot.writeFieldEnd()
16099 
    if self.username is not None:
16100 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16101 
      oprot.writeString(self.username)
16102 
      oprot.writeFieldEnd()
16103 
    if self.reason is not None:
16104 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16105 
      oprot.writeString(self.reason)
16106 
      oprot.writeFieldEnd()
16107 
    oprot.writeFieldStop()
16108 
    oprot.writeStructEnd()
16109 
 
16110 
  def validate(self):
16111 
    return
16112 
 
16113 
 
16114 
  def __repr__(self):
16115 
    L = ['%s=%r' % (key, value)
16116 
      for key, value in self.__dict__.iteritems()]
16117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16118 
 
16119 
  def __eq__(self, other):
16120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16121 
 
16122 
  def __ne__(self, other):
16123 
    return not (self == other)
16124 
 
16125 
class addAuthorizationLog_result:
16126 
  """
16127 
  Attributes:
16128 
   - success
16129 
   - cex
16130 
  """
16131 
 
16132 
  thrift_spec = (
16133 
    (0, TType.BOOL, 'success', None, None, ), # 0
16134 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16135 
  )
16136 
 
16137 
  def __init__(self, success=None, cex=None,):
16138 
    self.success = success
16139 
    self.cex = cex
16140 
 
16141 
  def read(self, iprot):
16142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16144 
      return
16145 
    iprot.readStructBegin()
16146 
    while True:
16147 
      (fname, ftype, fid) = iprot.readFieldBegin()
16148 
      if ftype == TType.STOP:
16149 
        break
16150 
      if fid == 0:
16151 
        if ftype == TType.BOOL:
16152 
          self.success = iprot.readBool();
16153 
        else:
16154 
          iprot.skip(ftype)
16155 
      elif fid == 1:
16156 
        if ftype == TType.STRUCT:
16157 
          self.cex = CatalogServiceException()
16158 
          self.cex.read(iprot)
16159 
        else:
16160 
          iprot.skip(ftype)
16161 
      else:
16162 
        iprot.skip(ftype)
16163 
      iprot.readFieldEnd()
16164 
    iprot.readStructEnd()
16165 
 
16166 
  def write(self, oprot):
16167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16169 
      return
16170 
    oprot.writeStructBegin('addAuthorizationLog_result')
16171 
    if self.success is not None:
16172 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16173 
      oprot.writeBool(self.success)
16174 
      oprot.writeFieldEnd()
16175 
    if self.cex is not None:
16176 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16177 
      self.cex.write(oprot)
16178 
      oprot.writeFieldEnd()
16179 
    oprot.writeFieldStop()
16180 
    oprot.writeStructEnd()
16181 
 
16182 
  def validate(self):
16183 
    return
16184 
 
16185 
 
16186 
  def __repr__(self):
16187 
    L = ['%s=%r' % (key, value)
16188 
      for key, value in self.__dict__.iteritems()]
16189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16190 
 
16191 
  def __eq__(self, other):
16192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16193 
 
16194 
  def __ne__(self, other):
16195 
    return not (self == other)
16196 
 
16197 
class addupdateVoucherForItem_args:
16198 
  """
16199 
  Attributes:
16200 
   - catalog_item_id
16201 
   - voucherType
16202 
   - voucherAmount
16203 
  """
16204 
 
16205 
  thrift_spec = (
16206 
    None, # 0
16207 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16208 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16209 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
16210 
  )
16211 
 
16212 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
16213 
    self.catalog_item_id = catalog_item_id
16214 
    self.voucherType = voucherType
16215 
    self.voucherAmount = voucherAmount
16216 
 
16217 
  def read(self, iprot):
16218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16220 
      return
16221 
    iprot.readStructBegin()
16222 
    while True:
16223 
      (fname, ftype, fid) = iprot.readFieldBegin()
16224 
      if ftype == TType.STOP:
16225 
        break
16226 
      if fid == 1:
16227 
        if ftype == TType.I64:
16228 
          self.catalog_item_id = iprot.readI64();
16229 
        else:
16230 
          iprot.skip(ftype)
16231 
      elif fid == 2:
16232 
        if ftype == TType.I64:
16233 
          self.voucherType = iprot.readI64();
16234 
        else:
16235 
          iprot.skip(ftype)
16236 
      elif fid == 3:
16237 
        if ftype == TType.I64:
16238 
          self.voucherAmount = iprot.readI64();
16239 
        else:
16240 
          iprot.skip(ftype)
16241 
      else:
16242 
        iprot.skip(ftype)
16243 
      iprot.readFieldEnd()
16244 
    iprot.readStructEnd()
16245 
 
16246 
  def write(self, oprot):
16247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16249 
      return
16250 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
16251 
    if self.catalog_item_id is not None:
16252 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16253 
      oprot.writeI64(self.catalog_item_id)
16254 
      oprot.writeFieldEnd()
16255 
    if self.voucherType is not None:
16256 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16257 
      oprot.writeI64(self.voucherType)
16258 
      oprot.writeFieldEnd()
16259 
    if self.voucherAmount is not None:
16260 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
16261 
      oprot.writeI64(self.voucherAmount)
16262 
      oprot.writeFieldEnd()
16263 
    oprot.writeFieldStop()
16264 
    oprot.writeStructEnd()
16265 
 
16266 
  def validate(self):
16267 
    return
16268 
 
16269 
 
16270 
  def __repr__(self):
16271 
    L = ['%s=%r' % (key, value)
16272 
      for key, value in self.__dict__.iteritems()]
16273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16274 
 
16275 
  def __eq__(self, other):
16276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16277 
 
16278 
  def __ne__(self, other):
16279 
    return not (self == other)
16280 
 
16281 
class addupdateVoucherForItem_result:
16282 
  """
16283 
  Attributes:
16284 
   - success
16285 
   - cex
16286 
  """
16287 
 
16288 
  thrift_spec = (
16289 
    (0, TType.BOOL, 'success', None, None, ), # 0
16290 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16291 
  )
16292 
 
16293 
  def __init__(self, success=None, cex=None,):
16294 
    self.success = success
16295 
    self.cex = cex
16296 
 
16297 
  def read(self, iprot):
16298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16300 
      return
16301 
    iprot.readStructBegin()
16302 
    while True:
16303 
      (fname, ftype, fid) = iprot.readFieldBegin()
16304 
      if ftype == TType.STOP:
16305 
        break
16306 
      if fid == 0:
16307 
        if ftype == TType.BOOL:
16308 
          self.success = iprot.readBool();
16309 
        else:
16310 
          iprot.skip(ftype)
16311 
      elif fid == 1:
16312 
        if ftype == TType.STRUCT:
16313 
          self.cex = CatalogServiceException()
16314 
          self.cex.read(iprot)
16315 
        else:
16316 
          iprot.skip(ftype)
16317 
      else:
16318 
        iprot.skip(ftype)
16319 
      iprot.readFieldEnd()
16320 
    iprot.readStructEnd()
16321 
 
16322 
  def write(self, oprot):
16323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16325 
      return
16326 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
16327 
    if self.success is not None:
16328 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16329 
      oprot.writeBool(self.success)
16330 
      oprot.writeFieldEnd()
16331 
    if self.cex is not None:
16332 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16333 
      self.cex.write(oprot)
16334 
      oprot.writeFieldEnd()
16335 
    oprot.writeFieldStop()
16336 
    oprot.writeStructEnd()
16337 
 
16338 
  def validate(self):
16339 
    return
16340 
 
16341 
 
16342 
  def __repr__(self):
16343 
    L = ['%s=%r' % (key, value)
16344 
      for key, value in self.__dict__.iteritems()]
16345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16346 
 
16347 
  def __eq__(self, other):
16348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16349 
 
16350 
  def __ne__(self, other):
16351 
    return not (self == other)
16352 
 
16353 
class deleteVoucherForItem_args:
16354 
  """
16355 
  Attributes:
16356 
   - catalog_item_id
16357 
   - voucherType
16358 
  """
16359 
 
16360 
  thrift_spec = (
16361 
    None, # 0
16362 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16363 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16364 
  )
16365 
 
16366 
  def __init__(self, catalog_item_id=None, voucherType=None,):
16367 
    self.catalog_item_id = catalog_item_id
16368 
    self.voucherType = voucherType
16369 
 
16370 
  def read(self, iprot):
16371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16373 
      return
16374 
    iprot.readStructBegin()
16375 
    while True:
16376 
      (fname, ftype, fid) = iprot.readFieldBegin()
16377 
      if ftype == TType.STOP:
16378 
        break
16379 
      if fid == 1:
16380 
        if ftype == TType.I64:
16381 
          self.catalog_item_id = iprot.readI64();
16382 
        else:
16383 
          iprot.skip(ftype)
16384 
      elif fid == 2:
16385 
        if ftype == TType.I64:
16386 
          self.voucherType = iprot.readI64();
16387 
        else:
16388 
          iprot.skip(ftype)
16389 
      else:
16390 
        iprot.skip(ftype)
16391 
      iprot.readFieldEnd()
16392 
    iprot.readStructEnd()
16393 
 
16394 
  def write(self, oprot):
16395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16397 
      return
16398 
    oprot.writeStructBegin('deleteVoucherForItem_args')
16399 
    if self.catalog_item_id is not None:
16400 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16401 
      oprot.writeI64(self.catalog_item_id)
16402 
      oprot.writeFieldEnd()
16403 
    if self.voucherType is not None:
16404 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16405 
      oprot.writeI64(self.voucherType)
16406 
      oprot.writeFieldEnd()
16407 
    oprot.writeFieldStop()
16408 
    oprot.writeStructEnd()
16409 
 
16410 
  def validate(self):
16411 
    return
16412 
 
16413 
 
16414 
  def __repr__(self):
16415 
    L = ['%s=%r' % (key, value)
16416 
      for key, value in self.__dict__.iteritems()]
16417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16418 
 
16419 
  def __eq__(self, other):
16420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16421 
 
16422 
  def __ne__(self, other):
16423 
    return not (self == other)
16424 
 
16425 
class deleteVoucherForItem_result:
16426 
  """
16427 
  Attributes:
16428 
   - success
16429 
   - cex
16430 
  """
16431 
 
16432 
  thrift_spec = (
16433 
    (0, TType.BOOL, 'success', None, None, ), # 0
16434 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16435 
  )
16436 
 
16437 
  def __init__(self, success=None, cex=None,):
16438 
    self.success = success
16439 
    self.cex = cex
16440 
 
16441 
  def read(self, iprot):
16442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16444 
      return
16445 
    iprot.readStructBegin()
16446 
    while True:
16447 
      (fname, ftype, fid) = iprot.readFieldBegin()
16448 
      if ftype == TType.STOP:
16449 
        break
16450 
      if fid == 0:
16451 
        if ftype == TType.BOOL:
16452 
          self.success = iprot.readBool();
16453 
        else:
16454 
          iprot.skip(ftype)
16455 
      elif fid == 1:
16456 
        if ftype == TType.STRUCT:
16457 
          self.cex = CatalogServiceException()
16458 
          self.cex.read(iprot)
16459 
        else:
16460 
          iprot.skip(ftype)
16461 
      else:
16462 
        iprot.skip(ftype)
16463 
      iprot.readFieldEnd()
16464 
    iprot.readStructEnd()
16465 
 
16466 
  def write(self, oprot):
16467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16469 
      return
16470 
    oprot.writeStructBegin('deleteVoucherForItem_result')
16471 
    if self.success is not None:
16472 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16473 
      oprot.writeBool(self.success)
16474 
      oprot.writeFieldEnd()
16475 
    if self.cex is not None:
16476 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16477 
      self.cex.write(oprot)
16478 
      oprot.writeFieldEnd()
16479 
    oprot.writeFieldStop()
16480 
    oprot.writeStructEnd()
16481 
 
16482 
  def validate(self):
16483 
    return
16484 
 
16485 
 
16486 
  def __repr__(self):
16487 
    L = ['%s=%r' % (key, value)
16488 
      for key, value in self.__dict__.iteritems()]
16489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16490 
 
16491 
  def __eq__(self, other):
16492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16493 
 
16494 
  def __ne__(self, other):
16495 
    return not (self == other)
16496 
 
16497 
class getVoucherAmount_args:
16498 
  """
16499 
  Attributes:
16500 
   - itemId
16501 
   - voucherType
16502 
  """
16503 
 
16504 
  thrift_spec = (
16505 
    None, # 0
16506 
    (1, TType.I64, 'itemId', None, None, ), # 1
16507 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16508 
  )
16509 
 
16510 
  def __init__(self, itemId=None, voucherType=None,):
16511 
    self.itemId = itemId
16512 
    self.voucherType = voucherType
16513 
 
16514 
  def read(self, iprot):
16515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16517 
      return
16518 
    iprot.readStructBegin()
16519 
    while True:
16520 
      (fname, ftype, fid) = iprot.readFieldBegin()
16521 
      if ftype == TType.STOP:
16522 
        break
16523 
      if fid == 1:
16524 
        if ftype == TType.I64:
16525 
          self.itemId = iprot.readI64();
16526 
        else:
16527 
          iprot.skip(ftype)
16528 
      elif fid == 2:
16529 
        if ftype == TType.I64:
16530 
          self.voucherType = iprot.readI64();
16531 
        else:
16532 
          iprot.skip(ftype)
16533 
      else:
16534 
        iprot.skip(ftype)
16535 
      iprot.readFieldEnd()
16536 
    iprot.readStructEnd()
16537 
 
16538 
  def write(self, oprot):
16539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16541 
      return
16542 
    oprot.writeStructBegin('getVoucherAmount_args')
16543 
    if self.itemId is not None:
16544 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16545 
      oprot.writeI64(self.itemId)
16546 
      oprot.writeFieldEnd()
16547 
    if self.voucherType is not None:
16548 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16549 
      oprot.writeI64(self.voucherType)
16550 
      oprot.writeFieldEnd()
16551 
    oprot.writeFieldStop()
16552 
    oprot.writeStructEnd()
16553 
 
16554 
  def validate(self):
16555 
    return
16556 
 
16557 
 
16558 
  def __repr__(self):
16559 
    L = ['%s=%r' % (key, value)
16560 
      for key, value in self.__dict__.iteritems()]
16561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16562 
 
16563 
  def __eq__(self, other):
16564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16565 
 
16566 
  def __ne__(self, other):
16567 
    return not (self == other)
16568 
 
16569 
class getVoucherAmount_result:
16570 
  """
16571 
  Attributes:
16572 
   - success
16573 
  """
16574 
 
16575 
  thrift_spec = (
16576 
    (0, TType.I64, 'success', None, None, ), # 0
16577 
  )
16578 
 
16579 
  def __init__(self, success=None,):
16580 
    self.success = success
16581 
 
16582 
  def read(self, iprot):
16583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16585 
      return
16586 
    iprot.readStructBegin()
16587 
    while True:
16588 
      (fname, ftype, fid) = iprot.readFieldBegin()
16589 
      if ftype == TType.STOP:
16590 
        break
16591 
      if fid == 0:
16592 
        if ftype == TType.I64:
16593 
          self.success = iprot.readI64();
16594 
        else:
16595 
          iprot.skip(ftype)
16596 
      else:
16597 
        iprot.skip(ftype)
16598 
      iprot.readFieldEnd()
16599 
    iprot.readStructEnd()
16600 
 
16601 
  def write(self, oprot):
16602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16604 
      return
16605 
    oprot.writeStructBegin('getVoucherAmount_result')
16606 
    if self.success is not None:
16607 
      oprot.writeFieldBegin('success', TType.I64, 0)
16608 
      oprot.writeI64(self.success)
16609 
      oprot.writeFieldEnd()
16610 
    oprot.writeFieldStop()
16611 
    oprot.writeStructEnd()
16612 
 
16613 
  def validate(self):
16614 
    return
16615 
 
16616 
 
16617 
  def __repr__(self):
16618 
    L = ['%s=%r' % (key, value)
16619 
      for key, value in self.__dict__.iteritems()]
16620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16621 
 
16622 
  def __eq__(self, other):
16623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16624 
 
16625 
  def __ne__(self, other):
16626 
    return not (self == other)
16627 
 
16628 
class getAllItemVouchers_args:
16629 
  """
16630 
  Attributes:
16631 
   - itemId
16632 
  """
16633 
 
16634 
  thrift_spec = (
16635 
    None, # 0
16636 
    (1, TType.I64, 'itemId', None, None, ), # 1
16637 
  )
16638 
 
16639 
  def __init__(self, itemId=None,):
16640 
    self.itemId = itemId
16641 
 
16642 
  def read(self, iprot):
16643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16645 
      return
16646 
    iprot.readStructBegin()
16647 
    while True:
16648 
      (fname, ftype, fid) = iprot.readFieldBegin()
16649 
      if ftype == TType.STOP:
16650 
        break
16651 
      if fid == 1:
16652 
        if ftype == TType.I64:
16653 
          self.itemId = iprot.readI64();
16654 
        else:
16655 
          iprot.skip(ftype)
16656 
      else:
16657 
        iprot.skip(ftype)
16658 
      iprot.readFieldEnd()
16659 
    iprot.readStructEnd()
16660 
 
16661 
  def write(self, oprot):
16662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16664 
      return
16665 
    oprot.writeStructBegin('getAllItemVouchers_args')
16666 
    if self.itemId is not None:
16667 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16668 
      oprot.writeI64(self.itemId)
16669 
      oprot.writeFieldEnd()
16670 
    oprot.writeFieldStop()
16671 
    oprot.writeStructEnd()
16672 
 
16673 
  def validate(self):
16674 
    return
16675 
 
16676 
 
16677 
  def __repr__(self):
16678 
    L = ['%s=%r' % (key, value)
16679 
      for key, value in self.__dict__.iteritems()]
16680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16681 
 
16682 
  def __eq__(self, other):
16683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16684 
 
16685 
  def __ne__(self, other):
16686 
    return not (self == other)
16687 
 
16688 
class getAllItemVouchers_result:
16689 
  """
16690 
  Attributes:
16691 
   - success
16692 
  """
16693 
 
16694 
  thrift_spec = (
16695 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
16696 
  )
16697 
 
16698 
  def __init__(self, success=None,):
16699 
    self.success = success
16700 
 
16701 
  def read(self, iprot):
16702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16704 
      return
16705 
    iprot.readStructBegin()
16706 
    while True:
16707 
      (fname, ftype, fid) = iprot.readFieldBegin()
16708 
      if ftype == TType.STOP:
16709 
        break
16710 
      if fid == 0:
16711 
        if ftype == TType.LIST:
16712 
          self.success = []
8579 kshitij.so 16713 
          (_etype333, _size330) = iprot.readListBegin()
16714 
          for _i334 in xrange(_size330):
16715 
            _elem335 = VoucherItemMapping()
16716 
            _elem335.read(iprot)
16717 
            self.success.append(_elem335)
5944 mandeep.dh 16718 
          iprot.readListEnd()
16719 
        else:
16720 
          iprot.skip(ftype)
16721 
      else:
16722 
        iprot.skip(ftype)
16723 
      iprot.readFieldEnd()
16724 
    iprot.readStructEnd()
16725 
 
16726 
  def write(self, oprot):
16727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16729 
      return
16730 
    oprot.writeStructBegin('getAllItemVouchers_result')
16731 
    if self.success is not None:
16732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 16734 
      for iter336 in self.success:
16735 
        iter336.write(oprot)
5944 mandeep.dh 16736 
      oprot.writeListEnd()
16737 
      oprot.writeFieldEnd()
16738 
    oprot.writeFieldStop()
16739 
    oprot.writeStructEnd()
16740 
 
16741 
  def validate(self):
16742 
    return
16743 
 
16744 
 
16745 
  def __repr__(self):
16746 
    L = ['%s=%r' % (key, value)
16747 
      for key, value in self.__dict__.iteritems()]
16748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16749 
 
16750 
  def __eq__(self, other):
16751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16752 
 
16753 
  def __ne__(self, other):
16754 
    return not (self == other)
16755 
 
16756 
class isValidCatalogItemId_args:
16757 
  """
16758 
  Attributes:
16759 
   - catalog_item_id
16760 
  """
16761 
 
16762 
  thrift_spec = (
16763 
    None, # 0
16764 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16765 
  )
16766 
 
16767 
  def __init__(self, catalog_item_id=None,):
16768 
    self.catalog_item_id = catalog_item_id
16769 
 
16770 
  def read(self, iprot):
16771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16773 
      return
16774 
    iprot.readStructBegin()
16775 
    while True:
16776 
      (fname, ftype, fid) = iprot.readFieldBegin()
16777 
      if ftype == TType.STOP:
16778 
        break
16779 
      if fid == 1:
16780 
        if ftype == TType.I64:
16781 
          self.catalog_item_id = iprot.readI64();
16782 
        else:
16783 
          iprot.skip(ftype)
16784 
      else:
16785 
        iprot.skip(ftype)
16786 
      iprot.readFieldEnd()
16787 
    iprot.readStructEnd()
16788 
 
16789 
  def write(self, oprot):
16790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16792 
      return
16793 
    oprot.writeStructBegin('isValidCatalogItemId_args')
16794 
    if self.catalog_item_id is not None:
16795 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16796 
      oprot.writeI64(self.catalog_item_id)
16797 
      oprot.writeFieldEnd()
16798 
    oprot.writeFieldStop()
16799 
    oprot.writeStructEnd()
16800 
 
16801 
  def validate(self):
16802 
    return
16803 
 
16804 
 
16805 
  def __repr__(self):
16806 
    L = ['%s=%r' % (key, value)
16807 
      for key, value in self.__dict__.iteritems()]
16808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16809 
 
16810 
  def __eq__(self, other):
16811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16812 
 
16813 
  def __ne__(self, other):
16814 
    return not (self == other)
16815 
 
16816 
class isValidCatalogItemId_result:
16817 
  """
16818 
  Attributes:
16819 
   - success
16820 
  """
16821 
 
16822 
  thrift_spec = (
16823 
    (0, TType.BOOL, 'success', None, None, ), # 0
16824 
  )
16825 
 
16826 
  def __init__(self, success=None,):
16827 
    self.success = success
16828 
 
16829 
  def read(self, iprot):
16830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16832 
      return
16833 
    iprot.readStructBegin()
16834 
    while True:
16835 
      (fname, ftype, fid) = iprot.readFieldBegin()
16836 
      if ftype == TType.STOP:
16837 
        break
16838 
      if fid == 0:
16839 
        if ftype == TType.BOOL:
16840 
          self.success = iprot.readBool();
16841 
        else:
16842 
          iprot.skip(ftype)
16843 
      else:
16844 
        iprot.skip(ftype)
16845 
      iprot.readFieldEnd()
16846 
    iprot.readStructEnd()
16847 
 
16848 
  def write(self, oprot):
16849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16851 
      return
16852 
    oprot.writeStructBegin('isValidCatalogItemId_result')
16853 
    if self.success is not None:
16854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16855 
      oprot.writeBool(self.success)
16856 
      oprot.writeFieldEnd()
16857 
    oprot.writeFieldStop()
16858 
    oprot.writeStructEnd()
16859 
 
16860 
  def validate(self):
16861 
    return
16862 
 
16863 
 
16864 
  def __repr__(self):
16865 
    L = ['%s=%r' % (key, value)
16866 
      for key, value in self.__dict__.iteritems()]
16867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16868 
 
16869 
  def __eq__(self, other):
16870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16871 
 
16872 
  def __ne__(self, other):
16873 
    return not (self == other)
6039 amit.gupta 16874 
 
16875 
class getVatPercentageForItem_args:
16876 
  """
16877 
  Attributes:
16878 
   - itemId
7330 amit.gupta 16879 
   - stateId
6039 amit.gupta 16880 
   - price
16881 
  """
16882 
 
16883 
  thrift_spec = (
16884 
    None, # 0
16885 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 16886 
    (2, TType.I64, 'stateId', None, None, ), # 2
16887 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 16888 
  )
16889 
 
7330 amit.gupta 16890 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 16891 
    self.itemId = itemId
7330 amit.gupta 16892 
    self.stateId = stateId
6039 amit.gupta 16893 
    self.price = price
16894 
 
16895 
  def read(self, iprot):
16896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16898 
      return
16899 
    iprot.readStructBegin()
16900 
    while True:
16901 
      (fname, ftype, fid) = iprot.readFieldBegin()
16902 
      if ftype == TType.STOP:
16903 
        break
16904 
      if fid == 1:
16905 
        if ftype == TType.I64:
16906 
          self.itemId = iprot.readI64();
16907 
        else:
16908 
          iprot.skip(ftype)
16909 
      elif fid == 2:
7330 amit.gupta 16910 
        if ftype == TType.I64:
16911 
          self.stateId = iprot.readI64();
16912 
        else:
16913 
          iprot.skip(ftype)
16914 
      elif fid == 3:
6039 amit.gupta 16915 
        if ftype == TType.DOUBLE:
16916 
          self.price = iprot.readDouble();
16917 
        else:
16918 
          iprot.skip(ftype)
16919 
      else:
16920 
        iprot.skip(ftype)
16921 
      iprot.readFieldEnd()
16922 
    iprot.readStructEnd()
16923 
 
16924 
  def write(self, oprot):
16925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16927 
      return
16928 
    oprot.writeStructBegin('getVatPercentageForItem_args')
16929 
    if self.itemId is not None:
16930 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16931 
      oprot.writeI64(self.itemId)
16932 
      oprot.writeFieldEnd()
7330 amit.gupta 16933 
    if self.stateId is not None:
16934 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
16935 
      oprot.writeI64(self.stateId)
16936 
      oprot.writeFieldEnd()
6039 amit.gupta 16937 
    if self.price is not None:
7330 amit.gupta 16938 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 16939 
      oprot.writeDouble(self.price)
16940 
      oprot.writeFieldEnd()
16941 
    oprot.writeFieldStop()
16942 
    oprot.writeStructEnd()
16943 
 
16944 
  def validate(self):
16945 
    return
16946 
 
16947 
 
16948 
  def __repr__(self):
16949 
    L = ['%s=%r' % (key, value)
16950 
      for key, value in self.__dict__.iteritems()]
16951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16952 
 
16953 
  def __eq__(self, other):
16954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16955 
 
16956 
  def __ne__(self, other):
16957 
    return not (self == other)
16958 
 
16959 
class getVatPercentageForItem_result:
16960 
  """
16961 
  Attributes:
16962 
   - success
7340 amit.gupta 16963 
   - cex
6039 amit.gupta 16964 
  """
16965 
 
16966 
  thrift_spec = (
16967 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 16968 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 16969 
  )
16970 
 
7340 amit.gupta 16971 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 16972 
    self.success = success
7340 amit.gupta 16973 
    self.cex = cex
6039 amit.gupta 16974 
 
16975 
  def read(self, iprot):
16976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16978 
      return
16979 
    iprot.readStructBegin()
16980 
    while True:
16981 
      (fname, ftype, fid) = iprot.readFieldBegin()
16982 
      if ftype == TType.STOP:
16983 
        break
16984 
      if fid == 0:
16985 
        if ftype == TType.DOUBLE:
16986 
          self.success = iprot.readDouble();
16987 
        else:
16988 
          iprot.skip(ftype)
7340 amit.gupta 16989 
      elif fid == 1:
16990 
        if ftype == TType.STRUCT:
16991 
          self.cex = CatalogServiceException()
16992 
          self.cex.read(iprot)
16993 
        else:
16994 
          iprot.skip(ftype)
6039 amit.gupta 16995 
      else:
16996 
        iprot.skip(ftype)
16997 
      iprot.readFieldEnd()
16998 
    iprot.readStructEnd()
16999 
 
17000 
  def write(self, oprot):
17001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17003 
      return
17004 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17005 
    if self.success is not None:
17006 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17007 
      oprot.writeDouble(self.success)
17008 
      oprot.writeFieldEnd()
7340 amit.gupta 17009 
    if self.cex is not None:
17010 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17011 
      self.cex.write(oprot)
17012 
      oprot.writeFieldEnd()
6039 amit.gupta 17013 
    oprot.writeFieldStop()
17014 
    oprot.writeStructEnd()
17015 
 
17016 
  def validate(self):
17017 
    return
17018 
 
17019 
 
17020 
  def __repr__(self):
17021 
    L = ['%s=%r' % (key, value)
17022 
      for key, value in self.__dict__.iteritems()]
17023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17024 
 
17025 
  def __eq__(self, other):
17026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17027 
 
17028 
  def __ne__(self, other):
17029 
    return not (self == other)
17030 
 
17031 
class getVatAmountForItem_args:
17032 
  """
17033 
  Attributes:
17034 
   - itemId
17035 
   - price
17036 
  """
17037 
 
17038 
  thrift_spec = (
17039 
    None, # 0
17040 
    (1, TType.I64, 'itemId', None, None, ), # 1
17041 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17042 
  )
17043 
 
17044 
  def __init__(self, itemId=None, price=None,):
17045 
    self.itemId = itemId
17046 
    self.price = price
17047 
 
17048 
  def read(self, iprot):
17049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17051 
      return
17052 
    iprot.readStructBegin()
17053 
    while True:
17054 
      (fname, ftype, fid) = iprot.readFieldBegin()
17055 
      if ftype == TType.STOP:
17056 
        break
17057 
      if fid == 1:
17058 
        if ftype == TType.I64:
17059 
          self.itemId = iprot.readI64();
17060 
        else:
17061 
          iprot.skip(ftype)
17062 
      elif fid == 2:
17063 
        if ftype == TType.DOUBLE:
17064 
          self.price = iprot.readDouble();
17065 
        else:
17066 
          iprot.skip(ftype)
17067 
      else:
17068 
        iprot.skip(ftype)
17069 
      iprot.readFieldEnd()
17070 
    iprot.readStructEnd()
17071 
 
17072 
  def write(self, oprot):
17073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17075 
      return
17076 
    oprot.writeStructBegin('getVatAmountForItem_args')
17077 
    if self.itemId is not None:
17078 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17079 
      oprot.writeI64(self.itemId)
17080 
      oprot.writeFieldEnd()
17081 
    if self.price is not None:
17082 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17083 
      oprot.writeDouble(self.price)
17084 
      oprot.writeFieldEnd()
17085 
    oprot.writeFieldStop()
17086 
    oprot.writeStructEnd()
17087 
 
17088 
  def validate(self):
17089 
    return
17090 
 
17091 
 
17092 
  def __repr__(self):
17093 
    L = ['%s=%r' % (key, value)
17094 
      for key, value in self.__dict__.iteritems()]
17095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17096 
 
17097 
  def __eq__(self, other):
17098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17099 
 
17100 
  def __ne__(self, other):
17101 
    return not (self == other)
17102 
 
17103 
class getVatAmountForItem_result:
17104 
  """
17105 
  Attributes:
17106 
   - success
17107 
  """
17108 
 
17109 
  thrift_spec = (
17110 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17111 
  )
17112 
 
17113 
  def __init__(self, success=None,):
17114 
    self.success = success
17115 
 
17116 
  def read(self, iprot):
17117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17119 
      return
17120 
    iprot.readStructBegin()
17121 
    while True:
17122 
      (fname, ftype, fid) = iprot.readFieldBegin()
17123 
      if ftype == TType.STOP:
17124 
        break
17125 
      if fid == 0:
17126 
        if ftype == TType.DOUBLE:
17127 
          self.success = iprot.readDouble();
17128 
        else:
17129 
          iprot.skip(ftype)
17130 
      else:
17131 
        iprot.skip(ftype)
17132 
      iprot.readFieldEnd()
17133 
    iprot.readStructEnd()
17134 
 
17135 
  def write(self, oprot):
17136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17138 
      return
17139 
    oprot.writeStructBegin('getVatAmountForItem_result')
17140 
    if self.success is not None:
17141 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17142 
      oprot.writeDouble(self.success)
17143 
      oprot.writeFieldEnd()
17144 
    oprot.writeFieldStop()
17145 
    oprot.writeStructEnd()
17146 
 
17147 
  def validate(self):
17148 
    return
17149 
 
17150 
 
17151 
  def __repr__(self):
17152 
    L = ['%s=%r' % (key, value)
17153 
      for key, value in self.__dict__.iteritems()]
17154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17155 
 
17156 
  def __eq__(self, other):
17157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17158 
 
17159 
  def __ne__(self, other):
17160 
    return not (self == other)
6531 vikram.rag 17161 
 
17162 
class getAllIgnoredInventoryUpdateItemsList_args:
17163 
  """
17164 
  Attributes:
17165 
   - offset
17166 
   - limit
17167 
  """
17168 
 
17169 
  thrift_spec = (
17170 
    None, # 0
17171 
    (1, TType.I32, 'offset', None, None, ), # 1
17172 
    (2, TType.I32, 'limit', None, None, ), # 2
17173 
  )
17174 
 
17175 
  def __init__(self, offset=None, limit=None,):
17176 
    self.offset = offset
17177 
    self.limit = limit
17178 
 
17179 
  def read(self, iprot):
17180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17182 
      return
17183 
    iprot.readStructBegin()
17184 
    while True:
17185 
      (fname, ftype, fid) = iprot.readFieldBegin()
17186 
      if ftype == TType.STOP:
17187 
        break
17188 
      if fid == 1:
17189 
        if ftype == TType.I32:
17190 
          self.offset = iprot.readI32();
17191 
        else:
17192 
          iprot.skip(ftype)
17193 
      elif fid == 2:
17194 
        if ftype == TType.I32:
17195 
          self.limit = iprot.readI32();
17196 
        else:
17197 
          iprot.skip(ftype)
17198 
      else:
17199 
        iprot.skip(ftype)
17200 
      iprot.readFieldEnd()
17201 
    iprot.readStructEnd()
17202 
 
17203 
  def write(self, oprot):
17204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17206 
      return
17207 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17208 
    if self.offset is not None:
17209 
      oprot.writeFieldBegin('offset', TType.I32, 1)
17210 
      oprot.writeI32(self.offset)
17211 
      oprot.writeFieldEnd()
17212 
    if self.limit is not None:
17213 
      oprot.writeFieldBegin('limit', TType.I32, 2)
17214 
      oprot.writeI32(self.limit)
17215 
      oprot.writeFieldEnd()
17216 
    oprot.writeFieldStop()
17217 
    oprot.writeStructEnd()
17218 
 
17219 
  def validate(self):
17220 
    return
17221 
 
17222 
 
17223 
  def __repr__(self):
17224 
    L = ['%s=%r' % (key, value)
17225 
      for key, value in self.__dict__.iteritems()]
17226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17227 
 
17228 
  def __eq__(self, other):
17229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17230 
 
17231 
  def __ne__(self, other):
17232 
    return not (self == other)
17233 
 
17234 
class getAllIgnoredInventoryUpdateItemsList_result:
17235 
  """
17236 
  Attributes:
17237 
   - success
17238 
  """
17239 
 
17240 
  thrift_spec = (
17241 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17242 
  )
17243 
 
17244 
  def __init__(self, success=None,):
17245 
    self.success = success
17246 
 
17247 
  def read(self, iprot):
17248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17250 
      return
17251 
    iprot.readStructBegin()
17252 
    while True:
17253 
      (fname, ftype, fid) = iprot.readFieldBegin()
17254 
      if ftype == TType.STOP:
17255 
        break
17256 
      if fid == 0:
17257 
        if ftype == TType.LIST:
17258 
          self.success = []
8579 kshitij.so 17259 
          (_etype340, _size337) = iprot.readListBegin()
17260 
          for _i341 in xrange(_size337):
17261 
            _elem342 = Item()
17262 
            _elem342.read(iprot)
17263 
            self.success.append(_elem342)
6531 vikram.rag 17264 
          iprot.readListEnd()
17265 
        else:
17266 
          iprot.skip(ftype)
17267 
      else:
17268 
        iprot.skip(ftype)
17269 
      iprot.readFieldEnd()
17270 
    iprot.readStructEnd()
17271 
 
17272 
  def write(self, oprot):
17273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17275 
      return
17276 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
17277 
    if self.success is not None:
17278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17279 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 17280 
      for iter343 in self.success:
17281 
        iter343.write(oprot)
6531 vikram.rag 17282 
      oprot.writeListEnd()
17283 
      oprot.writeFieldEnd()
17284 
    oprot.writeFieldStop()
17285 
    oprot.writeStructEnd()
17286 
 
17287 
  def validate(self):
17288 
    return
17289 
 
17290 
 
17291 
  def __repr__(self):
17292 
    L = ['%s=%r' % (key, value)
17293 
      for key, value in self.__dict__.iteritems()]
17294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17295 
 
17296 
  def __eq__(self, other):
17297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17298 
 
17299 
  def __ne__(self, other):
17300 
    return not (self == other)
6805 anupam.sin 17301 
 
6821 amar.kumar 17302 
class getAllAliveItems_args:
17303 
 
17304 
  thrift_spec = (
17305 
  )
17306 
 
17307 
  def read(self, iprot):
17308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17310 
      return
17311 
    iprot.readStructBegin()
17312 
    while True:
17313 
      (fname, ftype, fid) = iprot.readFieldBegin()
17314 
      if ftype == TType.STOP:
17315 
        break
17316 
      else:
17317 
        iprot.skip(ftype)
17318 
      iprot.readFieldEnd()
17319 
    iprot.readStructEnd()
17320 
 
17321 
  def write(self, oprot):
17322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17324 
      return
17325 
    oprot.writeStructBegin('getAllAliveItems_args')
17326 
    oprot.writeFieldStop()
17327 
    oprot.writeStructEnd()
17328 
 
17329 
  def validate(self):
17330 
    return
17331 
 
17332 
 
17333 
  def __repr__(self):
17334 
    L = ['%s=%r' % (key, value)
17335 
      for key, value in self.__dict__.iteritems()]
17336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17337 
 
17338 
  def __eq__(self, other):
17339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17340 
 
17341 
  def __ne__(self, other):
17342 
    return not (self == other)
17343 
 
17344 
class getAllAliveItems_result:
17345 
  """
17346 
  Attributes:
17347 
   - success
17348 
  """
17349 
 
17350 
  thrift_spec = (
17351 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17352 
  )
17353 
 
17354 
  def __init__(self, success=None,):
17355 
    self.success = success
17356 
 
17357 
  def read(self, iprot):
17358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17360 
      return
17361 
    iprot.readStructBegin()
17362 
    while True:
17363 
      (fname, ftype, fid) = iprot.readFieldBegin()
17364 
      if ftype == TType.STOP:
17365 
        break
17366 
      if fid == 0:
17367 
        if ftype == TType.LIST:
17368 
          self.success = []
8579 kshitij.so 17369 
          (_etype347, _size344) = iprot.readListBegin()
17370 
          for _i348 in xrange(_size344):
17371 
            _elem349 = Item()
17372 
            _elem349.read(iprot)
17373 
            self.success.append(_elem349)
6821 amar.kumar 17374 
          iprot.readListEnd()
17375 
        else:
17376 
          iprot.skip(ftype)
17377 
      else:
17378 
        iprot.skip(ftype)
17379 
      iprot.readFieldEnd()
17380 
    iprot.readStructEnd()
17381 
 
17382 
  def write(self, oprot):
17383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17385 
      return
17386 
    oprot.writeStructBegin('getAllAliveItems_result')
17387 
    if self.success is not None:
17388 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17389 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 17390 
      for iter350 in self.success:
17391 
        iter350.write(oprot)
6821 amar.kumar 17392 
      oprot.writeListEnd()
17393 
      oprot.writeFieldEnd()
17394 
    oprot.writeFieldStop()
17395 
    oprot.writeStructEnd()
17396 
 
17397 
  def validate(self):
17398 
    return
17399 
 
17400 
 
17401 
  def __repr__(self):
17402 
    L = ['%s=%r' % (key, value)
17403 
      for key, value in self.__dict__.iteritems()]
17404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17405 
 
17406 
  def __eq__(self, other):
17407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17408 
 
17409 
  def __ne__(self, other):
17410 
    return not (self == other)
17411 
 
6805 anupam.sin 17412 
class getInsuranceAmount_args:
17413 
  """
17414 
  Attributes:
17415 
   - itemId
6921 anupam.sin 17416 
   - price
6805 anupam.sin 17417 
   - insurerId
17418 
   - quantity
17419 
  """
17420 
 
17421 
  thrift_spec = (
17422 
    None, # 0
17423 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 17424 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17425 
    (3, TType.I64, 'insurerId', None, None, ), # 3
17426 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 17427 
  )
17428 
 
6921 anupam.sin 17429 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 17430 
    self.itemId = itemId
6921 anupam.sin 17431 
    self.price = price
6805 anupam.sin 17432 
    self.insurerId = insurerId
17433 
    self.quantity = quantity
17434 
 
17435 
  def read(self, iprot):
17436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17438 
      return
17439 
    iprot.readStructBegin()
17440 
    while True:
17441 
      (fname, ftype, fid) = iprot.readFieldBegin()
17442 
      if ftype == TType.STOP:
17443 
        break
17444 
      if fid == 1:
17445 
        if ftype == TType.I64:
17446 
          self.itemId = iprot.readI64();
17447 
        else:
17448 
          iprot.skip(ftype)
17449 
      elif fid == 2:
6921 anupam.sin 17450 
        if ftype == TType.DOUBLE:
17451 
          self.price = iprot.readDouble();
17452 
        else:
17453 
          iprot.skip(ftype)
17454 
      elif fid == 3:
6805 anupam.sin 17455 
        if ftype == TType.I64:
17456 
          self.insurerId = iprot.readI64();
17457 
        else:
17458 
          iprot.skip(ftype)
6921 anupam.sin 17459 
      elif fid == 4:
6805 anupam.sin 17460 
        if ftype == TType.I64:
17461 
          self.quantity = iprot.readI64();
17462 
        else:
17463 
          iprot.skip(ftype)
17464 
      else:
17465 
        iprot.skip(ftype)
17466 
      iprot.readFieldEnd()
17467 
    iprot.readStructEnd()
17468 
 
17469 
  def write(self, oprot):
17470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17472 
      return
17473 
    oprot.writeStructBegin('getInsuranceAmount_args')
17474 
    if self.itemId is not None:
17475 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17476 
      oprot.writeI64(self.itemId)
17477 
      oprot.writeFieldEnd()
6921 anupam.sin 17478 
    if self.price is not None:
17479 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17480 
      oprot.writeDouble(self.price)
17481 
      oprot.writeFieldEnd()
6805 anupam.sin 17482 
    if self.insurerId is not None:
6921 anupam.sin 17483 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 17484 
      oprot.writeI64(self.insurerId)
17485 
      oprot.writeFieldEnd()
17486 
    if self.quantity is not None:
6921 anupam.sin 17487 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 17488 
      oprot.writeI64(self.quantity)
17489 
      oprot.writeFieldEnd()
17490 
    oprot.writeFieldStop()
17491 
    oprot.writeStructEnd()
17492 
 
17493 
  def validate(self):
17494 
    return
17495 
 
17496 
 
17497 
  def __repr__(self):
17498 
    L = ['%s=%r' % (key, value)
17499 
      for key, value in self.__dict__.iteritems()]
17500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17501 
 
17502 
  def __eq__(self, other):
17503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17504 
 
17505 
  def __ne__(self, other):
17506 
    return not (self == other)
17507 
 
17508 
class getInsuranceAmount_result:
17509 
  """
17510 
  Attributes:
17511 
   - success
17512 
  """
17513 
 
17514 
  thrift_spec = (
17515 
    (0, TType.I64, 'success', None, None, ), # 0
17516 
  )
17517 
 
17518 
  def __init__(self, success=None,):
17519 
    self.success = success
17520 
 
17521 
  def read(self, iprot):
17522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17524 
      return
17525 
    iprot.readStructBegin()
17526 
    while True:
17527 
      (fname, ftype, fid) = iprot.readFieldBegin()
17528 
      if ftype == TType.STOP:
17529 
        break
17530 
      if fid == 0:
17531 
        if ftype == TType.I64:
17532 
          self.success = iprot.readI64();
17533 
        else:
17534 
          iprot.skip(ftype)
17535 
      else:
17536 
        iprot.skip(ftype)
17537 
      iprot.readFieldEnd()
17538 
    iprot.readStructEnd()
17539 
 
17540 
  def write(self, oprot):
17541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17543 
      return
17544 
    oprot.writeStructBegin('getInsuranceAmount_result')
17545 
    if self.success is not None:
17546 
      oprot.writeFieldBegin('success', TType.I64, 0)
17547 
      oprot.writeI64(self.success)
17548 
      oprot.writeFieldEnd()
17549 
    oprot.writeFieldStop()
17550 
    oprot.writeStructEnd()
17551 
 
17552 
  def validate(self):
17553 
    return
17554 
 
17555 
 
17556 
  def __repr__(self):
17557 
    L = ['%s=%r' % (key, value)
17558 
      for key, value in self.__dict__.iteritems()]
17559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17560 
 
17561 
  def __eq__(self, other):
17562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17563 
 
17564 
  def __ne__(self, other):
17565 
    return not (self == other)
17566 
 
17567 
class getInsurer_args:
17568 
  """
17569 
  Attributes:
17570 
   - insurerId
17571 
  """
17572 
 
17573 
  thrift_spec = (
17574 
    None, # 0
17575 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17576 
  )
17577 
 
17578 
  def __init__(self, insurerId=None,):
17579 
    self.insurerId = insurerId
17580 
 
17581 
  def read(self, iprot):
17582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17584 
      return
17585 
    iprot.readStructBegin()
17586 
    while True:
17587 
      (fname, ftype, fid) = iprot.readFieldBegin()
17588 
      if ftype == TType.STOP:
17589 
        break
17590 
      if fid == 1:
17591 
        if ftype == TType.I64:
17592 
          self.insurerId = iprot.readI64();
17593 
        else:
17594 
          iprot.skip(ftype)
17595 
      else:
17596 
        iprot.skip(ftype)
17597 
      iprot.readFieldEnd()
17598 
    iprot.readStructEnd()
17599 
 
17600 
  def write(self, oprot):
17601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17603 
      return
17604 
    oprot.writeStructBegin('getInsurer_args')
17605 
    if self.insurerId is not None:
17606 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17607 
      oprot.writeI64(self.insurerId)
17608 
      oprot.writeFieldEnd()
17609 
    oprot.writeFieldStop()
17610 
    oprot.writeStructEnd()
17611 
 
17612 
  def validate(self):
17613 
    return
17614 
 
17615 
 
17616 
  def __repr__(self):
17617 
    L = ['%s=%r' % (key, value)
17618 
      for key, value in self.__dict__.iteritems()]
17619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17620 
 
17621 
  def __eq__(self, other):
17622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17623 
 
17624 
  def __ne__(self, other):
17625 
    return not (self == other)
17626 
 
17627 
class getInsurer_result:
17628 
  """
17629 
  Attributes:
17630 
   - success
17631 
  """
17632 
 
17633 
  thrift_spec = (
17634 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
17635 
  )
17636 
 
17637 
  def __init__(self, success=None,):
17638 
    self.success = success
17639 
 
17640 
  def read(self, iprot):
17641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17643 
      return
17644 
    iprot.readStructBegin()
17645 
    while True:
17646 
      (fname, ftype, fid) = iprot.readFieldBegin()
17647 
      if ftype == TType.STOP:
17648 
        break
17649 
      if fid == 0:
17650 
        if ftype == TType.STRUCT:
17651 
          self.success = Insurer()
17652 
          self.success.read(iprot)
17653 
        else:
17654 
          iprot.skip(ftype)
17655 
      else:
17656 
        iprot.skip(ftype)
17657 
      iprot.readFieldEnd()
17658 
    iprot.readStructEnd()
17659 
 
17660 
  def write(self, oprot):
17661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17663 
      return
17664 
    oprot.writeStructBegin('getInsurer_result')
17665 
    if self.success is not None:
17666 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17667 
      self.success.write(oprot)
17668 
      oprot.writeFieldEnd()
17669 
    oprot.writeFieldStop()
17670 
    oprot.writeStructEnd()
17671 
 
17672 
  def validate(self):
17673 
    return
17674 
 
17675 
 
17676 
  def __repr__(self):
17677 
    L = ['%s=%r' % (key, value)
17678 
      for key, value in self.__dict__.iteritems()]
17679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17680 
 
17681 
  def __eq__(self, other):
17682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17683 
 
17684 
  def __ne__(self, other):
17685 
    return not (self == other)
6838 vikram.rag 17686 
 
17687 
class getAllInsurers_args:
17688 
 
17689 
  thrift_spec = (
17690 
  )
17691 
 
17692 
  def read(self, iprot):
17693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17695 
      return
17696 
    iprot.readStructBegin()
17697 
    while True:
17698 
      (fname, ftype, fid) = iprot.readFieldBegin()
17699 
      if ftype == TType.STOP:
17700 
        break
17701 
      else:
17702 
        iprot.skip(ftype)
17703 
      iprot.readFieldEnd()
17704 
    iprot.readStructEnd()
17705 
 
17706 
  def write(self, oprot):
17707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17709 
      return
17710 
    oprot.writeStructBegin('getAllInsurers_args')
17711 
    oprot.writeFieldStop()
17712 
    oprot.writeStructEnd()
17713 
 
17714 
  def validate(self):
17715 
    return
17716 
 
17717 
 
17718 
  def __repr__(self):
17719 
    L = ['%s=%r' % (key, value)
17720 
      for key, value in self.__dict__.iteritems()]
17721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17722 
 
17723 
  def __eq__(self, other):
17724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17725 
 
17726 
  def __ne__(self, other):
17727 
    return not (self == other)
17728 
 
17729 
class getAllInsurers_result:
17730 
  """
17731 
  Attributes:
17732 
   - success
17733 
  """
17734 
 
17735 
  thrift_spec = (
17736 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
17737 
  )
17738 
 
17739 
  def __init__(self, success=None,):
17740 
    self.success = success
17741 
 
17742 
  def read(self, iprot):
17743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17745 
      return
17746 
    iprot.readStructBegin()
17747 
    while True:
17748 
      (fname, ftype, fid) = iprot.readFieldBegin()
17749 
      if ftype == TType.STOP:
17750 
        break
17751 
      if fid == 0:
17752 
        if ftype == TType.LIST:
17753 
          self.success = []
8579 kshitij.so 17754 
          (_etype354, _size351) = iprot.readListBegin()
17755 
          for _i355 in xrange(_size351):
17756 
            _elem356 = Insurer()
17757 
            _elem356.read(iprot)
17758 
            self.success.append(_elem356)
6838 vikram.rag 17759 
          iprot.readListEnd()
17760 
        else:
17761 
          iprot.skip(ftype)
17762 
      else:
17763 
        iprot.skip(ftype)
17764 
      iprot.readFieldEnd()
17765 
    iprot.readStructEnd()
17766 
 
17767 
  def write(self, oprot):
17768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17770 
      return
17771 
    oprot.writeStructBegin('getAllInsurers_result')
17772 
    if self.success is not None:
17773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 17775 
      for iter357 in self.success:
17776 
        iter357.write(oprot)
6838 vikram.rag 17777 
      oprot.writeListEnd()
17778 
      oprot.writeFieldEnd()
17779 
    oprot.writeFieldStop()
17780 
    oprot.writeStructEnd()
17781 
 
17782 
  def validate(self):
17783 
    return
17784 
 
17785 
 
17786 
  def __repr__(self):
17787 
    L = ['%s=%r' % (key, value)
17788 
      for key, value in self.__dict__.iteritems()]
17789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17790 
 
17791 
  def __eq__(self, other):
17792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17793 
 
17794 
  def __ne__(self, other):
17795 
    return not (self == other)
6962 rajveer 17796 
 
17797 
class updateInsuranceDeclaredAmount_args:
17798 
  """
17799 
  Attributes:
17800 
   - insurerId
17801 
   - amount
17802 
  """
17803 
 
17804 
  thrift_spec = (
17805 
    None, # 0
17806 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17807 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
17808 
  )
17809 
 
17810 
  def __init__(self, insurerId=None, amount=None,):
17811 
    self.insurerId = insurerId
17812 
    self.amount = amount
17813 
 
17814 
  def read(self, iprot):
17815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17817 
      return
17818 
    iprot.readStructBegin()
17819 
    while True:
17820 
      (fname, ftype, fid) = iprot.readFieldBegin()
17821 
      if ftype == TType.STOP:
17822 
        break
17823 
      if fid == 1:
17824 
        if ftype == TType.I64:
17825 
          self.insurerId = iprot.readI64();
17826 
        else:
17827 
          iprot.skip(ftype)
17828 
      elif fid == 2:
17829 
        if ftype == TType.DOUBLE:
17830 
          self.amount = iprot.readDouble();
17831 
        else:
17832 
          iprot.skip(ftype)
17833 
      else:
17834 
        iprot.skip(ftype)
17835 
      iprot.readFieldEnd()
17836 
    iprot.readStructEnd()
17837 
 
17838 
  def write(self, oprot):
17839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17841 
      return
17842 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
17843 
    if self.insurerId is not None:
17844 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17845 
      oprot.writeI64(self.insurerId)
17846 
      oprot.writeFieldEnd()
17847 
    if self.amount is not None:
17848 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
17849 
      oprot.writeDouble(self.amount)
17850 
      oprot.writeFieldEnd()
17851 
    oprot.writeFieldStop()
17852 
    oprot.writeStructEnd()
17853 
 
17854 
  def validate(self):
17855 
    return
17856 
 
17857 
 
17858 
  def __repr__(self):
17859 
    L = ['%s=%r' % (key, value)
17860 
      for key, value in self.__dict__.iteritems()]
17861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17862 
 
17863 
  def __eq__(self, other):
17864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17865 
 
17866 
  def __ne__(self, other):
17867 
    return not (self == other)
17868 
 
17869 
class updateInsuranceDeclaredAmount_result:
17870 
 
17871 
  thrift_spec = (
17872 
  )
17873 
 
17874 
  def read(self, iprot):
17875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17877 
      return
17878 
    iprot.readStructBegin()
17879 
    while True:
17880 
      (fname, ftype, fid) = iprot.readFieldBegin()
17881 
      if ftype == TType.STOP:
17882 
        break
17883 
      else:
17884 
        iprot.skip(ftype)
17885 
      iprot.readFieldEnd()
17886 
    iprot.readStructEnd()
17887 
 
17888 
  def write(self, oprot):
17889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17891 
      return
17892 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
17893 
    oprot.writeFieldStop()
17894 
    oprot.writeStructEnd()
17895 
 
17896 
  def validate(self):
17897 
    return
17898 
 
17899 
 
17900 
  def __repr__(self):
17901 
    L = ['%s=%r' % (key, value)
17902 
      for key, value in self.__dict__.iteritems()]
17903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17904 
 
17905 
  def __eq__(self, other):
17906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17907 
 
17908 
  def __ne__(self, other):
17909 
    return not (self == other)
7190 amar.kumar 17910 
 
17911 
class getFreebieForItem_args:
17912 
  """
17913 
  Attributes:
17914 
   - itemId
17915 
  """
17916 
 
17917 
  thrift_spec = (
17918 
    None, # 0
17919 
    (1, TType.I64, 'itemId', None, None, ), # 1
17920 
  )
17921 
 
17922 
  def __init__(self, itemId=None,):
17923 
    self.itemId = itemId
17924 
 
17925 
  def read(self, iprot):
17926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17928 
      return
17929 
    iprot.readStructBegin()
17930 
    while True:
17931 
      (fname, ftype, fid) = iprot.readFieldBegin()
17932 
      if ftype == TType.STOP:
17933 
        break
17934 
      if fid == 1:
17935 
        if ftype == TType.I64:
17936 
          self.itemId = iprot.readI64();
17937 
        else:
17938 
          iprot.skip(ftype)
17939 
      else:
17940 
        iprot.skip(ftype)
17941 
      iprot.readFieldEnd()
17942 
    iprot.readStructEnd()
17943 
 
17944 
  def write(self, oprot):
17945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17947 
      return
17948 
    oprot.writeStructBegin('getFreebieForItem_args')
17949 
    if self.itemId is not None:
17950 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17951 
      oprot.writeI64(self.itemId)
17952 
      oprot.writeFieldEnd()
17953 
    oprot.writeFieldStop()
17954 
    oprot.writeStructEnd()
17955 
 
17956 
  def validate(self):
17957 
    return
17958 
 
17959 
 
17960 
  def __repr__(self):
17961 
    L = ['%s=%r' % (key, value)
17962 
      for key, value in self.__dict__.iteritems()]
17963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17964 
 
17965 
  def __eq__(self, other):
17966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17967 
 
17968 
  def __ne__(self, other):
17969 
    return not (self == other)
17970 
 
17971 
class getFreebieForItem_result:
17972 
  """
17973 
  Attributes:
17974 
   - success
17975 
  """
17976 
 
17977 
  thrift_spec = (
17978 
    (0, TType.I64, 'success', None, None, ), # 0
17979 
  )
17980 
 
17981 
  def __init__(self, success=None,):
17982 
    self.success = success
17983 
 
17984 
  def read(self, iprot):
17985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17987 
      return
17988 
    iprot.readStructBegin()
17989 
    while True:
17990 
      (fname, ftype, fid) = iprot.readFieldBegin()
17991 
      if ftype == TType.STOP:
17992 
        break
17993 
      if fid == 0:
17994 
        if ftype == TType.I64:
17995 
          self.success = iprot.readI64();
17996 
        else:
17997 
          iprot.skip(ftype)
17998 
      else:
17999 
        iprot.skip(ftype)
18000 
      iprot.readFieldEnd()
18001 
    iprot.readStructEnd()
18002 
 
18003 
  def write(self, oprot):
18004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18006 
      return
18007 
    oprot.writeStructBegin('getFreebieForItem_result')
18008 
    if self.success is not None:
18009 
      oprot.writeFieldBegin('success', TType.I64, 0)
18010 
      oprot.writeI64(self.success)
18011 
      oprot.writeFieldEnd()
18012 
    oprot.writeFieldStop()
18013 
    oprot.writeStructEnd()
18014 
 
18015 
  def validate(self):
18016 
    return
18017 
 
18018 
 
18019 
  def __repr__(self):
18020 
    L = ['%s=%r' % (key, value)
18021 
      for key, value in self.__dict__.iteritems()]
18022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18023 
 
18024 
  def __eq__(self, other):
18025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18026 
 
18027 
  def __ne__(self, other):
18028 
    return not (self == other)
18029 
 
18030 
class addOrUpdateFreebieForItem_args:
18031 
  """
18032 
  Attributes:
18033 
   - freebieItem
18034 
  """
18035 
 
18036 
  thrift_spec = (
18037 
    None, # 0
18038 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18039 
  )
18040 
 
18041 
  def __init__(self, freebieItem=None,):
18042 
    self.freebieItem = freebieItem
18043 
 
18044 
  def read(self, iprot):
18045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18047 
      return
18048 
    iprot.readStructBegin()
18049 
    while True:
18050 
      (fname, ftype, fid) = iprot.readFieldBegin()
18051 
      if ftype == TType.STOP:
18052 
        break
18053 
      if fid == 1:
18054 
        if ftype == TType.STRUCT:
18055 
          self.freebieItem = FreebieItem()
18056 
          self.freebieItem.read(iprot)
18057 
        else:
18058 
          iprot.skip(ftype)
18059 
      else:
18060 
        iprot.skip(ftype)
18061 
      iprot.readFieldEnd()
18062 
    iprot.readStructEnd()
18063 
 
18064 
  def write(self, oprot):
18065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18067 
      return
18068 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18069 
    if self.freebieItem is not None:
18070 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18071 
      self.freebieItem.write(oprot)
18072 
      oprot.writeFieldEnd()
18073 
    oprot.writeFieldStop()
18074 
    oprot.writeStructEnd()
18075 
 
18076 
  def validate(self):
18077 
    return
18078 
 
18079 
 
18080 
  def __repr__(self):
18081 
    L = ['%s=%r' % (key, value)
18082 
      for key, value in self.__dict__.iteritems()]
18083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18084 
 
18085 
  def __eq__(self, other):
18086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18087 
 
18088 
  def __ne__(self, other):
18089 
    return not (self == other)
18090 
 
18091 
class addOrUpdateFreebieForItem_result:
18092 
 
18093 
  thrift_spec = (
18094 
  )
18095 
 
18096 
  def read(self, iprot):
18097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18099 
      return
18100 
    iprot.readStructBegin()
18101 
    while True:
18102 
      (fname, ftype, fid) = iprot.readFieldBegin()
18103 
      if ftype == TType.STOP:
18104 
        break
18105 
      else:
18106 
        iprot.skip(ftype)
18107 
      iprot.readFieldEnd()
18108 
    iprot.readStructEnd()
18109 
 
18110 
  def write(self, oprot):
18111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18113 
      return
18114 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18115 
    oprot.writeFieldStop()
18116 
    oprot.writeStructEnd()
18117 
 
18118 
  def validate(self):
18119 
    return
18120 
 
18121 
 
18122 
  def __repr__(self):
18123 
    L = ['%s=%r' % (key, value)
18124 
      for key, value in self.__dict__.iteritems()]
18125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18126 
 
18127 
  def __eq__(self, other):
18128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18129 
 
18130 
  def __ne__(self, other):
18131 
    return not (self == other)
7256 rajveer 18132 
 
7272 amit.gupta 18133 
class addOrUpdateBrandInfo_args:
18134 
  """
18135 
  Attributes:
18136 
   - brandInfo
18137 
  """
18138 
 
18139 
  thrift_spec = (
18140 
    None, # 0
18141 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18142 
  )
18143 
 
18144 
  def __init__(self, brandInfo=None,):
18145 
    self.brandInfo = brandInfo
18146 
 
18147 
  def read(self, iprot):
18148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18150 
      return
18151 
    iprot.readStructBegin()
18152 
    while True:
18153 
      (fname, ftype, fid) = iprot.readFieldBegin()
18154 
      if ftype == TType.STOP:
18155 
        break
18156 
      if fid == 1:
18157 
        if ftype == TType.STRUCT:
18158 
          self.brandInfo = BrandInfo()
18159 
          self.brandInfo.read(iprot)
18160 
        else:
18161 
          iprot.skip(ftype)
18162 
      else:
18163 
        iprot.skip(ftype)
18164 
      iprot.readFieldEnd()
18165 
    iprot.readStructEnd()
18166 
 
18167 
  def write(self, oprot):
18168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18170 
      return
18171 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18172 
    if self.brandInfo is not None:
18173 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18174 
      self.brandInfo.write(oprot)
18175 
      oprot.writeFieldEnd()
18176 
    oprot.writeFieldStop()
18177 
    oprot.writeStructEnd()
18178 
 
18179 
  def validate(self):
18180 
    return
18181 
 
18182 
 
18183 
  def __repr__(self):
18184 
    L = ['%s=%r' % (key, value)
18185 
      for key, value in self.__dict__.iteritems()]
18186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18187 
 
18188 
  def __eq__(self, other):
18189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18190 
 
18191 
  def __ne__(self, other):
18192 
    return not (self == other)
18193 
 
18194 
class addOrUpdateBrandInfo_result:
18195 
 
18196 
  thrift_spec = (
18197 
  )
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 
      else:
18209 
        iprot.skip(ftype)
18210 
      iprot.readFieldEnd()
18211 
    iprot.readStructEnd()
18212 
 
18213 
  def write(self, oprot):
18214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18216 
      return
18217 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
18218 
    oprot.writeFieldStop()
18219 
    oprot.writeStructEnd()
18220 
 
18221 
  def validate(self):
18222 
    return
18223 
 
18224 
 
18225 
  def __repr__(self):
18226 
    L = ['%s=%r' % (key, value)
18227 
      for key, value in self.__dict__.iteritems()]
18228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18229 
 
18230 
  def __eq__(self, other):
18231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18232 
 
18233 
  def __ne__(self, other):
18234 
    return not (self == other)
18235 
 
18236 
class getBrandInfo_args:
18237 
 
18238 
  thrift_spec = (
18239 
  )
18240 
 
18241 
  def read(self, iprot):
18242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18244 
      return
18245 
    iprot.readStructBegin()
18246 
    while True:
18247 
      (fname, ftype, fid) = iprot.readFieldBegin()
18248 
      if ftype == TType.STOP:
18249 
        break
18250 
      else:
18251 
        iprot.skip(ftype)
18252 
      iprot.readFieldEnd()
18253 
    iprot.readStructEnd()
18254 
 
18255 
  def write(self, oprot):
18256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18258 
      return
18259 
    oprot.writeStructBegin('getBrandInfo_args')
18260 
    oprot.writeFieldStop()
18261 
    oprot.writeStructEnd()
18262 
 
18263 
  def validate(self):
18264 
    return
18265 
 
18266 
 
18267 
  def __repr__(self):
18268 
    L = ['%s=%r' % (key, value)
18269 
      for key, value in self.__dict__.iteritems()]
18270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18271 
 
18272 
  def __eq__(self, other):
18273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18274 
 
18275 
  def __ne__(self, other):
18276 
    return not (self == other)
18277 
 
18278 
class getBrandInfo_result:
18279 
  """
18280 
  Attributes:
18281 
   - success
18282 
  """
18283 
 
18284 
  thrift_spec = (
18285 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
18286 
  )
18287 
 
18288 
  def __init__(self, success=None,):
18289 
    self.success = success
18290 
 
18291 
  def read(self, iprot):
18292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18294 
      return
18295 
    iprot.readStructBegin()
18296 
    while True:
18297 
      (fname, ftype, fid) = iprot.readFieldBegin()
18298 
      if ftype == TType.STOP:
18299 
        break
18300 
      if fid == 0:
18301 
        if ftype == TType.MAP:
18302 
          self.success = {}
8579 kshitij.so 18303 
          (_ktype359, _vtype360, _size358 ) = iprot.readMapBegin()
18304 
          for _i362 in xrange(_size358):
18305 
            _key363 = iprot.readString();
18306 
            _val364 = BrandInfo()
18307 
            _val364.read(iprot)
18308 
            self.success[_key363] = _val364
7272 amit.gupta 18309 
          iprot.readMapEnd()
18310 
        else:
18311 
          iprot.skip(ftype)
18312 
      else:
18313 
        iprot.skip(ftype)
18314 
      iprot.readFieldEnd()
18315 
    iprot.readStructEnd()
18316 
 
18317 
  def write(self, oprot):
18318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18320 
      return
18321 
    oprot.writeStructBegin('getBrandInfo_result')
18322 
    if self.success is not None:
18323 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18324 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
8579 kshitij.so 18325 
      for kiter365,viter366 in self.success.items():
18326 
        oprot.writeString(kiter365)
18327 
        viter366.write(oprot)
7272 amit.gupta 18328 
      oprot.writeMapEnd()
18329 
      oprot.writeFieldEnd()
18330 
    oprot.writeFieldStop()
18331 
    oprot.writeStructEnd()
18332 
 
18333 
  def validate(self):
18334 
    return
18335 
 
18336 
 
18337 
  def __repr__(self):
18338 
    L = ['%s=%r' % (key, value)
18339 
      for key, value in self.__dict__.iteritems()]
18340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18341 
 
18342 
  def __eq__(self, other):
18343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18344 
 
18345 
  def __ne__(self, other):
18346 
    return not (self == other)
18347 
 
7256 rajveer 18348 
class getStorePricing_args:
18349 
  """
18350 
  Attributes:
18351 
   - itemId
18352 
  """
18353 
 
18354 
  thrift_spec = (
18355 
    None, # 0
18356 
    (1, TType.I64, 'itemId', None, None, ), # 1
18357 
  )
18358 
 
18359 
  def __init__(self, itemId=None,):
18360 
    self.itemId = itemId
18361 
 
18362 
  def read(self, iprot):
18363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18365 
      return
18366 
    iprot.readStructBegin()
18367 
    while True:
18368 
      (fname, ftype, fid) = iprot.readFieldBegin()
18369 
      if ftype == TType.STOP:
18370 
        break
18371 
      if fid == 1:
18372 
        if ftype == TType.I64:
18373 
          self.itemId = iprot.readI64();
18374 
        else:
18375 
          iprot.skip(ftype)
18376 
      else:
18377 
        iprot.skip(ftype)
18378 
      iprot.readFieldEnd()
18379 
    iprot.readStructEnd()
18380 
 
18381 
  def write(self, oprot):
18382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18384 
      return
18385 
    oprot.writeStructBegin('getStorePricing_args')
18386 
    if self.itemId is not None:
18387 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18388 
      oprot.writeI64(self.itemId)
18389 
      oprot.writeFieldEnd()
18390 
    oprot.writeFieldStop()
18391 
    oprot.writeStructEnd()
18392 
 
18393 
  def validate(self):
18394 
    return
18395 
 
18396 
 
18397 
  def __repr__(self):
18398 
    L = ['%s=%r' % (key, value)
18399 
      for key, value in self.__dict__.iteritems()]
18400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18401 
 
18402 
  def __eq__(self, other):
18403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18404 
 
18405 
  def __ne__(self, other):
18406 
    return not (self == other)
18407 
 
18408 
class getStorePricing_result:
18409 
  """
18410 
  Attributes:
18411 
   - success
18412 
  """
18413 
 
18414 
  thrift_spec = (
18415 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
18416 
  )
18417 
 
18418 
  def __init__(self, success=None,):
18419 
    self.success = success
18420 
 
18421 
  def read(self, iprot):
18422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18424 
      return
18425 
    iprot.readStructBegin()
18426 
    while True:
18427 
      (fname, ftype, fid) = iprot.readFieldBegin()
18428 
      if ftype == TType.STOP:
18429 
        break
18430 
      if fid == 0:
18431 
        if ftype == TType.STRUCT:
18432 
          self.success = StorePricing()
18433 
          self.success.read(iprot)
18434 
        else:
18435 
          iprot.skip(ftype)
18436 
      else:
18437 
        iprot.skip(ftype)
18438 
      iprot.readFieldEnd()
18439 
    iprot.readStructEnd()
18440 
 
18441 
  def write(self, oprot):
18442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18444 
      return
18445 
    oprot.writeStructBegin('getStorePricing_result')
18446 
    if self.success is not None:
18447 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18448 
      self.success.write(oprot)
18449 
      oprot.writeFieldEnd()
18450 
    oprot.writeFieldStop()
18451 
    oprot.writeStructEnd()
18452 
 
18453 
  def validate(self):
18454 
    return
18455 
 
18456 
 
18457 
  def __repr__(self):
18458 
    L = ['%s=%r' % (key, value)
18459 
      for key, value in self.__dict__.iteritems()]
18460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18461 
 
18462 
  def __eq__(self, other):
18463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18464 
 
18465 
  def __ne__(self, other):
18466 
    return not (self == other)
7265 rajveer 18467 
 
7306 rajveer 18468 
class getStorePricings_args:
18469 
  """
18470 
  Attributes:
18471 
   - itemIds
18472 
  """
18473 
 
18474 
  thrift_spec = (
18475 
    None, # 0
18476 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18477 
  )
18478 
 
18479 
  def __init__(self, itemIds=None,):
18480 
    self.itemIds = itemIds
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 == 1:
18492 
        if ftype == TType.LIST:
18493 
          self.itemIds = []
8579 kshitij.so 18494 
          (_etype370, _size367) = iprot.readListBegin()
18495 
          for _i371 in xrange(_size367):
18496 
            _elem372 = iprot.readI64();
18497 
            self.itemIds.append(_elem372)
7306 rajveer 18498 
          iprot.readListEnd()
18499 
        else:
18500 
          iprot.skip(ftype)
18501 
      else:
18502 
        iprot.skip(ftype)
18503 
      iprot.readFieldEnd()
18504 
    iprot.readStructEnd()
18505 
 
18506 
  def write(self, oprot):
18507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18509 
      return
18510 
    oprot.writeStructBegin('getStorePricings_args')
18511 
    if self.itemIds is not None:
18512 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18513 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8579 kshitij.so 18514 
      for iter373 in self.itemIds:
18515 
        oprot.writeI64(iter373)
7306 rajveer 18516 
      oprot.writeListEnd()
18517 
      oprot.writeFieldEnd()
18518 
    oprot.writeFieldStop()
18519 
    oprot.writeStructEnd()
18520 
 
18521 
  def validate(self):
18522 
    return
18523 
 
18524 
 
18525 
  def __repr__(self):
18526 
    L = ['%s=%r' % (key, value)
18527 
      for key, value in self.__dict__.iteritems()]
18528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18529 
 
18530 
  def __eq__(self, other):
18531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18532 
 
18533 
  def __ne__(self, other):
18534 
    return not (self == other)
18535 
 
18536 
class getStorePricings_result:
18537 
  """
18538 
  Attributes:
18539 
   - success
18540 
  """
18541 
 
18542 
  thrift_spec = (
18543 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
18544 
  )
18545 
 
18546 
  def __init__(self, success=None,):
18547 
    self.success = success
18548 
 
18549 
  def read(self, iprot):
18550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18552 
      return
18553 
    iprot.readStructBegin()
18554 
    while True:
18555 
      (fname, ftype, fid) = iprot.readFieldBegin()
18556 
      if ftype == TType.STOP:
18557 
        break
18558 
      if fid == 0:
18559 
        if ftype == TType.LIST:
18560 
          self.success = []
8579 kshitij.so 18561 
          (_etype377, _size374) = iprot.readListBegin()
18562 
          for _i378 in xrange(_size374):
18563 
            _elem379 = StorePricing()
18564 
            _elem379.read(iprot)
18565 
            self.success.append(_elem379)
7306 rajveer 18566 
          iprot.readListEnd()
18567 
        else:
18568 
          iprot.skip(ftype)
18569 
      else:
18570 
        iprot.skip(ftype)
18571 
      iprot.readFieldEnd()
18572 
    iprot.readStructEnd()
18573 
 
18574 
  def write(self, oprot):
18575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18577 
      return
18578 
    oprot.writeStructBegin('getStorePricings_result')
18579 
    if self.success is not None:
18580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18581 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 18582 
      for iter380 in self.success:
18583 
        iter380.write(oprot)
7306 rajveer 18584 
      oprot.writeListEnd()
18585 
      oprot.writeFieldEnd()
18586 
    oprot.writeFieldStop()
18587 
    oprot.writeStructEnd()
18588 
 
18589 
  def validate(self):
18590 
    return
18591 
 
18592 
 
18593 
  def __repr__(self):
18594 
    L = ['%s=%r' % (key, value)
18595 
      for key, value in self.__dict__.iteritems()]
18596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18597 
 
18598 
  def __eq__(self, other):
18599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18600 
 
18601 
  def __ne__(self, other):
18602 
    return not (self == other)
18603 
 
7265 rajveer 18604 
class updateStorePricing_args:
18605 
  """
18606 
  Attributes:
18607 
   - sp
7382 rajveer 18608 
   - allColors
7265 rajveer 18609 
  """
18610 
 
18611 
  thrift_spec = (
18612 
    None, # 0
18613 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 18614 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 18615 
  )
18616 
 
7382 rajveer 18617 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 18618 
    self.sp = sp
7382 rajveer 18619 
    self.allColors = allColors
7265 rajveer 18620 
 
18621 
  def read(self, iprot):
18622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18624 
      return
18625 
    iprot.readStructBegin()
18626 
    while True:
18627 
      (fname, ftype, fid) = iprot.readFieldBegin()
18628 
      if ftype == TType.STOP:
18629 
        break
18630 
      if fid == 1:
18631 
        if ftype == TType.STRUCT:
18632 
          self.sp = StorePricing()
18633 
          self.sp.read(iprot)
18634 
        else:
18635 
          iprot.skip(ftype)
7382 rajveer 18636 
      elif fid == 2:
18637 
        if ftype == TType.BOOL:
18638 
          self.allColors = iprot.readBool();
18639 
        else:
18640 
          iprot.skip(ftype)
7265 rajveer 18641 
      else:
18642 
        iprot.skip(ftype)
18643 
      iprot.readFieldEnd()
18644 
    iprot.readStructEnd()
18645 
 
18646 
  def write(self, oprot):
18647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18649 
      return
18650 
    oprot.writeStructBegin('updateStorePricing_args')
18651 
    if self.sp is not None:
18652 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
18653 
      self.sp.write(oprot)
18654 
      oprot.writeFieldEnd()
7382 rajveer 18655 
    if self.allColors is not None:
18656 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
18657 
      oprot.writeBool(self.allColors)
18658 
      oprot.writeFieldEnd()
7265 rajveer 18659 
    oprot.writeFieldStop()
18660 
    oprot.writeStructEnd()
18661 
 
18662 
  def validate(self):
18663 
    return
18664 
 
18665 
 
18666 
  def __repr__(self):
18667 
    L = ['%s=%r' % (key, value)
18668 
      for key, value in self.__dict__.iteritems()]
18669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18670 
 
18671 
  def __eq__(self, other):
18672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18673 
 
18674 
  def __ne__(self, other):
18675 
    return not (self == other)
18676 
 
18677 
class updateStorePricing_result:
18678 
 
18679 
  thrift_spec = (
18680 
  )
18681 
 
18682 
  def read(self, iprot):
18683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18685 
      return
18686 
    iprot.readStructBegin()
18687 
    while True:
18688 
      (fname, ftype, fid) = iprot.readFieldBegin()
18689 
      if ftype == TType.STOP:
18690 
        break
18691 
      else:
18692 
        iprot.skip(ftype)
18693 
      iprot.readFieldEnd()
18694 
    iprot.readStructEnd()
18695 
 
18696 
  def write(self, oprot):
18697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18699 
      return
18700 
    oprot.writeStructBegin('updateStorePricing_result')
18701 
    oprot.writeFieldStop()
18702 
    oprot.writeStructEnd()
18703 
 
18704 
  def validate(self):
18705 
    return
18706 
 
18707 
 
18708 
  def __repr__(self):
18709 
    L = ['%s=%r' % (key, value)
18710 
      for key, value in self.__dict__.iteritems()]
18711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18712 
 
18713 
  def __eq__(self, other):
18714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18715 
 
18716 
  def __ne__(self, other):
18717 
    return not (self == other)
7281 kshitij.so 18718 
 
18719 
class getAllAmazonListedItems_args:
18720 
 
18721 
  thrift_spec = (
18722 
  )
18723 
 
18724 
  def read(self, iprot):
18725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18727 
      return
18728 
    iprot.readStructBegin()
18729 
    while True:
18730 
      (fname, ftype, fid) = iprot.readFieldBegin()
18731 
      if ftype == TType.STOP:
18732 
        break
18733 
      else:
18734 
        iprot.skip(ftype)
18735 
      iprot.readFieldEnd()
18736 
    iprot.readStructEnd()
18737 
 
18738 
  def write(self, oprot):
18739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18741 
      return
18742 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
18743 
    oprot.writeFieldStop()
18744 
    oprot.writeStructEnd()
18745 
 
18746 
  def validate(self):
18747 
    return
18748 
 
18749 
 
18750 
  def __repr__(self):
18751 
    L = ['%s=%r' % (key, value)
18752 
      for key, value in self.__dict__.iteritems()]
18753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18754 
 
18755 
  def __eq__(self, other):
18756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18757 
 
18758 
  def __ne__(self, other):
18759 
    return not (self == other)
18760 
 
18761 
class getAllAmazonListedItems_result:
18762 
  """
18763 
  Attributes:
18764 
   - success
18765 
  """
18766 
 
18767 
  thrift_spec = (
18768 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18769 
  )
18770 
 
18771 
  def __init__(self, success=None,):
18772 
    self.success = success
18773 
 
18774 
  def read(self, iprot):
18775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18777 
      return
18778 
    iprot.readStructBegin()
18779 
    while True:
18780 
      (fname, ftype, fid) = iprot.readFieldBegin()
18781 
      if ftype == TType.STOP:
18782 
        break
18783 
      if fid == 0:
18784 
        if ftype == TType.LIST:
18785 
          self.success = []
8579 kshitij.so 18786 
          (_etype384, _size381) = iprot.readListBegin()
18787 
          for _i385 in xrange(_size381):
18788 
            _elem386 = Amazonlisted()
18789 
            _elem386.read(iprot)
18790 
            self.success.append(_elem386)
7281 kshitij.so 18791 
          iprot.readListEnd()
18792 
        else:
18793 
          iprot.skip(ftype)
18794 
      else:
18795 
        iprot.skip(ftype)
18796 
      iprot.readFieldEnd()
18797 
    iprot.readStructEnd()
18798 
 
18799 
  def write(self, oprot):
18800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18802 
      return
18803 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
18804 
    if self.success is not None:
18805 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18806 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 18807 
      for iter387 in self.success:
18808 
        iter387.write(oprot)
7281 kshitij.so 18809 
      oprot.writeListEnd()
18810 
      oprot.writeFieldEnd()
18811 
    oprot.writeFieldStop()
18812 
    oprot.writeStructEnd()
18813 
 
18814 
  def validate(self):
18815 
    return
18816 
 
18817 
 
18818 
  def __repr__(self):
18819 
    L = ['%s=%r' % (key, value)
18820 
      for key, value in self.__dict__.iteritems()]
18821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18822 
 
18823 
  def __eq__(self, other):
18824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18825 
 
18826 
  def __ne__(self, other):
18827 
    return not (self == other)
18828 
 
18829 
class getAmazonItemDetails_args:
18830 
  """
18831 
  Attributes:
18832 
   - itemId
18833 
  """
18834 
 
18835 
  thrift_spec = (
18836 
    None, # 0
18837 
    (1, TType.I64, 'itemId', None, None, ), # 1
18838 
  )
18839 
 
18840 
  def __init__(self, itemId=None,):
18841 
    self.itemId = itemId
18842 
 
18843 
  def read(self, iprot):
18844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18846 
      return
18847 
    iprot.readStructBegin()
18848 
    while True:
18849 
      (fname, ftype, fid) = iprot.readFieldBegin()
18850 
      if ftype == TType.STOP:
18851 
        break
18852 
      if fid == 1:
18853 
        if ftype == TType.I64:
18854 
          self.itemId = iprot.readI64();
18855 
        else:
18856 
          iprot.skip(ftype)
18857 
      else:
18858 
        iprot.skip(ftype)
18859 
      iprot.readFieldEnd()
18860 
    iprot.readStructEnd()
18861 
 
18862 
  def write(self, oprot):
18863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18865 
      return
18866 
    oprot.writeStructBegin('getAmazonItemDetails_args')
18867 
    if self.itemId is not None:
18868 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18869 
      oprot.writeI64(self.itemId)
18870 
      oprot.writeFieldEnd()
18871 
    oprot.writeFieldStop()
18872 
    oprot.writeStructEnd()
18873 
 
18874 
  def validate(self):
18875 
    return
18876 
 
18877 
 
18878 
  def __repr__(self):
18879 
    L = ['%s=%r' % (key, value)
18880 
      for key, value in self.__dict__.iteritems()]
18881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18882 
 
18883 
  def __eq__(self, other):
18884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18885 
 
18886 
  def __ne__(self, other):
18887 
    return not (self == other)
18888 
 
18889 
class getAmazonItemDetails_result:
18890 
  """
18891 
  Attributes:
18892 
   - success
18893 
  """
18894 
 
18895 
  thrift_spec = (
18896 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
18897 
  )
18898 
 
18899 
  def __init__(self, success=None,):
18900 
    self.success = success
18901 
 
18902 
  def read(self, iprot):
18903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18905 
      return
18906 
    iprot.readStructBegin()
18907 
    while True:
18908 
      (fname, ftype, fid) = iprot.readFieldBegin()
18909 
      if ftype == TType.STOP:
18910 
        break
18911 
      if fid == 0:
18912 
        if ftype == TType.STRUCT:
18913 
          self.success = Amazonlisted()
18914 
          self.success.read(iprot)
18915 
        else:
18916 
          iprot.skip(ftype)
18917 
      else:
18918 
        iprot.skip(ftype)
18919 
      iprot.readFieldEnd()
18920 
    iprot.readStructEnd()
18921 
 
18922 
  def write(self, oprot):
18923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18925 
      return
18926 
    oprot.writeStructBegin('getAmazonItemDetails_result')
18927 
    if self.success is not None:
18928 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18929 
      self.success.write(oprot)
18930 
      oprot.writeFieldEnd()
18931 
    oprot.writeFieldStop()
18932 
    oprot.writeStructEnd()
18933 
 
18934 
  def validate(self):
18935 
    return
18936 
 
18937 
 
18938 
  def __repr__(self):
18939 
    L = ['%s=%r' % (key, value)
18940 
      for key, value in self.__dict__.iteritems()]
18941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18942 
 
18943 
  def __eq__(self, other):
18944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18945 
 
18946 
  def __ne__(self, other):
18947 
    return not (self == other)
18948 
 
18949 
class updateAmazonItemDetails_args:
18950 
  """
18951 
  Attributes:
8168 kshitij.so 18952 
   - amazonlisted
7281 kshitij.so 18953 
  """
18954 
 
18955 
  thrift_spec = (
18956 
    None, # 0
8168 kshitij.so 18957 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 18958 
  )
18959 
 
8168 kshitij.so 18960 
  def __init__(self, amazonlisted=None,):
18961 
    self.amazonlisted = amazonlisted
7281 kshitij.so 18962 
 
18963 
  def read(self, iprot):
18964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18966 
      return
18967 
    iprot.readStructBegin()
18968 
    while True:
18969 
      (fname, ftype, fid) = iprot.readFieldBegin()
18970 
      if ftype == TType.STOP:
18971 
        break
18972 
      if fid == 1:
8168 kshitij.so 18973 
        if ftype == TType.STRUCT:
18974 
          self.amazonlisted = Amazonlisted()
18975 
          self.amazonlisted.read(iprot)
7281 kshitij.so 18976 
        else:
18977 
          iprot.skip(ftype)
18978 
      else:
18979 
        iprot.skip(ftype)
18980 
      iprot.readFieldEnd()
18981 
    iprot.readStructEnd()
18982 
 
18983 
  def write(self, oprot):
18984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18986 
      return
18987 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 18988 
    if self.amazonlisted is not None:
18989 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
18990 
      self.amazonlisted.write(oprot)
7281 kshitij.so 18991 
      oprot.writeFieldEnd()
18992 
    oprot.writeFieldStop()
18993 
    oprot.writeStructEnd()
18994 
 
18995 
  def validate(self):
18996 
    return
18997 
 
18998 
 
18999 
  def __repr__(self):
19000 
    L = ['%s=%r' % (key, value)
19001 
      for key, value in self.__dict__.iteritems()]
19002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19003 
 
19004 
  def __eq__(self, other):
19005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19006 
 
19007 
  def __ne__(self, other):
19008 
    return not (self == other)
19009 
 
19010 
class updateAmazonItemDetails_result:
19011 
 
19012 
  thrift_spec = (
19013 
  )
19014 
 
19015 
  def read(self, iprot):
19016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19018 
      return
19019 
    iprot.readStructBegin()
19020 
    while True:
19021 
      (fname, ftype, fid) = iprot.readFieldBegin()
19022 
      if ftype == TType.STOP:
19023 
        break
19024 
      else:
19025 
        iprot.skip(ftype)
19026 
      iprot.readFieldEnd()
19027 
    iprot.readStructEnd()
19028 
 
19029 
  def write(self, oprot):
19030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19032 
      return
19033 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
19034 
    oprot.writeFieldStop()
19035 
    oprot.writeStructEnd()
19036 
 
19037 
  def validate(self):
19038 
    return
19039 
 
19040 
 
19041 
  def __repr__(self):
19042 
    L = ['%s=%r' % (key, value)
19043 
      for key, value in self.__dict__.iteritems()]
19044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19045 
 
19046 
  def __eq__(self, other):
19047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19048 
 
19049 
  def __ne__(self, other):
19050 
    return not (self == other)
19051 
 
19052 
class addAmazonItem_args:
19053 
  """
19054 
  Attributes:
19055 
   - amazonlisted
19056 
  """
19057 
 
19058 
  thrift_spec = (
19059 
    None, # 0
19060 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
19061 
  )
19062 
 
19063 
  def __init__(self, amazonlisted=None,):
19064 
    self.amazonlisted = amazonlisted
19065 
 
19066 
  def read(self, iprot):
19067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19069 
      return
19070 
    iprot.readStructBegin()
19071 
    while True:
19072 
      (fname, ftype, fid) = iprot.readFieldBegin()
19073 
      if ftype == TType.STOP:
19074 
        break
19075 
      if fid == 1:
19076 
        if ftype == TType.STRUCT:
19077 
          self.amazonlisted = Amazonlisted()
19078 
          self.amazonlisted.read(iprot)
19079 
        else:
19080 
          iprot.skip(ftype)
19081 
      else:
19082 
        iprot.skip(ftype)
19083 
      iprot.readFieldEnd()
19084 
    iprot.readStructEnd()
19085 
 
19086 
  def write(self, oprot):
19087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19089 
      return
19090 
    oprot.writeStructBegin('addAmazonItem_args')
19091 
    if self.amazonlisted is not None:
19092 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19093 
      self.amazonlisted.write(oprot)
19094 
      oprot.writeFieldEnd()
19095 
    oprot.writeFieldStop()
19096 
    oprot.writeStructEnd()
19097 
 
19098 
  def validate(self):
19099 
    return
19100 
 
19101 
 
19102 
  def __repr__(self):
19103 
    L = ['%s=%r' % (key, value)
19104 
      for key, value in self.__dict__.iteritems()]
19105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19106 
 
19107 
  def __eq__(self, other):
19108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19109 
 
19110 
  def __ne__(self, other):
19111 
    return not (self == other)
19112 
 
19113 
class addAmazonItem_result:
19114 
 
19115 
  thrift_spec = (
19116 
  )
19117 
 
19118 
  def read(self, iprot):
19119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19121 
      return
19122 
    iprot.readStructBegin()
19123 
    while True:
19124 
      (fname, ftype, fid) = iprot.readFieldBegin()
19125 
      if ftype == TType.STOP:
19126 
        break
19127 
      else:
19128 
        iprot.skip(ftype)
19129 
      iprot.readFieldEnd()
19130 
    iprot.readStructEnd()
19131 
 
19132 
  def write(self, oprot):
19133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19135 
      return
19136 
    oprot.writeStructBegin('addAmazonItem_result')
19137 
    oprot.writeFieldStop()
19138 
    oprot.writeStructEnd()
19139 
 
19140 
  def validate(self):
19141 
    return
19142 
 
19143 
 
19144 
  def __repr__(self):
19145 
    L = ['%s=%r' % (key, value)
19146 
      for key, value in self.__dict__.iteritems()]
19147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19148 
 
19149 
  def __eq__(self, other):
19150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19151 
 
19152 
  def __ne__(self, other):
19153 
    return not (self == other)
7291 vikram.rag 19154 
 
19155 
class getAsinItems_args:
19156 
 
19157 
  thrift_spec = (
19158 
  )
19159 
 
19160 
  def read(self, iprot):
19161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19163 
      return
19164 
    iprot.readStructBegin()
19165 
    while True:
19166 
      (fname, ftype, fid) = iprot.readFieldBegin()
19167 
      if ftype == TType.STOP:
19168 
        break
19169 
      else:
19170 
        iprot.skip(ftype)
19171 
      iprot.readFieldEnd()
19172 
    iprot.readStructEnd()
19173 
 
19174 
  def write(self, oprot):
19175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19177 
      return
19178 
    oprot.writeStructBegin('getAsinItems_args')
19179 
    oprot.writeFieldStop()
19180 
    oprot.writeStructEnd()
19181 
 
19182 
  def validate(self):
19183 
    return
19184 
 
19185 
 
19186 
  def __repr__(self):
19187 
    L = ['%s=%r' % (key, value)
19188 
      for key, value in self.__dict__.iteritems()]
19189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19190 
 
19191 
  def __eq__(self, other):
19192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19193 
 
19194 
  def __ne__(self, other):
19195 
    return not (self == other)
19196 
 
19197 
class getAsinItems_result:
19198 
  """
19199 
  Attributes:
19200 
   - success
19201 
  """
19202 
 
19203 
  thrift_spec = (
19204 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19205 
  )
19206 
 
19207 
  def __init__(self, success=None,):
19208 
    self.success = success
19209 
 
19210 
  def read(self, iprot):
19211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19213 
      return
19214 
    iprot.readStructBegin()
19215 
    while True:
19216 
      (fname, ftype, fid) = iprot.readFieldBegin()
19217 
      if ftype == TType.STOP:
19218 
        break
19219 
      if fid == 0:
19220 
        if ftype == TType.LIST:
19221 
          self.success = []
8579 kshitij.so 19222 
          (_etype391, _size388) = iprot.readListBegin()
19223 
          for _i392 in xrange(_size388):
19224 
            _elem393 = Item()
19225 
            _elem393.read(iprot)
19226 
            self.success.append(_elem393)
7291 vikram.rag 19227 
          iprot.readListEnd()
19228 
        else:
19229 
          iprot.skip(ftype)
19230 
      else:
19231 
        iprot.skip(ftype)
19232 
      iprot.readFieldEnd()
19233 
    iprot.readStructEnd()
19234 
 
19235 
  def write(self, oprot):
19236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19238 
      return
19239 
    oprot.writeStructBegin('getAsinItems_result')
19240 
    if self.success is not None:
19241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19242 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 19243 
      for iter394 in self.success:
19244 
        iter394.write(oprot)
7291 vikram.rag 19245 
      oprot.writeListEnd()
19246 
      oprot.writeFieldEnd()
19247 
    oprot.writeFieldStop()
19248 
    oprot.writeStructEnd()
19249 
 
19250 
  def validate(self):
19251 
    return
19252 
 
19253 
 
19254 
  def __repr__(self):
19255 
    L = ['%s=%r' % (key, value)
19256 
      for key, value in self.__dict__.iteritems()]
19257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19258 
 
19259 
  def __eq__(self, other):
19260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19261 
 
19262 
  def __ne__(self, other):
19263 
    return not (self == other)
19264 
 
19265 
class getAllFbaListedItems_args:
19266 
 
19267 
  thrift_spec = (
19268 
  )
19269 
 
19270 
  def read(self, iprot):
19271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19273 
      return
19274 
    iprot.readStructBegin()
19275 
    while True:
19276 
      (fname, ftype, fid) = iprot.readFieldBegin()
19277 
      if ftype == TType.STOP:
19278 
        break
19279 
      else:
19280 
        iprot.skip(ftype)
19281 
      iprot.readFieldEnd()
19282 
    iprot.readStructEnd()
19283 
 
19284 
  def write(self, oprot):
19285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19287 
      return
19288 
    oprot.writeStructBegin('getAllFbaListedItems_args')
19289 
    oprot.writeFieldStop()
19290 
    oprot.writeStructEnd()
19291 
 
19292 
  def validate(self):
19293 
    return
19294 
 
19295 
 
19296 
  def __repr__(self):
19297 
    L = ['%s=%r' % (key, value)
19298 
      for key, value in self.__dict__.iteritems()]
19299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19300 
 
19301 
  def __eq__(self, other):
19302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19303 
 
19304 
  def __ne__(self, other):
19305 
    return not (self == other)
19306 
 
19307 
class getAllFbaListedItems_result:
19308 
  """
19309 
  Attributes:
19310 
   - success
19311 
  """
19312 
 
19313 
  thrift_spec = (
19314 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19315 
  )
19316 
 
19317 
  def __init__(self, success=None,):
19318 
    self.success = success
19319 
 
19320 
  def read(self, iprot):
19321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19323 
      return
19324 
    iprot.readStructBegin()
19325 
    while True:
19326 
      (fname, ftype, fid) = iprot.readFieldBegin()
19327 
      if ftype == TType.STOP:
19328 
        break
19329 
      if fid == 0:
19330 
        if ftype == TType.LIST:
19331 
          self.success = []
8579 kshitij.so 19332 
          (_etype398, _size395) = iprot.readListBegin()
19333 
          for _i399 in xrange(_size395):
19334 
            _elem400 = Amazonlisted()
19335 
            _elem400.read(iprot)
19336 
            self.success.append(_elem400)
7291 vikram.rag 19337 
          iprot.readListEnd()
19338 
        else:
19339 
          iprot.skip(ftype)
19340 
      else:
19341 
        iprot.skip(ftype)
19342 
      iprot.readFieldEnd()
19343 
    iprot.readStructEnd()
19344 
 
19345 
  def write(self, oprot):
19346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19348 
      return
19349 
    oprot.writeStructBegin('getAllFbaListedItems_result')
19350 
    if self.success is not None:
19351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19352 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 19353 
      for iter401 in self.success:
19354 
        iter401.write(oprot)
7291 vikram.rag 19355 
      oprot.writeListEnd()
19356 
      oprot.writeFieldEnd()
19357 
    oprot.writeFieldStop()
19358 
    oprot.writeStructEnd()
19359 
 
19360 
  def validate(self):
19361 
    return
19362 
 
19363 
 
19364 
  def __repr__(self):
19365 
    L = ['%s=%r' % (key, value)
19366 
      for key, value in self.__dict__.iteritems()]
19367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19368 
 
19369 
  def __eq__(self, other):
19370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19371 
 
19372 
  def __ne__(self, other):
19373 
    return not (self == other)
19374 
 
19375 
class getAllNonFbaListedItems_args:
19376 
 
19377 
  thrift_spec = (
19378 
  )
19379 
 
19380 
  def read(self, iprot):
19381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19383 
      return
19384 
    iprot.readStructBegin()
19385 
    while True:
19386 
      (fname, ftype, fid) = iprot.readFieldBegin()
19387 
      if ftype == TType.STOP:
19388 
        break
19389 
      else:
19390 
        iprot.skip(ftype)
19391 
      iprot.readFieldEnd()
19392 
    iprot.readStructEnd()
19393 
 
19394 
  def write(self, oprot):
19395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19397 
      return
19398 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
19399 
    oprot.writeFieldStop()
19400 
    oprot.writeStructEnd()
19401 
 
19402 
  def validate(self):
19403 
    return
19404 
 
19405 
 
19406 
  def __repr__(self):
19407 
    L = ['%s=%r' % (key, value)
19408 
      for key, value in self.__dict__.iteritems()]
19409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19410 
 
19411 
  def __eq__(self, other):
19412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19413 
 
19414 
  def __ne__(self, other):
19415 
    return not (self == other)
19416 
 
19417 
class getAllNonFbaListedItems_result:
19418 
  """
19419 
  Attributes:
19420 
   - success
19421 
  """
19422 
 
19423 
  thrift_spec = (
19424 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19425 
  )
19426 
 
19427 
  def __init__(self, success=None,):
19428 
    self.success = success
19429 
 
19430 
  def read(self, iprot):
19431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19433 
      return
19434 
    iprot.readStructBegin()
19435 
    while True:
19436 
      (fname, ftype, fid) = iprot.readFieldBegin()
19437 
      if ftype == TType.STOP:
19438 
        break
19439 
      if fid == 0:
19440 
        if ftype == TType.LIST:
19441 
          self.success = []
8579 kshitij.so 19442 
          (_etype405, _size402) = iprot.readListBegin()
19443 
          for _i406 in xrange(_size402):
19444 
            _elem407 = Amazonlisted()
19445 
            _elem407.read(iprot)
19446 
            self.success.append(_elem407)
7291 vikram.rag 19447 
          iprot.readListEnd()
19448 
        else:
19449 
          iprot.skip(ftype)
19450 
      else:
19451 
        iprot.skip(ftype)
19452 
      iprot.readFieldEnd()
19453 
    iprot.readStructEnd()
19454 
 
19455 
  def write(self, oprot):
19456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19458 
      return
19459 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
19460 
    if self.success is not None:
19461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19462 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 19463 
      for iter408 in self.success:
19464 
        iter408.write(oprot)
7291 vikram.rag 19465 
      oprot.writeListEnd()
19466 
      oprot.writeFieldEnd()
19467 
    oprot.writeFieldStop()
19468 
    oprot.writeStructEnd()
19469 
 
19470 
  def validate(self):
19471 
    return
19472 
 
19473 
 
19474 
  def __repr__(self):
19475 
    L = ['%s=%r' % (key, value)
19476 
      for key, value in self.__dict__.iteritems()]
19477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19478 
 
19479 
  def __eq__(self, other):
19480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19481 
 
19482 
  def __ne__(self, other):
19483 
    return not (self == other)
7460 kshitij.so 19484 
 
19485 
class updateItemInventory_args:
19486 
  """
19487 
  Attributes:
19488 
   - itemId
19489 
   - holdInventory
19490 
   - defaultInventory
19491 
  """
19492 
 
19493 
  thrift_spec = (
19494 
    None, # 0
19495 
    (1, TType.I64, 'itemId', None, None, ), # 1
19496 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
19497 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
19498 
  )
19499 
 
19500 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
19501 
    self.itemId = itemId
19502 
    self.holdInventory = holdInventory
19503 
    self.defaultInventory = defaultInventory
19504 
 
19505 
  def read(self, iprot):
19506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19508 
      return
19509 
    iprot.readStructBegin()
19510 
    while True:
19511 
      (fname, ftype, fid) = iprot.readFieldBegin()
19512 
      if ftype == TType.STOP:
19513 
        break
19514 
      if fid == 1:
19515 
        if ftype == TType.I64:
19516 
          self.itemId = iprot.readI64();
19517 
        else:
19518 
          iprot.skip(ftype)
19519 
      elif fid == 2:
19520 
        if ftype == TType.I64:
19521 
          self.holdInventory = iprot.readI64();
19522 
        else:
19523 
          iprot.skip(ftype)
19524 
      elif fid == 3:
19525 
        if ftype == TType.I64:
19526 
          self.defaultInventory = iprot.readI64();
19527 
        else:
19528 
          iprot.skip(ftype)
19529 
      else:
19530 
        iprot.skip(ftype)
19531 
      iprot.readFieldEnd()
19532 
    iprot.readStructEnd()
19533 
 
19534 
  def write(self, oprot):
19535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19537 
      return
19538 
    oprot.writeStructBegin('updateItemInventory_args')
19539 
    if self.itemId is not None:
19540 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19541 
      oprot.writeI64(self.itemId)
19542 
      oprot.writeFieldEnd()
19543 
    if self.holdInventory is not None:
19544 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
19545 
      oprot.writeI64(self.holdInventory)
19546 
      oprot.writeFieldEnd()
19547 
    if self.defaultInventory is not None:
19548 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
19549 
      oprot.writeI64(self.defaultInventory)
19550 
      oprot.writeFieldEnd()
19551 
    oprot.writeFieldStop()
19552 
    oprot.writeStructEnd()
19553 
 
19554 
  def validate(self):
19555 
    return
19556 
 
19557 
 
19558 
  def __repr__(self):
19559 
    L = ['%s=%r' % (key, value)
19560 
      for key, value in self.__dict__.iteritems()]
19561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19562 
 
19563 
  def __eq__(self, other):
19564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19565 
 
19566 
  def __ne__(self, other):
19567 
    return not (self == other)
19568 
 
19569 
class updateItemInventory_result:
19570 
  """
19571 
  Attributes:
19572 
   - success
19573 
  """
19574 
 
19575 
  thrift_spec = (
19576 
    (0, TType.BOOL, 'success', None, None, ), # 0
19577 
  )
19578 
 
19579 
  def __init__(self, success=None,):
19580 
    self.success = success
19581 
 
19582 
  def read(self, iprot):
19583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19585 
      return
19586 
    iprot.readStructBegin()
19587 
    while True:
19588 
      (fname, ftype, fid) = iprot.readFieldBegin()
19589 
      if ftype == TType.STOP:
19590 
        break
19591 
      if fid == 0:
19592 
        if ftype == TType.BOOL:
19593 
          self.success = iprot.readBool();
19594 
        else:
19595 
          iprot.skip(ftype)
19596 
      else:
19597 
        iprot.skip(ftype)
19598 
      iprot.readFieldEnd()
19599 
    iprot.readStructEnd()
19600 
 
19601 
  def write(self, oprot):
19602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19604 
      return
19605 
    oprot.writeStructBegin('updateItemInventory_result')
19606 
    if self.success is not None:
19607 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19608 
      oprot.writeBool(self.success)
19609 
      oprot.writeFieldEnd()
19610 
    oprot.writeFieldStop()
19611 
    oprot.writeStructEnd()
19612 
 
19613 
  def validate(self):
19614 
    return
19615 
 
19616 
 
19617 
  def __repr__(self):
19618 
    L = ['%s=%r' % (key, value)
19619 
      for key, value in self.__dict__.iteritems()]
19620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19621 
 
19622 
  def __eq__(self, other):
19623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19624 
 
19625 
  def __ne__(self, other):
19626 
    return not (self == other)
7770 kshitij.so 19627 
 
19628 
class updateTimestampForAmazonFeeds_args:
19629 
  """
19630 
  Attributes:
19631 
   - type
19632 
   - sku
19633 
   - timestamp
19634 
  """
19635 
 
19636 
  thrift_spec = (
19637 
    None, # 0
19638 
    (1, TType.STRING, 'type', None, None, ), # 1
19639 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
19640 
    (3, TType.I64, 'timestamp', None, None, ), # 3
19641 
  )
19642 
 
19643 
  def __init__(self, type=None, sku=None, timestamp=None,):
19644 
    self.type = type
19645 
    self.sku = sku
19646 
    self.timestamp = timestamp
19647 
 
19648 
  def read(self, iprot):
19649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19651 
      return
19652 
    iprot.readStructBegin()
19653 
    while True:
19654 
      (fname, ftype, fid) = iprot.readFieldBegin()
19655 
      if ftype == TType.STOP:
19656 
        break
19657 
      if fid == 1:
19658 
        if ftype == TType.STRING:
19659 
          self.type = iprot.readString();
19660 
        else:
19661 
          iprot.skip(ftype)
19662 
      elif fid == 2:
19663 
        if ftype == TType.LIST:
19664 
          self.sku = []
8579 kshitij.so 19665 
          (_etype412, _size409) = iprot.readListBegin()
19666 
          for _i413 in xrange(_size409):
19667 
            _elem414 = iprot.readI64();
19668 
            self.sku.append(_elem414)
7770 kshitij.so 19669 
          iprot.readListEnd()
19670 
        else:
19671 
          iprot.skip(ftype)
19672 
      elif fid == 3:
19673 
        if ftype == TType.I64:
19674 
          self.timestamp = iprot.readI64();
19675 
        else:
19676 
          iprot.skip(ftype)
19677 
      else:
19678 
        iprot.skip(ftype)
19679 
      iprot.readFieldEnd()
19680 
    iprot.readStructEnd()
19681 
 
19682 
  def write(self, oprot):
19683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19685 
      return
19686 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
19687 
    if self.type is not None:
19688 
      oprot.writeFieldBegin('type', TType.STRING, 1)
19689 
      oprot.writeString(self.type)
19690 
      oprot.writeFieldEnd()
19691 
    if self.sku is not None:
19692 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
19693 
      oprot.writeListBegin(TType.I64, len(self.sku))
8579 kshitij.so 19694 
      for iter415 in self.sku:
19695 
        oprot.writeI64(iter415)
7770 kshitij.so 19696 
      oprot.writeListEnd()
19697 
      oprot.writeFieldEnd()
19698 
    if self.timestamp is not None:
19699 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
19700 
      oprot.writeI64(self.timestamp)
19701 
      oprot.writeFieldEnd()
19702 
    oprot.writeFieldStop()
19703 
    oprot.writeStructEnd()
19704 
 
19705 
  def validate(self):
19706 
    return
19707 
 
19708 
 
19709 
  def __repr__(self):
19710 
    L = ['%s=%r' % (key, value)
19711 
      for key, value in self.__dict__.iteritems()]
19712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19713 
 
19714 
  def __eq__(self, other):
19715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19716 
 
19717 
  def __ne__(self, other):
19718 
    return not (self == other)
19719 
 
19720 
class updateTimestampForAmazonFeeds_result:
19721 
  """
19722 
  Attributes:
19723 
   - success
19724 
  """
19725 
 
19726 
  thrift_spec = (
19727 
    (0, TType.BOOL, 'success', None, None, ), # 0
19728 
  )
19729 
 
19730 
  def __init__(self, success=None,):
19731 
    self.success = success
19732 
 
19733 
  def read(self, iprot):
19734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19736 
      return
19737 
    iprot.readStructBegin()
19738 
    while True:
19739 
      (fname, ftype, fid) = iprot.readFieldBegin()
19740 
      if ftype == TType.STOP:
19741 
        break
19742 
      if fid == 0:
19743 
        if ftype == TType.BOOL:
19744 
          self.success = iprot.readBool();
19745 
        else:
19746 
          iprot.skip(ftype)
19747 
      else:
19748 
        iprot.skip(ftype)
19749 
      iprot.readFieldEnd()
19750 
    iprot.readStructEnd()
19751 
 
19752 
  def write(self, oprot):
19753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19755 
      return
19756 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
19757 
    if self.success is not None:
19758 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19759 
      oprot.writeBool(self.success)
19760 
      oprot.writeFieldEnd()
19761 
    oprot.writeFieldStop()
19762 
    oprot.writeStructEnd()
19763 
 
19764 
  def validate(self):
19765 
    return
19766 
 
19767 
 
19768 
  def __repr__(self):
19769 
    L = ['%s=%r' % (key, value)
19770 
      for key, value in self.__dict__.iteritems()]
19771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19772 
 
19773 
  def __eq__(self, other):
19774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19775 
 
19776 
  def __ne__(self, other):
19777 
    return not (self == other)
7897 amar.kumar 19778 
 
19779 
class getAllParentCategories_args:
19780 
 
19781 
  thrift_spec = (
19782 
  )
19783 
 
19784 
  def read(self, iprot):
19785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19787 
      return
19788 
    iprot.readStructBegin()
19789 
    while True:
19790 
      (fname, ftype, fid) = iprot.readFieldBegin()
19791 
      if ftype == TType.STOP:
19792 
        break
19793 
      else:
19794 
        iprot.skip(ftype)
19795 
      iprot.readFieldEnd()
19796 
    iprot.readStructEnd()
19797 
 
19798 
  def write(self, oprot):
19799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19801 
      return
19802 
    oprot.writeStructBegin('getAllParentCategories_args')
19803 
    oprot.writeFieldStop()
19804 
    oprot.writeStructEnd()
19805 
 
19806 
  def validate(self):
19807 
    return
19808 
 
19809 
 
19810 
  def __repr__(self):
19811 
    L = ['%s=%r' % (key, value)
19812 
      for key, value in self.__dict__.iteritems()]
19813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19814 
 
19815 
  def __eq__(self, other):
19816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19817 
 
19818 
  def __ne__(self, other):
19819 
    return not (self == other)
19820 
 
19821 
class getAllParentCategories_result:
19822 
  """
19823 
  Attributes:
19824 
   - success
19825 
  """
19826 
 
19827 
  thrift_spec = (
19828 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
19829 
  )
19830 
 
19831 
  def __init__(self, success=None,):
19832 
    self.success = success
19833 
 
19834 
  def read(self, iprot):
19835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19837 
      return
19838 
    iprot.readStructBegin()
19839 
    while True:
19840 
      (fname, ftype, fid) = iprot.readFieldBegin()
19841 
      if ftype == TType.STOP:
19842 
        break
19843 
      if fid == 0:
19844 
        if ftype == TType.LIST:
19845 
          self.success = []
8579 kshitij.so 19846 
          (_etype419, _size416) = iprot.readListBegin()
19847 
          for _i420 in xrange(_size416):
19848 
            _elem421 = Category()
19849 
            _elem421.read(iprot)
19850 
            self.success.append(_elem421)
7897 amar.kumar 19851 
          iprot.readListEnd()
19852 
        else:
19853 
          iprot.skip(ftype)
19854 
      else:
19855 
        iprot.skip(ftype)
19856 
      iprot.readFieldEnd()
19857 
    iprot.readStructEnd()
19858 
 
19859 
  def write(self, oprot):
19860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19862 
      return
19863 
    oprot.writeStructBegin('getAllParentCategories_result')
19864 
    if self.success is not None:
19865 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19866 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 19867 
      for iter422 in self.success:
19868 
        iter422.write(oprot)
7897 amar.kumar 19869 
      oprot.writeListEnd()
19870 
      oprot.writeFieldEnd()
19871 
    oprot.writeFieldStop()
19872 
    oprot.writeStructEnd()
19873 
 
19874 
  def validate(self):
19875 
    return
19876 
 
19877 
 
19878 
  def __repr__(self):
19879 
    L = ['%s=%r' % (key, value)
19880 
      for key, value in self.__dict__.iteritems()]
19881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19882 
 
19883 
  def __eq__(self, other):
19884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19885 
 
19886 
  def __ne__(self, other):
19887 
    return not (self == other)
7977 kshitij.so 19888 
 
19889 
class addPageViewEvent_args:
19890 
  """
19891 
  Attributes:
19892 
   - pageViewEvents
19893 
  """
19894 
 
19895 
  thrift_spec = (
19896 
    None, # 0
19897 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
19898 
  )
19899 
 
19900 
  def __init__(self, pageViewEvents=None,):
19901 
    self.pageViewEvents = pageViewEvents
19902 
 
19903 
  def read(self, iprot):
19904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19906 
      return
19907 
    iprot.readStructBegin()
19908 
    while True:
19909 
      (fname, ftype, fid) = iprot.readFieldBegin()
19910 
      if ftype == TType.STOP:
19911 
        break
19912 
      if fid == 1:
19913 
        if ftype == TType.STRUCT:
19914 
          self.pageViewEvents = PageViewEvents()
19915 
          self.pageViewEvents.read(iprot)
19916 
        else:
19917 
          iprot.skip(ftype)
19918 
      else:
19919 
        iprot.skip(ftype)
19920 
      iprot.readFieldEnd()
19921 
    iprot.readStructEnd()
19922 
 
19923 
  def write(self, oprot):
19924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19926 
      return
19927 
    oprot.writeStructBegin('addPageViewEvent_args')
19928 
    if self.pageViewEvents is not None:
19929 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
19930 
      self.pageViewEvents.write(oprot)
19931 
      oprot.writeFieldEnd()
19932 
    oprot.writeFieldStop()
19933 
    oprot.writeStructEnd()
19934 
 
19935 
  def validate(self):
19936 
    return
19937 
 
19938 
 
19939 
  def __repr__(self):
19940 
    L = ['%s=%r' % (key, value)
19941 
      for key, value in self.__dict__.iteritems()]
19942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19943 
 
19944 
  def __eq__(self, other):
19945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19946 
 
19947 
  def __ne__(self, other):
19948 
    return not (self == other)
19949 
 
19950 
class addPageViewEvent_result:
19951 
 
19952 
  thrift_spec = (
19953 
  )
19954 
 
19955 
  def read(self, iprot):
19956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19958 
      return
19959 
    iprot.readStructBegin()
19960 
    while True:
19961 
      (fname, ftype, fid) = iprot.readFieldBegin()
19962 
      if ftype == TType.STOP:
19963 
        break
19964 
      else:
19965 
        iprot.skip(ftype)
19966 
      iprot.readFieldEnd()
19967 
    iprot.readStructEnd()
19968 
 
19969 
  def write(self, oprot):
19970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19972 
      return
19973 
    oprot.writeStructBegin('addPageViewEvent_result')
19974 
    oprot.writeFieldStop()
19975 
    oprot.writeStructEnd()
19976 
 
19977 
  def validate(self):
19978 
    return
19979 
 
19980 
 
19981 
  def __repr__(self):
19982 
    L = ['%s=%r' % (key, value)
19983 
      for key, value in self.__dict__.iteritems()]
19984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19985 
 
19986 
  def __eq__(self, other):
19987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19988 
 
19989 
  def __ne__(self, other):
19990 
    return not (self == other)
19991 
 
19992 
class addCartEvent_args:
19993 
  """
19994 
  Attributes:
19995 
   - cartEvents
19996 
  """
19997 
 
19998 
  thrift_spec = (
19999 
    None, # 0
20000 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
20001 
  )
20002 
 
20003 
  def __init__(self, cartEvents=None,):
20004 
    self.cartEvents = cartEvents
20005 
 
20006 
  def read(self, iprot):
20007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20009 
      return
20010 
    iprot.readStructBegin()
20011 
    while True:
20012 
      (fname, ftype, fid) = iprot.readFieldBegin()
20013 
      if ftype == TType.STOP:
20014 
        break
20015 
      if fid == 1:
20016 
        if ftype == TType.STRUCT:
20017 
          self.cartEvents = CartEvents()
20018 
          self.cartEvents.read(iprot)
20019 
        else:
20020 
          iprot.skip(ftype)
20021 
      else:
20022 
        iprot.skip(ftype)
20023 
      iprot.readFieldEnd()
20024 
    iprot.readStructEnd()
20025 
 
20026 
  def write(self, oprot):
20027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20029 
      return
20030 
    oprot.writeStructBegin('addCartEvent_args')
20031 
    if self.cartEvents is not None:
20032 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
20033 
      self.cartEvents.write(oprot)
20034 
      oprot.writeFieldEnd()
20035 
    oprot.writeFieldStop()
20036 
    oprot.writeStructEnd()
20037 
 
20038 
  def validate(self):
20039 
    return
20040 
 
20041 
 
20042 
  def __repr__(self):
20043 
    L = ['%s=%r' % (key, value)
20044 
      for key, value in self.__dict__.iteritems()]
20045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20046 
 
20047 
  def __eq__(self, other):
20048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20049 
 
20050 
  def __ne__(self, other):
20051 
    return not (self == other)
20052 
 
20053 
class addCartEvent_result:
20054 
 
20055 
  thrift_spec = (
20056 
  )
20057 
 
20058 
  def read(self, iprot):
20059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20061 
      return
20062 
    iprot.readStructBegin()
20063 
    while True:
20064 
      (fname, ftype, fid) = iprot.readFieldBegin()
20065 
      if ftype == TType.STOP:
20066 
        break
20067 
      else:
20068 
        iprot.skip(ftype)
20069 
      iprot.readFieldEnd()
20070 
    iprot.readStructEnd()
20071 
 
20072 
  def write(self, oprot):
20073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20075 
      return
20076 
    oprot.writeStructBegin('addCartEvent_result')
20077 
    oprot.writeFieldStop()
20078 
    oprot.writeStructEnd()
20079 
 
20080 
  def validate(self):
20081 
    return
20082 
 
20083 
 
20084 
  def __repr__(self):
20085 
    L = ['%s=%r' % (key, value)
20086 
      for key, value in self.__dict__.iteritems()]
20087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20088 
 
20089 
  def __eq__(self, other):
20090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20091 
 
20092 
  def __ne__(self, other):
20093 
    return not (self == other)
8139 kshitij.so 20094 
 
8182 amar.kumar 20095 
class addEbayItem_args:
20096 
  """
20097 
  Attributes:
20098 
   - ebayItem
20099 
  """
20100 
 
20101 
  thrift_spec = (
20102 
    None, # 0
20103 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20104 
  )
20105 
 
20106 
  def __init__(self, ebayItem=None,):
20107 
    self.ebayItem = ebayItem
20108 
 
20109 
  def read(self, iprot):
20110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20112 
      return
20113 
    iprot.readStructBegin()
20114 
    while True:
20115 
      (fname, ftype, fid) = iprot.readFieldBegin()
20116 
      if ftype == TType.STOP:
20117 
        break
20118 
      if fid == 1:
20119 
        if ftype == TType.STRUCT:
20120 
          self.ebayItem = EbayItem()
20121 
          self.ebayItem.read(iprot)
20122 
        else:
20123 
          iprot.skip(ftype)
20124 
      else:
20125 
        iprot.skip(ftype)
20126 
      iprot.readFieldEnd()
20127 
    iprot.readStructEnd()
20128 
 
20129 
  def write(self, oprot):
20130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20132 
      return
20133 
    oprot.writeStructBegin('addEbayItem_args')
20134 
    if self.ebayItem is not None:
20135 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20136 
      self.ebayItem.write(oprot)
20137 
      oprot.writeFieldEnd()
20138 
    oprot.writeFieldStop()
20139 
    oprot.writeStructEnd()
20140 
 
20141 
  def validate(self):
20142 
    return
20143 
 
20144 
 
20145 
  def __repr__(self):
20146 
    L = ['%s=%r' % (key, value)
20147 
      for key, value in self.__dict__.iteritems()]
20148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20149 
 
20150 
  def __eq__(self, other):
20151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20152 
 
20153 
  def __ne__(self, other):
20154 
    return not (self == other)
20155 
 
20156 
class addEbayItem_result:
20157 
 
20158 
  thrift_spec = (
20159 
  )
20160 
 
20161 
  def read(self, iprot):
20162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20164 
      return
20165 
    iprot.readStructBegin()
20166 
    while True:
20167 
      (fname, ftype, fid) = iprot.readFieldBegin()
20168 
      if ftype == TType.STOP:
20169 
        break
20170 
      else:
20171 
        iprot.skip(ftype)
20172 
      iprot.readFieldEnd()
20173 
    iprot.readStructEnd()
20174 
 
20175 
  def write(self, oprot):
20176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20178 
      return
20179 
    oprot.writeStructBegin('addEbayItem_result')
20180 
    oprot.writeFieldStop()
20181 
    oprot.writeStructEnd()
20182 
 
20183 
  def validate(self):
20184 
    return
20185 
 
20186 
 
20187 
  def __repr__(self):
20188 
    L = ['%s=%r' % (key, value)
20189 
      for key, value in self.__dict__.iteritems()]
20190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20191 
 
20192 
  def __eq__(self, other):
20193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20194 
 
20195 
  def __ne__(self, other):
20196 
    return not (self == other)
20197 
 
20198 
class getEbayItem_args:
20199 
  """
20200 
  Attributes:
20201 
   - listingId
20202 
  """
20203 
 
20204 
  thrift_spec = (
20205 
    None, # 0
20206 
    (1, TType.STRING, 'listingId', None, None, ), # 1
20207 
  )
20208 
 
20209 
  def __init__(self, listingId=None,):
20210 
    self.listingId = listingId
20211 
 
20212 
  def read(self, iprot):
20213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20215 
      return
20216 
    iprot.readStructBegin()
20217 
    while True:
20218 
      (fname, ftype, fid) = iprot.readFieldBegin()
20219 
      if ftype == TType.STOP:
20220 
        break
20221 
      if fid == 1:
20222 
        if ftype == TType.STRING:
20223 
          self.listingId = iprot.readString();
20224 
        else:
20225 
          iprot.skip(ftype)
20226 
      else:
20227 
        iprot.skip(ftype)
20228 
      iprot.readFieldEnd()
20229 
    iprot.readStructEnd()
20230 
 
20231 
  def write(self, oprot):
20232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20234 
      return
20235 
    oprot.writeStructBegin('getEbayItem_args')
20236 
    if self.listingId is not None:
20237 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
20238 
      oprot.writeString(self.listingId)
20239 
      oprot.writeFieldEnd()
20240 
    oprot.writeFieldStop()
20241 
    oprot.writeStructEnd()
20242 
 
20243 
  def validate(self):
20244 
    return
20245 
 
20246 
 
20247 
  def __repr__(self):
20248 
    L = ['%s=%r' % (key, value)
20249 
      for key, value in self.__dict__.iteritems()]
20250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20251 
 
20252 
  def __eq__(self, other):
20253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20254 
 
20255 
  def __ne__(self, other):
20256 
    return not (self == other)
20257 
 
20258 
class getEbayItem_result:
20259 
  """
20260 
  Attributes:
20261 
   - success
20262 
  """
20263 
 
20264 
  thrift_spec = (
20265 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
20266 
  )
20267 
 
20268 
  def __init__(self, success=None,):
20269 
    self.success = success
20270 
 
20271 
  def read(self, iprot):
20272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20274 
      return
20275 
    iprot.readStructBegin()
20276 
    while True:
20277 
      (fname, ftype, fid) = iprot.readFieldBegin()
20278 
      if ftype == TType.STOP:
20279 
        break
20280 
      if fid == 0:
20281 
        if ftype == TType.STRUCT:
20282 
          self.success = EbayItem()
20283 
          self.success.read(iprot)
20284 
        else:
20285 
          iprot.skip(ftype)
20286 
      else:
20287 
        iprot.skip(ftype)
20288 
      iprot.readFieldEnd()
20289 
    iprot.readStructEnd()
20290 
 
20291 
  def write(self, oprot):
20292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20294 
      return
20295 
    oprot.writeStructBegin('getEbayItem_result')
20296 
    if self.success is not None:
20297 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20298 
      self.success.write(oprot)
20299 
      oprot.writeFieldEnd()
20300 
    oprot.writeFieldStop()
20301 
    oprot.writeStructEnd()
20302 
 
20303 
  def validate(self):
20304 
    return
20305 
 
20306 
 
20307 
  def __repr__(self):
20308 
    L = ['%s=%r' % (key, value)
20309 
      for key, value in self.__dict__.iteritems()]
20310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20311 
 
20312 
  def __eq__(self, other):
20313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20314 
 
20315 
  def __ne__(self, other):
20316 
    return not (self == other)
20317 
 
20318 
class updateEbayItem_args:
20319 
  """
20320 
  Attributes:
20321 
   - ebayItem
20322 
  """
20323 
 
20324 
  thrift_spec = (
20325 
    None, # 0
20326 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20327 
  )
20328 
 
20329 
  def __init__(self, ebayItem=None,):
20330 
    self.ebayItem = ebayItem
20331 
 
20332 
  def read(self, iprot):
20333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20335 
      return
20336 
    iprot.readStructBegin()
20337 
    while True:
20338 
      (fname, ftype, fid) = iprot.readFieldBegin()
20339 
      if ftype == TType.STOP:
20340 
        break
20341 
      if fid == 1:
20342 
        if ftype == TType.STRUCT:
20343 
          self.ebayItem = EbayItem()
20344 
          self.ebayItem.read(iprot)
20345 
        else:
20346 
          iprot.skip(ftype)
20347 
      else:
20348 
        iprot.skip(ftype)
20349 
      iprot.readFieldEnd()
20350 
    iprot.readStructEnd()
20351 
 
20352 
  def write(self, oprot):
20353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20355 
      return
20356 
    oprot.writeStructBegin('updateEbayItem_args')
20357 
    if self.ebayItem is not None:
20358 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20359 
      self.ebayItem.write(oprot)
20360 
      oprot.writeFieldEnd()
20361 
    oprot.writeFieldStop()
20362 
    oprot.writeStructEnd()
20363 
 
20364 
  def validate(self):
20365 
    return
20366 
 
20367 
 
20368 
  def __repr__(self):
20369 
    L = ['%s=%r' % (key, value)
20370 
      for key, value in self.__dict__.iteritems()]
20371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20372 
 
20373 
  def __eq__(self, other):
20374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20375 
 
20376 
  def __ne__(self, other):
20377 
    return not (self == other)
20378 
 
20379 
class updateEbayItem_result:
20380 
 
20381 
  thrift_spec = (
20382 
  )
20383 
 
20384 
  def read(self, iprot):
20385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20387 
      return
20388 
    iprot.readStructBegin()
20389 
    while True:
20390 
      (fname, ftype, fid) = iprot.readFieldBegin()
20391 
      if ftype == TType.STOP:
20392 
        break
20393 
      else:
20394 
        iprot.skip(ftype)
20395 
      iprot.readFieldEnd()
20396 
    iprot.readStructEnd()
20397 
 
20398 
  def write(self, oprot):
20399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20401 
      return
20402 
    oprot.writeStructBegin('updateEbayItem_result')
20403 
    oprot.writeFieldStop()
20404 
    oprot.writeStructEnd()
20405 
 
20406 
  def validate(self):
20407 
    return
20408 
 
20409 
 
20410 
  def __repr__(self):
20411 
    L = ['%s=%r' % (key, value)
20412 
      for key, value in self.__dict__.iteritems()]
20413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20414 
 
20415 
  def __eq__(self, other):
20416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20417 
 
20418 
  def __ne__(self, other):
20419 
    return not (self == other)
20420 
 
8139 kshitij.so 20421 
class getAmazonListedItems_args:
20422 
  """
20423 
  Attributes:
20424 
   - offset
20425 
   - limit
20426 
  """
20427 
 
20428 
  thrift_spec = (
20429 
    None, # 0
20430 
    (1, TType.I64, 'offset', None, None, ), # 1
20431 
    (2, TType.I64, 'limit', None, None, ), # 2
20432 
  )
20433 
 
20434 
  def __init__(self, offset=None, limit=None,):
20435 
    self.offset = offset
20436 
    self.limit = limit
20437 
 
20438 
  def read(self, iprot):
20439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20441 
      return
20442 
    iprot.readStructBegin()
20443 
    while True:
20444 
      (fname, ftype, fid) = iprot.readFieldBegin()
20445 
      if ftype == TType.STOP:
20446 
        break
20447 
      if fid == 1:
20448 
        if ftype == TType.I64:
20449 
          self.offset = iprot.readI64();
20450 
        else:
20451 
          iprot.skip(ftype)
20452 
      elif fid == 2:
20453 
        if ftype == TType.I64:
20454 
          self.limit = iprot.readI64();
20455 
        else:
20456 
          iprot.skip(ftype)
20457 
      else:
20458 
        iprot.skip(ftype)
20459 
      iprot.readFieldEnd()
20460 
    iprot.readStructEnd()
20461 
 
20462 
  def write(self, oprot):
20463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20465 
      return
20466 
    oprot.writeStructBegin('getAmazonListedItems_args')
20467 
    if self.offset is not None:
20468 
      oprot.writeFieldBegin('offset', TType.I64, 1)
20469 
      oprot.writeI64(self.offset)
20470 
      oprot.writeFieldEnd()
20471 
    if self.limit is not None:
20472 
      oprot.writeFieldBegin('limit', TType.I64, 2)
20473 
      oprot.writeI64(self.limit)
20474 
      oprot.writeFieldEnd()
20475 
    oprot.writeFieldStop()
20476 
    oprot.writeStructEnd()
20477 
 
20478 
  def validate(self):
20479 
    return
20480 
 
20481 
 
20482 
  def __repr__(self):
20483 
    L = ['%s=%r' % (key, value)
20484 
      for key, value in self.__dict__.iteritems()]
20485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20486 
 
20487 
  def __eq__(self, other):
20488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20489 
 
20490 
  def __ne__(self, other):
20491 
    return not (self == other)
20492 
 
20493 
class getAmazonListedItems_result:
20494 
  """
20495 
  Attributes:
20496 
   - success
20497 
  """
20498 
 
20499 
  thrift_spec = (
20500 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20501 
  )
20502 
 
20503 
  def __init__(self, success=None,):
20504 
    self.success = success
20505 
 
20506 
  def read(self, iprot):
20507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20509 
      return
20510 
    iprot.readStructBegin()
20511 
    while True:
20512 
      (fname, ftype, fid) = iprot.readFieldBegin()
20513 
      if ftype == TType.STOP:
20514 
        break
20515 
      if fid == 0:
20516 
        if ftype == TType.LIST:
20517 
          self.success = []
8579 kshitij.so 20518 
          (_etype426, _size423) = iprot.readListBegin()
20519 
          for _i427 in xrange(_size423):
20520 
            _elem428 = Amazonlisted()
20521 
            _elem428.read(iprot)
20522 
            self.success.append(_elem428)
8139 kshitij.so 20523 
          iprot.readListEnd()
20524 
        else:
20525 
          iprot.skip(ftype)
20526 
      else:
20527 
        iprot.skip(ftype)
20528 
      iprot.readFieldEnd()
20529 
    iprot.readStructEnd()
20530 
 
20531 
  def write(self, oprot):
20532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20534 
      return
20535 
    oprot.writeStructBegin('getAmazonListedItems_result')
20536 
    if self.success is not None:
20537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20538 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 20539 
      for iter429 in self.success:
20540 
        iter429.write(oprot)
8139 kshitij.so 20541 
      oprot.writeListEnd()
20542 
      oprot.writeFieldEnd()
20543 
    oprot.writeFieldStop()
20544 
    oprot.writeStructEnd()
20545 
 
20546 
  def validate(self):
20547 
    return
20548 
 
20549 
 
20550 
  def __repr__(self):
20551 
    L = ['%s=%r' % (key, value)
20552 
      for key, value in self.__dict__.iteritems()]
20553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20554 
 
20555 
  def __eq__(self, other):
20556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20557 
 
20558 
  def __ne__(self, other):
20559 
    return not (self == other)
8168 kshitij.so 20560 
 
20561 
class updateAmazonAttributesInBulk_args:
20562 
  """
20563 
  Attributes:
20564 
   - amazonlisted
20565 
  """
20566 
 
20567 
  thrift_spec = (
20568 
    None, # 0
20569 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
20570 
  )
20571 
 
20572 
  def __init__(self, amazonlisted=None,):
20573 
    self.amazonlisted = amazonlisted
20574 
 
20575 
  def read(self, iprot):
20576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20578 
      return
20579 
    iprot.readStructBegin()
20580 
    while True:
20581 
      (fname, ftype, fid) = iprot.readFieldBegin()
20582 
      if ftype == TType.STOP:
20583 
        break
20584 
      if fid == 1:
20585 
        if ftype == TType.MAP:
20586 
          self.amazonlisted = {}
8579 kshitij.so 20587 
          (_ktype431, _vtype432, _size430 ) = iprot.readMapBegin()
20588 
          for _i434 in xrange(_size430):
20589 
            _key435 = iprot.readI64();
20590 
            _val436 = Amazonlisted()
20591 
            _val436.read(iprot)
20592 
            self.amazonlisted[_key435] = _val436
8168 kshitij.so 20593 
          iprot.readMapEnd()
20594 
        else:
20595 
          iprot.skip(ftype)
20596 
      else:
20597 
        iprot.skip(ftype)
20598 
      iprot.readFieldEnd()
20599 
    iprot.readStructEnd()
20600 
 
20601 
  def write(self, oprot):
20602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20604 
      return
20605 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
20606 
    if self.amazonlisted is not None:
20607 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
20608 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
8579 kshitij.so 20609 
      for kiter437,viter438 in self.amazonlisted.items():
20610 
        oprot.writeI64(kiter437)
20611 
        viter438.write(oprot)
8168 kshitij.so 20612 
      oprot.writeMapEnd()
20613 
      oprot.writeFieldEnd()
20614 
    oprot.writeFieldStop()
20615 
    oprot.writeStructEnd()
20616 
 
20617 
  def validate(self):
20618 
    return
20619 
 
20620 
 
20621 
  def __repr__(self):
20622 
    L = ['%s=%r' % (key, value)
20623 
      for key, value in self.__dict__.iteritems()]
20624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20625 
 
20626 
  def __eq__(self, other):
20627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20628 
 
20629 
  def __ne__(self, other):
20630 
    return not (self == other)
20631 
 
20632 
class updateAmazonAttributesInBulk_result:
20633 
  """
20634 
  Attributes:
20635 
   - success
20636 
  """
20637 
 
20638 
  thrift_spec = (
20639 
    (0, TType.BOOL, 'success', None, None, ), # 0
20640 
  )
20641 
 
20642 
  def __init__(self, success=None,):
20643 
    self.success = success
20644 
 
20645 
  def read(self, iprot):
20646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20648 
      return
20649 
    iprot.readStructBegin()
20650 
    while True:
20651 
      (fname, ftype, fid) = iprot.readFieldBegin()
20652 
      if ftype == TType.STOP:
20653 
        break
20654 
      if fid == 0:
20655 
        if ftype == TType.BOOL:
20656 
          self.success = iprot.readBool();
20657 
        else:
20658 
          iprot.skip(ftype)
20659 
      else:
20660 
        iprot.skip(ftype)
20661 
      iprot.readFieldEnd()
20662 
    iprot.readStructEnd()
20663 
 
20664 
  def write(self, oprot):
20665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20667 
      return
20668 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
20669 
    if self.success is not None:
20670 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20671 
      oprot.writeBool(self.success)
20672 
      oprot.writeFieldEnd()
20673 
    oprot.writeFieldStop()
20674 
    oprot.writeStructEnd()
20675 
 
20676 
  def validate(self):
20677 
    return
20678 
 
20679 
 
20680 
  def __repr__(self):
20681 
    L = ['%s=%r' % (key, value)
20682 
      for key, value in self.__dict__.iteritems()]
20683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20684 
 
20685 
  def __eq__(self, other):
20686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20687 
 
20688 
  def __ne__(self, other):
20689 
    return not (self == other)
8379 vikram.rag 20690 
 
20691 
class getAllItemstoListOnFba_args:
20692 
 
20693 
  thrift_spec = (
20694 
  )
20695 
 
20696 
  def read(self, iprot):
20697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20699 
      return
20700 
    iprot.readStructBegin()
20701 
    while True:
20702 
      (fname, ftype, fid) = iprot.readFieldBegin()
20703 
      if ftype == TType.STOP:
20704 
        break
20705 
      else:
20706 
        iprot.skip(ftype)
20707 
      iprot.readFieldEnd()
20708 
    iprot.readStructEnd()
20709 
 
20710 
  def write(self, oprot):
20711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20713 
      return
20714 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
20715 
    oprot.writeFieldStop()
20716 
    oprot.writeStructEnd()
20717 
 
20718 
  def validate(self):
20719 
    return
20720 
 
20721 
 
20722 
  def __repr__(self):
20723 
    L = ['%s=%r' % (key, value)
20724 
      for key, value in self.__dict__.iteritems()]
20725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20726 
 
20727 
  def __eq__(self, other):
20728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20729 
 
20730 
  def __ne__(self, other):
20731 
    return not (self == other)
20732 
 
20733 
class getAllItemstoListOnFba_result:
20734 
  """
20735 
  Attributes:
20736 
   - success
20737 
  """
20738 
 
20739 
  thrift_spec = (
20740 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20741 
  )
20742 
 
20743 
  def __init__(self, success=None,):
20744 
    self.success = success
20745 
 
20746 
  def read(self, iprot):
20747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20749 
      return
20750 
    iprot.readStructBegin()
20751 
    while True:
20752 
      (fname, ftype, fid) = iprot.readFieldBegin()
20753 
      if ftype == TType.STOP:
20754 
        break
20755 
      if fid == 0:
20756 
        if ftype == TType.LIST:
20757 
          self.success = []
8579 kshitij.so 20758 
          (_etype442, _size439) = iprot.readListBegin()
20759 
          for _i443 in xrange(_size439):
20760 
            _elem444 = Amazonlisted()
20761 
            _elem444.read(iprot)
20762 
            self.success.append(_elem444)
8379 vikram.rag 20763 
          iprot.readListEnd()
20764 
        else:
20765 
          iprot.skip(ftype)
20766 
      else:
20767 
        iprot.skip(ftype)
20768 
      iprot.readFieldEnd()
20769 
    iprot.readStructEnd()
20770 
 
20771 
  def write(self, oprot):
20772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20774 
      return
20775 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
20776 
    if self.success is not None:
20777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 20779 
      for iter445 in self.success:
20780 
        iter445.write(oprot)
8379 vikram.rag 20781 
      oprot.writeListEnd()
20782 
      oprot.writeFieldEnd()
20783 
    oprot.writeFieldStop()
20784 
    oprot.writeStructEnd()
20785 
 
20786 
  def validate(self):
20787 
    return
20788 
 
20789 
 
20790 
  def __repr__(self):
20791 
    L = ['%s=%r' % (key, value)
20792 
      for key, value in self.__dict__.iteritems()]
20793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20794 
 
20795 
  def __eq__(self, other):
20796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20797 
 
20798 
  def __ne__(self, other):
20799 
    return not (self == other)
20800 
 
20801 
class getAllItemstoListOnNonFba_args:
20802 
 
20803 
  thrift_spec = (
20804 
  )
20805 
 
20806 
  def read(self, iprot):
20807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20809 
      return
20810 
    iprot.readStructBegin()
20811 
    while True:
20812 
      (fname, ftype, fid) = iprot.readFieldBegin()
20813 
      if ftype == TType.STOP:
20814 
        break
20815 
      else:
20816 
        iprot.skip(ftype)
20817 
      iprot.readFieldEnd()
20818 
    iprot.readStructEnd()
20819 
 
20820 
  def write(self, oprot):
20821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20823 
      return
20824 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
20825 
    oprot.writeFieldStop()
20826 
    oprot.writeStructEnd()
20827 
 
20828 
  def validate(self):
20829 
    return
20830 
 
20831 
 
20832 
  def __repr__(self):
20833 
    L = ['%s=%r' % (key, value)
20834 
      for key, value in self.__dict__.iteritems()]
20835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20836 
 
20837 
  def __eq__(self, other):
20838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20839 
 
20840 
  def __ne__(self, other):
20841 
    return not (self == other)
20842 
 
20843 
class getAllItemstoListOnNonFba_result:
20844 
  """
20845 
  Attributes:
20846 
   - success
20847 
  """
20848 
 
20849 
  thrift_spec = (
20850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20851 
  )
20852 
 
20853 
  def __init__(self, success=None,):
20854 
    self.success = success
20855 
 
20856 
  def read(self, iprot):
20857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20859 
      return
20860 
    iprot.readStructBegin()
20861 
    while True:
20862 
      (fname, ftype, fid) = iprot.readFieldBegin()
20863 
      if ftype == TType.STOP:
20864 
        break
20865 
      if fid == 0:
20866 
        if ftype == TType.LIST:
20867 
          self.success = []
8579 kshitij.so 20868 
          (_etype449, _size446) = iprot.readListBegin()
20869 
          for _i450 in xrange(_size446):
20870 
            _elem451 = Amazonlisted()
20871 
            _elem451.read(iprot)
20872 
            self.success.append(_elem451)
8379 vikram.rag 20873 
          iprot.readListEnd()
20874 
        else:
20875 
          iprot.skip(ftype)
20876 
      else:
20877 
        iprot.skip(ftype)
20878 
      iprot.readFieldEnd()
20879 
    iprot.readStructEnd()
20880 
 
20881 
  def write(self, oprot):
20882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20884 
      return
20885 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
20886 
    if self.success is not None:
20887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8579 kshitij.so 20889 
      for iter452 in self.success:
20890 
        iter452.write(oprot)
8379 vikram.rag 20891 
      oprot.writeListEnd()
20892 
      oprot.writeFieldEnd()
20893 
    oprot.writeFieldStop()
20894 
    oprot.writeStructEnd()
20895 
 
20896 
  def validate(self):
20897 
    return
20898 
 
20899 
 
20900 
  def __repr__(self):
20901 
    L = ['%s=%r' % (key, value)
20902 
      for key, value in self.__dict__.iteritems()]
20903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20904 
 
20905 
  def __eq__(self, other):
20906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20907 
 
20908 
  def __ne__(self, other):
20909 
    return not (self == other)