Subversion Repositories SmartDukaan

Rev

Rev 8579 | Rev 8616 | 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 
 
8590 kshitij.so 316 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 317 
    """
8579 kshitij.so 318 
    Banner Related
319 
 
6850 kshitij.so 320 
    Parameters:
8590 kshitij.so 321 
     - bannerCongregate
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 
 
8590 kshitij.so 2178 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2179 
    """
8579 kshitij.so 2180 
    Banner Related
2181 
 
6850 kshitij.so 2182 
    Parameters:
8590 kshitij.so 2183 
     - bannerCongregate
6850 kshitij.so 2184 
    """
8590 kshitij.so 2185 
    self.send_addBanner(bannerCongregate)
2186 
    self.recv_addBanner()
6850 kshitij.so 2187 
 
8590 kshitij.so 2188 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2189 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2190 
    args = addBanner_args()
8590 kshitij.so 2191 
    args.bannerCongregate = bannerCongregate
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()
8590 kshitij.so 2206 
    return
6850 kshitij.so 2207 
 
8579 kshitij.so 2208 
  def updateBanner(self, banner):
2209 
    """
2210 
    Parameters:
2211 
     - banner
2212 
    """
2213 
    self.send_updateBanner(banner)
2214 
    return self.recv_updateBanner()
2215 
 
2216 
  def send_updateBanner(self, banner):
2217 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2218 
    args = updateBanner_args()
2219 
    args.banner = banner
2220 
    args.write(self._oprot)
2221 
    self._oprot.writeMessageEnd()
2222 
    self._oprot.trans.flush()
2223 
 
2224 
  def recv_updateBanner(self, ):
2225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2226 
    if mtype == TMessageType.EXCEPTION:
2227 
      x = TApplicationException()
2228 
      x.read(self._iprot)
2229 
      self._iprot.readMessageEnd()
2230 
      raise x
2231 
    result = updateBanner_result()
2232 
    result.read(self._iprot)
2233 
    self._iprot.readMessageEnd()
2234 
    if result.success is not None:
2235 
      return result.success
2236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2237 
 
6850 kshitij.so 2238 
  def getAllBanners(self, ):
2239 
    self.send_getAllBanners()
2240 
    return self.recv_getAllBanners()
2241 
 
2242 
  def send_getAllBanners(self, ):
2243 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2244 
    args = getAllBanners_args()
2245 
    args.write(self._oprot)
2246 
    self._oprot.writeMessageEnd()
2247 
    self._oprot.trans.flush()
2248 
 
2249 
  def recv_getAllBanners(self, ):
2250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2251 
    if mtype == TMessageType.EXCEPTION:
2252 
      x = TApplicationException()
2253 
      x.read(self._iprot)
2254 
      self._iprot.readMessageEnd()
2255 
      raise x
2256 
    result = getAllBanners_result()
2257 
    result.read(self._iprot)
2258 
    self._iprot.readMessageEnd()
2259 
    if result.success is not None:
2260 
      return result.success
2261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2262 
 
2263 
  def deleteBanner(self, bannerName):
2264 
    """
2265 
    Parameters:
2266 
     - bannerName
2267 
    """
2268 
    self.send_deleteBanner(bannerName)
2269 
    return self.recv_deleteBanner()
2270 
 
2271 
  def send_deleteBanner(self, bannerName):
2272 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2273 
    args = deleteBanner_args()
2274 
    args.bannerName = bannerName
2275 
    args.write(self._oprot)
2276 
    self._oprot.writeMessageEnd()
2277 
    self._oprot.trans.flush()
2278 
 
2279 
  def recv_deleteBanner(self, ):
2280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2281 
    if mtype == TMessageType.EXCEPTION:
2282 
      x = TApplicationException()
2283 
      x.read(self._iprot)
2284 
      self._iprot.readMessageEnd()
2285 
      raise x
2286 
    result = deleteBanner_result()
2287 
    result.read(self._iprot)
2288 
    self._iprot.readMessageEnd()
2289 
    if result.success is not None:
2290 
      return result.success
2291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2292 
 
2293 
  def getBannerDetails(self, bannerName):
2294 
    """
2295 
    Parameters:
2296 
     - bannerName
2297 
    """
2298 
    self.send_getBannerDetails(bannerName)
2299 
    return self.recv_getBannerDetails()
2300 
 
2301 
  def send_getBannerDetails(self, bannerName):
2302 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2303 
    args = getBannerDetails_args()
2304 
    args.bannerName = bannerName
2305 
    args.write(self._oprot)
2306 
    self._oprot.writeMessageEnd()
2307 
    self._oprot.trans.flush()
2308 
 
2309 
  def recv_getBannerDetails(self, ):
2310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2311 
    if mtype == TMessageType.EXCEPTION:
2312 
      x = TApplicationException()
2313 
      x.read(self._iprot)
2314 
      self._iprot.readMessageEnd()
2315 
      raise x
2316 
    result = getBannerDetails_result()
2317 
    result.read(self._iprot)
2318 
    self._iprot.readMessageEnd()
2319 
    if result.success is not None:
2320 
      return result.success
2321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2322 
 
2323 
  def getActiveBanners(self, ):
2324 
    self.send_getActiveBanners()
2325 
    return self.recv_getActiveBanners()
2326 
 
2327 
  def send_getActiveBanners(self, ):
2328 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2329 
    args = getActiveBanners_args()
2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
2334 
  def recv_getActiveBanners(self, ):
2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
2341 
    result = getActiveBanners_result()
2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
2344 
    if result.success is not None:
2345 
      return result.success
2346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2347 
 
8579 kshitij.so 2348 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2349 
    """
2350 
    Parameters:
8579 kshitij.so 2351 
     - bannerMaps
6849 kshitij.so 2352 
    """
8579 kshitij.so 2353 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2354 
    return self.recv_addBannerMap()
2355 
 
8579 kshitij.so 2356 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2357 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2358 
    args = addBannerMap_args()
8579 kshitij.so 2359 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2360 
    args.write(self._oprot)
2361 
    self._oprot.writeMessageEnd()
2362 
    self._oprot.trans.flush()
2363 
 
2364 
  def recv_addBannerMap(self, ):
2365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2366 
    if mtype == TMessageType.EXCEPTION:
2367 
      x = TApplicationException()
2368 
      x.read(self._iprot)
2369 
      self._iprot.readMessageEnd()
2370 
      raise x
2371 
    result = addBannerMap_result()
2372 
    result.read(self._iprot)
2373 
    self._iprot.readMessageEnd()
2374 
    if result.success is not None:
2375 
      return result.success
2376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2377 
 
8579 kshitij.so 2378 
  def updateBannerMap(self, bannerMap):
2379 
    """
2380 
    Parameters:
2381 
     - bannerMap
2382 
    """
2383 
    self.send_updateBannerMap(bannerMap)
2384 
    return self.recv_updateBannerMap()
2385 
 
2386 
  def send_updateBannerMap(self, bannerMap):
2387 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2388 
    args = updateBannerMap_args()
2389 
    args.bannerMap = bannerMap
2390 
    args.write(self._oprot)
2391 
    self._oprot.writeMessageEnd()
2392 
    self._oprot.trans.flush()
2393 
 
2394 
  def recv_updateBannerMap(self, ):
2395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2396 
    if mtype == TMessageType.EXCEPTION:
2397 
      x = TApplicationException()
2398 
      x.read(self._iprot)
2399 
      self._iprot.readMessageEnd()
2400 
      raise x
2401 
    result = updateBannerMap_result()
2402 
    result.read(self._iprot)
2403 
    self._iprot.readMessageEnd()
2404 
    if result.success is not None:
2405 
      return result.success
2406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2407 
 
6849 kshitij.so 2408 
  def deleteBannerMap(self, bannerName):
2409 
    """
2410 
    Parameters:
2411 
     - bannerName
2412 
    """
2413 
    self.send_deleteBannerMap(bannerName)
2414 
    return self.recv_deleteBannerMap()
2415 
 
2416 
  def send_deleteBannerMap(self, bannerName):
2417 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2418 
    args = deleteBannerMap_args()
2419 
    args.bannerName = bannerName
2420 
    args.write(self._oprot)
2421 
    self._oprot.writeMessageEnd()
2422 
    self._oprot.trans.flush()
2423 
 
2424 
  def recv_deleteBannerMap(self, ):
2425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2426 
    if mtype == TMessageType.EXCEPTION:
2427 
      x = TApplicationException()
2428 
      x.read(self._iprot)
2429 
      self._iprot.readMessageEnd()
2430 
      raise x
2431 
    result = deleteBannerMap_result()
2432 
    result.read(self._iprot)
2433 
    self._iprot.readMessageEnd()
2434 
    if result.success is not None:
2435 
      return result.success
2436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2437 
 
2438 
  def getBannerMapDetails(self, bannerName):
2439 
    """
2440 
    Parameters:
2441 
     - bannerName
2442 
    """
2443 
    self.send_getBannerMapDetails(bannerName)
2444 
    return self.recv_getBannerMapDetails()
2445 
 
2446 
  def send_getBannerMapDetails(self, bannerName):
2447 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2448 
    args = getBannerMapDetails_args()
2449 
    args.bannerName = bannerName
2450 
    args.write(self._oprot)
2451 
    self._oprot.writeMessageEnd()
2452 
    self._oprot.trans.flush()
2453 
 
2454 
  def recv_getBannerMapDetails(self, ):
2455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2456 
    if mtype == TMessageType.EXCEPTION:
2457 
      x = TApplicationException()
2458 
      x.read(self._iprot)
2459 
      self._iprot.readMessageEnd()
2460 
      raise x
2461 
    result = getBannerMapDetails_result()
2462 
    result.read(self._iprot)
2463 
    self._iprot.readMessageEnd()
2464 
    if result.success is not None:
2465 
      return result.success
2466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2467 
 
8579 kshitij.so 2468 
  def addBannerUri(self, bannerUriMappings):
2469 
    """
2470 
    Parameters:
2471 
     - bannerUriMappings
2472 
    """
2473 
    self.send_addBannerUri(bannerUriMappings)
2474 
    self.recv_addBannerUri()
2475 
 
2476 
  def send_addBannerUri(self, bannerUriMappings):
2477 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2478 
    args = addBannerUri_args()
2479 
    args.bannerUriMappings = bannerUriMappings
2480 
    args.write(self._oprot)
2481 
    self._oprot.writeMessageEnd()
2482 
    self._oprot.trans.flush()
2483 
 
2484 
  def recv_addBannerUri(self, ):
2485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2486 
    if mtype == TMessageType.EXCEPTION:
2487 
      x = TApplicationException()
2488 
      x.read(self._iprot)
2489 
      self._iprot.readMessageEnd()
2490 
      raise x
2491 
    result = addBannerUri_result()
2492 
    result.read(self._iprot)
2493 
    self._iprot.readMessageEnd()
2494 
    return
2495 
 
2496 
  def getUriMapping(self, bannerName):
2497 
    """
2498 
    Parameters:
2499 
     - bannerName
2500 
    """
2501 
    self.send_getUriMapping(bannerName)
2502 
    return self.recv_getUriMapping()
2503 
 
2504 
  def send_getUriMapping(self, bannerName):
2505 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2506 
    args = getUriMapping_args()
2507 
    args.bannerName = bannerName
2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_getUriMapping(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = getUriMapping_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
2522 
    if result.success is not None:
2523 
      return result.success
2524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2525 
 
2526 
  def addCampaign(self, campaign):
2527 
    """
2528 
    Parameters:
2529 
     - campaign
2530 
    """
2531 
    self.send_addCampaign(campaign)
2532 
    self.recv_addCampaign()
2533 
 
2534 
  def send_addCampaign(self, campaign):
2535 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2536 
    args = addCampaign_args()
2537 
    args.campaign = campaign
2538 
    args.write(self._oprot)
2539 
    self._oprot.writeMessageEnd()
2540 
    self._oprot.trans.flush()
2541 
 
2542 
  def recv_addCampaign(self, ):
2543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2544 
    if mtype == TMessageType.EXCEPTION:
2545 
      x = TApplicationException()
2546 
      x.read(self._iprot)
2547 
      self._iprot.readMessageEnd()
2548 
      raise x
2549 
    result = addCampaign_result()
2550 
    result.read(self._iprot)
2551 
    self._iprot.readMessageEnd()
2552 
    return
2553 
 
2554 
  def getCampaigns(self, campaignName):
2555 
    """
2556 
    Parameters:
2557 
     - campaignName
2558 
    """
2559 
    self.send_getCampaigns(campaignName)
2560 
    return self.recv_getCampaigns()
2561 
 
2562 
  def send_getCampaigns(self, campaignName):
2563 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2564 
    args = getCampaigns_args()
2565 
    args.campaignName = campaignName
2566 
    args.write(self._oprot)
2567 
    self._oprot.writeMessageEnd()
2568 
    self._oprot.trans.flush()
2569 
 
2570 
  def recv_getCampaigns(self, ):
2571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2572 
    if mtype == TMessageType.EXCEPTION:
2573 
      x = TApplicationException()
2574 
      x.read(self._iprot)
2575 
      self._iprot.readMessageEnd()
2576 
      raise x
2577 
    result = getCampaigns_result()
2578 
    result.read(self._iprot)
2579 
    self._iprot.readMessageEnd()
2580 
    if result.success is not None:
2581 
      return result.success
2582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2583 
 
2584 
  def deleteCampaign(self, campaignId):
2585 
    """
2586 
    Parameters:
2587 
     - campaignId
2588 
    """
2589 
    self.send_deleteCampaign(campaignId)
2590 
    self.recv_deleteCampaign()
2591 
 
2592 
  def send_deleteCampaign(self, campaignId):
2593 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2594 
    args = deleteCampaign_args()
2595 
    args.campaignId = campaignId
2596 
    args.write(self._oprot)
2597 
    self._oprot.writeMessageEnd()
2598 
    self._oprot.trans.flush()
2599 
 
2600 
  def recv_deleteCampaign(self, ):
2601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2602 
    if mtype == TMessageType.EXCEPTION:
2603 
      x = TApplicationException()
2604 
      x.read(self._iprot)
2605 
      self._iprot.readMessageEnd()
2606 
      raise x
2607 
    result = deleteCampaign_result()
2608 
    result.read(self._iprot)
2609 
    self._iprot.readMessageEnd()
2610 
    return
2611 
 
2612 
  def getAllCampaigns(self, ):
2613 
    self.send_getAllCampaigns()
2614 
    return self.recv_getAllCampaigns()
2615 
 
2616 
  def send_getAllCampaigns(self, ):
2617 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2618 
    args = getAllCampaigns_args()
2619 
    args.write(self._oprot)
2620 
    self._oprot.writeMessageEnd()
2621 
    self._oprot.trans.flush()
2622 
 
2623 
  def recv_getAllCampaigns(self, ):
2624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2625 
    if mtype == TMessageType.EXCEPTION:
2626 
      x = TApplicationException()
2627 
      x.read(self._iprot)
2628 
      self._iprot.readMessageEnd()
2629 
      raise x
2630 
    result = getAllCampaigns_result()
2631 
    result.read(self._iprot)
2632 
    self._iprot.readMessageEnd()
2633 
    if result.success is not None:
2634 
      return result.success
2635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2636 
 
5944 mandeep.dh 2637 
  def deleteSimilarItem(self, itemId, catalogItemId):
2638 
    """
2639 
    Delete similar item.
2640 
 
2641 
    Parameters:
2642 
     - itemId
2643 
     - catalogItemId
2644 
    """
2645 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2646 
    return self.recv_deleteSimilarItem()
2647 
 
2648 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2649 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2650 
    args = deleteSimilarItem_args()
2651 
    args.itemId = itemId
2652 
    args.catalogItemId = catalogItemId
2653 
    args.write(self._oprot)
2654 
    self._oprot.writeMessageEnd()
2655 
    self._oprot.trans.flush()
2656 
 
2657 
  def recv_deleteSimilarItem(self, ):
2658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2659 
    if mtype == TMessageType.EXCEPTION:
2660 
      x = TApplicationException()
2661 
      x.read(self._iprot)
2662 
      self._iprot.readMessageEnd()
2663 
      raise x
2664 
    result = deleteSimilarItem_result()
2665 
    result.read(self._iprot)
2666 
    self._iprot.readMessageEnd()
2667 
    if result.success is not None:
2668 
      return result.success
2669 
    if result.cex is not None:
2670 
      raise result.cex
2671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2672 
 
2673 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2674 
    """
2675 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2676 
    If yes, returns the itemId else returns 0
2677 
 
2678 
    Parameters:
2679 
     - brand
2680 
     - modelNumber
2681 
     - modelName
2682 
     - color
2683 
    """
2684 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2685 
    return self.recv_checkSimilarItem()
2686 
 
2687 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2688 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2689 
    args = checkSimilarItem_args()
2690 
    args.brand = brand
2691 
    args.modelNumber = modelNumber
2692 
    args.modelName = modelName
2693 
    args.color = color
2694 
    args.write(self._oprot)
2695 
    self._oprot.writeMessageEnd()
2696 
    self._oprot.trans.flush()
2697 
 
2698 
  def recv_checkSimilarItem(self, ):
2699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2700 
    if mtype == TMessageType.EXCEPTION:
2701 
      x = TApplicationException()
2702 
      x.read(self._iprot)
2703 
      self._iprot.readMessageEnd()
2704 
      raise x
2705 
    result = checkSimilarItem_result()
2706 
    result.read(self._iprot)
2707 
    self._iprot.readMessageEnd()
2708 
    if result.success is not None:
2709 
      return result.success
2710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2711 
 
2712 
  def validateRiskyStatus(self, itemId):
2713 
    """
2714 
    Check wether item is risky and change status if inventory is not available for risky items
2715 
 
2716 
    Parameters:
2717 
     - itemId
2718 
    """
2719 
    self.send_validateRiskyStatus(itemId)
2720 
    self.recv_validateRiskyStatus()
2721 
 
2722 
  def send_validateRiskyStatus(self, itemId):
2723 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2724 
    args = validateRiskyStatus_args()
2725 
    args.itemId = itemId
2726 
    args.write(self._oprot)
2727 
    self._oprot.writeMessageEnd()
2728 
    self._oprot.trans.flush()
2729 
 
2730 
  def recv_validateRiskyStatus(self, ):
2731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2732 
    if mtype == TMessageType.EXCEPTION:
2733 
      x = TApplicationException()
2734 
      x.read(self._iprot)
2735 
      self._iprot.readMessageEnd()
2736 
      raise x
2737 
    result = validateRiskyStatus_result()
2738 
    result.read(self._iprot)
2739 
    self._iprot.readMessageEnd()
2740 
    return
2741 
 
2742 
  def changeItemRiskyFlag(self, itemId, risky):
2743 
    """
2744 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2745 
 
2746 
    Parameters:
2747 
     - itemId
2748 
     - risky
2749 
    """
2750 
    self.send_changeItemRiskyFlag(itemId, risky)
2751 
    self.recv_changeItemRiskyFlag()
2752 
 
2753 
  def send_changeItemRiskyFlag(self, itemId, risky):
2754 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2755 
    args = changeItemRiskyFlag_args()
2756 
    args.itemId = itemId
2757 
    args.risky = risky
2758 
    args.write(self._oprot)
2759 
    self._oprot.writeMessageEnd()
2760 
    self._oprot.trans.flush()
2761 
 
2762 
  def recv_changeItemRiskyFlag(self, ):
2763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2764 
    if mtype == TMessageType.EXCEPTION:
2765 
      x = TApplicationException()
2766 
      x.read(self._iprot)
2767 
      self._iprot.readMessageEnd()
2768 
      raise x
2769 
    result = changeItemRiskyFlag_result()
2770 
    result.read(self._iprot)
2771 
    self._iprot.readMessageEnd()
2772 
    return
2773 
 
2774 
  def getItemsByRiskyFlag(self, ):
2775 
    """
2776 
    Returns list of items marked as risky.
2777 
    """
2778 
    self.send_getItemsByRiskyFlag()
2779 
    return self.recv_getItemsByRiskyFlag()
2780 
 
2781 
  def send_getItemsByRiskyFlag(self, ):
2782 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2783 
    args = getItemsByRiskyFlag_args()
2784 
    args.write(self._oprot)
2785 
    self._oprot.writeMessageEnd()
2786 
    self._oprot.trans.flush()
2787 
 
2788 
  def recv_getItemsByRiskyFlag(self, ):
2789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2790 
    if mtype == TMessageType.EXCEPTION:
2791 
      x = TApplicationException()
2792 
      x.read(self._iprot)
2793 
      self._iprot.readMessageEnd()
2794 
      raise x
2795 
    result = getItemsByRiskyFlag_result()
2796 
    result.read(self._iprot)
2797 
    self._iprot.readMessageEnd()
2798 
    if result.success is not None:
2799 
      return result.success
2800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2801 
 
2802 
  def getItemsForMasterSheet(self, category, brand):
2803 
    """
2804 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2805 
 
2806 
    Parameters:
2807 
     - category
2808 
     - brand
2809 
    """
2810 
    self.send_getItemsForMasterSheet(category, brand)
2811 
    return self.recv_getItemsForMasterSheet()
2812 
 
2813 
  def send_getItemsForMasterSheet(self, category, brand):
2814 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2815 
    args = getItemsForMasterSheet_args()
2816 
    args.category = category
2817 
    args.brand = brand
2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
2822 
  def recv_getItemsForMasterSheet(self, ):
2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
2829 
    result = getItemsForMasterSheet_result()
2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
2832 
    if result.success is not None:
2833 
      return result.success
2834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2835 
 
2836 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2837 
    """
2838 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2839 
 
2840 
    Parameters:
2841 
     - beginIndex
2842 
     - totalItems
2843 
     - itemId
2844 
    """
2845 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2846 
    return self.recv_getSimilarItemsCatalogIds()
2847 
 
2848 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2849 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2850 
    args = getSimilarItemsCatalogIds_args()
2851 
    args.beginIndex = beginIndex
2852 
    args.totalItems = totalItems
2853 
    args.itemId = itemId
2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2858 
  def recv_getSimilarItemsCatalogIds(self, ):
2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2865 
    result = getSimilarItemsCatalogIds_result()
2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
2868 
    if result.success is not None:
2869 
      return result.success
2870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2871 
 
2872 
  def addProductNotification(self, itemId, email):
2873 
    """
2874 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2875 
 
2876 
    Parameters:
2877 
     - itemId
2878 
     - email
2879 
    """
2880 
    self.send_addProductNotification(itemId, email)
2881 
    return self.recv_addProductNotification()
2882 
 
2883 
  def send_addProductNotification(self, itemId, email):
2884 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2885 
    args = addProductNotification_args()
2886 
    args.itemId = itemId
2887 
    args.email = email
2888 
    args.write(self._oprot)
2889 
    self._oprot.writeMessageEnd()
2890 
    self._oprot.trans.flush()
2891 
 
2892 
  def recv_addProductNotification(self, ):
2893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2894 
    if mtype == TMessageType.EXCEPTION:
2895 
      x = TApplicationException()
2896 
      x.read(self._iprot)
2897 
      self._iprot.readMessageEnd()
2898 
      raise x
2899 
    result = addProductNotification_result()
2900 
    result.read(self._iprot)
2901 
    self._iprot.readMessageEnd()
2902 
    if result.success is not None:
2903 
      return result.success
2904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2905 
 
2906 
  def sendProductNotifications(self, ):
2907 
    """
2908 
    Send the product notifications to the users for items which has stock.
2909 
    """
2910 
    self.send_sendProductNotifications()
2911 
    return self.recv_sendProductNotifications()
2912 
 
2913 
  def send_sendProductNotifications(self, ):
2914 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2915 
    args = sendProductNotifications_args()
2916 
    args.write(self._oprot)
2917 
    self._oprot.writeMessageEnd()
2918 
    self._oprot.trans.flush()
2919 
 
2920 
  def recv_sendProductNotifications(self, ):
2921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2922 
    if mtype == TMessageType.EXCEPTION:
2923 
      x = TApplicationException()
2924 
      x.read(self._iprot)
2925 
      self._iprot.readMessageEnd()
2926 
      raise x
2927 
    result = sendProductNotifications_result()
2928 
    result.read(self._iprot)
2929 
    self._iprot.readMessageEnd()
2930 
    if result.success is not None:
2931 
      return result.success
2932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2933 
 
2934 
  def getAllBrandsByCategory(self, categoryId):
2935 
    """
2936 
    Returns list of brand names for a given category Id
2937 
 
2938 
    Parameters:
2939 
     - categoryId
2940 
    """
2941 
    self.send_getAllBrandsByCategory(categoryId)
2942 
    return self.recv_getAllBrandsByCategory()
2943 
 
2944 
  def send_getAllBrandsByCategory(self, categoryId):
2945 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2946 
    args = getAllBrandsByCategory_args()
2947 
    args.categoryId = categoryId
2948 
    args.write(self._oprot)
2949 
    self._oprot.writeMessageEnd()
2950 
    self._oprot.trans.flush()
2951 
 
2952 
  def recv_getAllBrandsByCategory(self, ):
2953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2954 
    if mtype == TMessageType.EXCEPTION:
2955 
      x = TApplicationException()
2956 
      x.read(self._iprot)
2957 
      self._iprot.readMessageEnd()
2958 
      raise x
2959 
    result = getAllBrandsByCategory_result()
2960 
    result.read(self._iprot)
2961 
    self._iprot.readMessageEnd()
2962 
    if result.success is not None:
2963 
      return result.success
2964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2965 
 
2966 
  def getAllBrands(self, ):
2967 
    """
2968 
    Returns list of brand names
2969 
    """
2970 
    self.send_getAllBrands()
2971 
    return self.recv_getAllBrands()
2972 
 
2973 
  def send_getAllBrands(self, ):
2974 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2975 
    args = getAllBrands_args()
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_getAllBrands(self, ):
2981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2982 
    if mtype == TMessageType.EXCEPTION:
2983 
      x = TApplicationException()
2984 
      x.read(self._iprot)
2985 
      self._iprot.readMessageEnd()
2986 
      raise x
2987 
    result = getAllBrands_result()
2988 
    result.read(self._iprot)
2989 
    self._iprot.readMessageEnd()
2990 
    if result.success is not None:
2991 
      return result.success
2992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2993 
 
2994 
  def getAllSources(self, ):
2995 
    """
2996 
    Return list of all sources
2997 
    """
2998 
    self.send_getAllSources()
2999 
    return self.recv_getAllSources()
3000 
 
3001 
  def send_getAllSources(self, ):
3002 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3003 
    args = getAllSources_args()
3004 
    args.write(self._oprot)
3005 
    self._oprot.writeMessageEnd()
3006 
    self._oprot.trans.flush()
3007 
 
3008 
  def recv_getAllSources(self, ):
3009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3010 
    if mtype == TMessageType.EXCEPTION:
3011 
      x = TApplicationException()
3012 
      x.read(self._iprot)
3013 
      self._iprot.readMessageEnd()
3014 
      raise x
3015 
    result = getAllSources_result()
3016 
    result.read(self._iprot)
3017 
    self._iprot.readMessageEnd()
3018 
    if result.success is not None:
3019 
      return result.success
3020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3021 
 
3022 
  def getItemPricingBySource(self, itemId, sourceId):
3023 
    """
3024 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3025 
 
3026 
    Parameters:
3027 
     - itemId
3028 
     - sourceId
3029 
    """
3030 
    self.send_getItemPricingBySource(itemId, sourceId)
3031 
    return self.recv_getItemPricingBySource()
3032 
 
3033 
  def send_getItemPricingBySource(self, itemId, sourceId):
3034 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3035 
    args = getItemPricingBySource_args()
3036 
    args.itemId = itemId
3037 
    args.sourceId = sourceId
3038 
    args.write(self._oprot)
3039 
    self._oprot.writeMessageEnd()
3040 
    self._oprot.trans.flush()
3041 
 
3042 
  def recv_getItemPricingBySource(self, ):
3043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3044 
    if mtype == TMessageType.EXCEPTION:
3045 
      x = TApplicationException()
3046 
      x.read(self._iprot)
3047 
      self._iprot.readMessageEnd()
3048 
      raise x
3049 
    result = getItemPricingBySource_result()
3050 
    result.read(self._iprot)
3051 
    self._iprot.readMessageEnd()
3052 
    if result.success is not None:
3053 
      return result.success
3054 
    if result.cex is not None:
3055 
      raise result.cex
3056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3057 
 
3058 
  def addSourceItemPricing(self, sourceItemPricing):
3059 
    """
3060 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3061 
    If item is not found or source is not found, it will throw exception.
3062 
 
3063 
    Parameters:
3064 
     - sourceItemPricing
3065 
    """
3066 
    self.send_addSourceItemPricing(sourceItemPricing)
3067 
    self.recv_addSourceItemPricing()
3068 
 
3069 
  def send_addSourceItemPricing(self, sourceItemPricing):
3070 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3071 
    args = addSourceItemPricing_args()
3072 
    args.sourceItemPricing = sourceItemPricing
3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
3077 
  def recv_addSourceItemPricing(self, ):
3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
3084 
    result = addSourceItemPricing_result()
3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3087 
    if result.cex is not None:
3088 
      raise result.cex
3089 
    return
3090 
 
3091 
  def getAllSourcePricing(self, itemId):
3092 
    """
3093 
    Returns the list of source pricing information of an item.
3094 
    Raises an exception if item not found corresponding to itemId
3095 
 
3096 
    Parameters:
3097 
     - itemId
3098 
    """
3099 
    self.send_getAllSourcePricing(itemId)
3100 
    return self.recv_getAllSourcePricing()
3101 
 
3102 
  def send_getAllSourcePricing(self, itemId):
3103 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3104 
    args = getAllSourcePricing_args()
3105 
    args.itemId = itemId
3106 
    args.write(self._oprot)
3107 
    self._oprot.writeMessageEnd()
3108 
    self._oprot.trans.flush()
3109 
 
3110 
  def recv_getAllSourcePricing(self, ):
3111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3112 
    if mtype == TMessageType.EXCEPTION:
3113 
      x = TApplicationException()
3114 
      x.read(self._iprot)
3115 
      self._iprot.readMessageEnd()
3116 
      raise x
3117 
    result = getAllSourcePricing_result()
3118 
    result.read(self._iprot)
3119 
    self._iprot.readMessageEnd()
3120 
    if result.success is not None:
3121 
      return result.success
3122 
    if result.cex is not None:
3123 
      raise result.cex
3124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3125 
 
3126 
  def getItemForSource(self, item_id, sourceId):
3127 
    """
3128 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3129 
 
3130 
    Parameters:
3131 
     - item_id
3132 
     - sourceId
3133 
    """
3134 
    self.send_getItemForSource(item_id, sourceId)
3135 
    return self.recv_getItemForSource()
3136 
 
3137 
  def send_getItemForSource(self, item_id, sourceId):
3138 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3139 
    args = getItemForSource_args()
3140 
    args.item_id = item_id
3141 
    args.sourceId = sourceId
3142 
    args.write(self._oprot)
3143 
    self._oprot.writeMessageEnd()
3144 
    self._oprot.trans.flush()
3145 
 
3146 
  def recv_getItemForSource(self, ):
3147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3148 
    if mtype == TMessageType.EXCEPTION:
3149 
      x = TApplicationException()
3150 
      x.read(self._iprot)
3151 
      self._iprot.readMessageEnd()
3152 
      raise x
3153 
    result = getItemForSource_result()
3154 
    result.read(self._iprot)
3155 
    self._iprot.readMessageEnd()
3156 
    if result.success is not None:
3157 
      return result.success
3158 
    if result.cex is not None:
3159 
      raise result.cex
3160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3161 
 
3162 
  def searchItemsInRange(self, searchTerms, offset, limit):
3163 
    """
3164 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3165 
 
3166 
    Parameters:
3167 
     - searchTerms
3168 
     - offset
3169 
     - limit
3170 
    """
3171 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3172 
    return self.recv_searchItemsInRange()
3173 
 
3174 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3175 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3176 
    args = searchItemsInRange_args()
3177 
    args.searchTerms = searchTerms
3178 
    args.offset = offset
3179 
    args.limit = limit
3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_searchItemsInRange(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = searchItemsInRange_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3194 
    if result.success is not None:
3195 
      return result.success
3196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3197 
 
3198 
  def getSearchResultCount(self, searchTerms):
3199 
    """
3200 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3201 
 
3202 
    Parameters:
3203 
     - searchTerms
3204 
    """
3205 
    self.send_getSearchResultCount(searchTerms)
3206 
    return self.recv_getSearchResultCount()
3207 
 
3208 
  def send_getSearchResultCount(self, searchTerms):
3209 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3210 
    args = getSearchResultCount_args()
3211 
    args.searchTerms = searchTerms
3212 
    args.write(self._oprot)
3213 
    self._oprot.writeMessageEnd()
3214 
    self._oprot.trans.flush()
3215 
 
3216 
  def recv_getSearchResultCount(self, ):
3217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3218 
    if mtype == TMessageType.EXCEPTION:
3219 
      x = TApplicationException()
3220 
      x.read(self._iprot)
3221 
      self._iprot.readMessageEnd()
3222 
      raise x
3223 
    result = getSearchResultCount_result()
3224 
    result.read(self._iprot)
3225 
    self._iprot.readMessageEnd()
3226 
    if result.success is not None:
3227 
      return result.success
3228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3229 
 
3230 
  def getProductNotifications(self, startDateTime):
3231 
    """
3232 
    Returns a list of product notifications added after a supplied datetime
3233 
 
3234 
    Parameters:
3235 
     - startDateTime
3236 
    """
3237 
    self.send_getProductNotifications(startDateTime)
3238 
    return self.recv_getProductNotifications()
3239 
 
3240 
  def send_getProductNotifications(self, startDateTime):
3241 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3242 
    args = getProductNotifications_args()
3243 
    args.startDateTime = startDateTime
3244 
    args.write(self._oprot)
3245 
    self._oprot.writeMessageEnd()
3246 
    self._oprot.trans.flush()
3247 
 
3248 
  def recv_getProductNotifications(self, ):
3249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3250 
    if mtype == TMessageType.EXCEPTION:
3251 
      x = TApplicationException()
3252 
      x.read(self._iprot)
3253 
      self._iprot.readMessageEnd()
3254 
      raise x
3255 
    result = getProductNotifications_result()
3256 
    result.read(self._iprot)
3257 
    self._iprot.readMessageEnd()
3258 
    if result.success is not None:
3259 
      return result.success
3260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3261 
 
7897 amar.kumar 3262 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3263 
    """
3264 
    Returns a list of count of requests for product notification against each item
3265 
 
3266 
    Parameters:
3267 
     - startDateTime
7897 amar.kumar 3268 
     - categoryId
5944 mandeep.dh 3269 
    """
7897 amar.kumar 3270 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3271 
    return self.recv_getProductNotificationRequestCount()
3272 
 
7897 amar.kumar 3273 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3274 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3275 
    args = getProductNotificationRequestCount_args()
3276 
    args.startDateTime = startDateTime
7897 amar.kumar 3277 
    args.categoryId = categoryId
5944 mandeep.dh 3278 
    args.write(self._oprot)
3279 
    self._oprot.writeMessageEnd()
3280 
    self._oprot.trans.flush()
3281 
 
3282 
  def recv_getProductNotificationRequestCount(self, ):
3283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3284 
    if mtype == TMessageType.EXCEPTION:
3285 
      x = TApplicationException()
3286 
      x.read(self._iprot)
3287 
      self._iprot.readMessageEnd()
3288 
      raise x
3289 
    result = getProductNotificationRequestCount_result()
3290 
    result.read(self._iprot)
3291 
    self._iprot.readMessageEnd()
3292 
    if result.success is not None:
3293 
      return result.success
3294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3295 
 
3296 
  def addAuthorizationLog(self, itemId, username, reason):
3297 
    """
3298 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3299 
 
3300 
    Parameters:
3301 
     - itemId
3302 
     - username
3303 
     - reason
3304 
    """
3305 
    self.send_addAuthorizationLog(itemId, username, reason)
3306 
    return self.recv_addAuthorizationLog()
3307 
 
3308 
  def send_addAuthorizationLog(self, itemId, username, reason):
3309 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3310 
    args = addAuthorizationLog_args()
3311 
    args.itemId = itemId
3312 
    args.username = username
3313 
    args.reason = reason
3314 
    args.write(self._oprot)
3315 
    self._oprot.writeMessageEnd()
3316 
    self._oprot.trans.flush()
3317 
 
3318 
  def recv_addAuthorizationLog(self, ):
3319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3320 
    if mtype == TMessageType.EXCEPTION:
3321 
      x = TApplicationException()
3322 
      x.read(self._iprot)
3323 
      self._iprot.readMessageEnd()
3324 
      raise x
3325 
    result = addAuthorizationLog_result()
3326 
    result.read(self._iprot)
3327 
    self._iprot.readMessageEnd()
3328 
    if result.success is not None:
3329 
      return result.success
3330 
    if result.cex is not None:
3331 
      raise result.cex
3332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3333 
 
3334 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3335 
    """
3336 
    Parameters:
3337 
     - catalog_item_id
3338 
     - voucherType
3339 
     - voucherAmount
3340 
    """
3341 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3342 
    return self.recv_addupdateVoucherForItem()
3343 
 
3344 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3345 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3346 
    args = addupdateVoucherForItem_args()
3347 
    args.catalog_item_id = catalog_item_id
3348 
    args.voucherType = voucherType
3349 
    args.voucherAmount = voucherAmount
3350 
    args.write(self._oprot)
3351 
    self._oprot.writeMessageEnd()
3352 
    self._oprot.trans.flush()
3353 
 
3354 
  def recv_addupdateVoucherForItem(self, ):
3355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3356 
    if mtype == TMessageType.EXCEPTION:
3357 
      x = TApplicationException()
3358 
      x.read(self._iprot)
3359 
      self._iprot.readMessageEnd()
3360 
      raise x
3361 
    result = addupdateVoucherForItem_result()
3362 
    result.read(self._iprot)
3363 
    self._iprot.readMessageEnd()
3364 
    if result.success is not None:
3365 
      return result.success
3366 
    if result.cex is not None:
3367 
      raise result.cex
3368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3369 
 
3370 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3371 
    """
3372 
    Parameters:
3373 
     - catalog_item_id
3374 
     - voucherType
3375 
    """
3376 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3377 
    return self.recv_deleteVoucherForItem()
3378 
 
3379 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3380 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3381 
    args = deleteVoucherForItem_args()
3382 
    args.catalog_item_id = catalog_item_id
3383 
    args.voucherType = voucherType
3384 
    args.write(self._oprot)
3385 
    self._oprot.writeMessageEnd()
3386 
    self._oprot.trans.flush()
3387 
 
3388 
  def recv_deleteVoucherForItem(self, ):
3389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3390 
    if mtype == TMessageType.EXCEPTION:
3391 
      x = TApplicationException()
3392 
      x.read(self._iprot)
3393 
      self._iprot.readMessageEnd()
3394 
      raise x
3395 
    result = deleteVoucherForItem_result()
3396 
    result.read(self._iprot)
3397 
    self._iprot.readMessageEnd()
3398 
    if result.success is not None:
3399 
      return result.success
3400 
    if result.cex is not None:
3401 
      raise result.cex
3402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3403 
 
3404 
  def getVoucherAmount(self, itemId, voucherType):
3405 
    """
3406 
    Parameters:
3407 
     - itemId
3408 
     - voucherType
3409 
    """
3410 
    self.send_getVoucherAmount(itemId, voucherType)
3411 
    return self.recv_getVoucherAmount()
3412 
 
3413 
  def send_getVoucherAmount(self, itemId, voucherType):
3414 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3415 
    args = getVoucherAmount_args()
3416 
    args.itemId = itemId
3417 
    args.voucherType = voucherType
3418 
    args.write(self._oprot)
3419 
    self._oprot.writeMessageEnd()
3420 
    self._oprot.trans.flush()
3421 
 
3422 
  def recv_getVoucherAmount(self, ):
3423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3424 
    if mtype == TMessageType.EXCEPTION:
3425 
      x = TApplicationException()
3426 
      x.read(self._iprot)
3427 
      self._iprot.readMessageEnd()
3428 
      raise x
3429 
    result = getVoucherAmount_result()
3430 
    result.read(self._iprot)
3431 
    self._iprot.readMessageEnd()
3432 
    if result.success is not None:
3433 
      return result.success
3434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3435 
 
3436 
  def getAllItemVouchers(self, itemId):
3437 
    """
3438 
    Parameters:
3439 
     - itemId
3440 
    """
3441 
    self.send_getAllItemVouchers(itemId)
3442 
    return self.recv_getAllItemVouchers()
3443 
 
3444 
  def send_getAllItemVouchers(self, itemId):
3445 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3446 
    args = getAllItemVouchers_args()
3447 
    args.itemId = itemId
3448 
    args.write(self._oprot)
3449 
    self._oprot.writeMessageEnd()
3450 
    self._oprot.trans.flush()
3451 
 
3452 
  def recv_getAllItemVouchers(self, ):
3453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3454 
    if mtype == TMessageType.EXCEPTION:
3455 
      x = TApplicationException()
3456 
      x.read(self._iprot)
3457 
      self._iprot.readMessageEnd()
3458 
      raise x
3459 
    result = getAllItemVouchers_result()
3460 
    result.read(self._iprot)
3461 
    self._iprot.readMessageEnd()
3462 
    if result.success is not None:
3463 
      return result.success
3464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3465 
 
3466 
  def isValidCatalogItemId(self, catalog_item_id):
3467 
    """
3468 
    Parameters:
3469 
     - catalog_item_id
3470 
    """
3471 
    self.send_isValidCatalogItemId(catalog_item_id)
3472 
    return self.recv_isValidCatalogItemId()
3473 
 
3474 
  def send_isValidCatalogItemId(self, catalog_item_id):
3475 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3476 
    args = isValidCatalogItemId_args()
3477 
    args.catalog_item_id = catalog_item_id
3478 
    args.write(self._oprot)
3479 
    self._oprot.writeMessageEnd()
3480 
    self._oprot.trans.flush()
3481 
 
3482 
  def recv_isValidCatalogItemId(self, ):
3483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3484 
    if mtype == TMessageType.EXCEPTION:
3485 
      x = TApplicationException()
3486 
      x.read(self._iprot)
3487 
      self._iprot.readMessageEnd()
3488 
      raise x
3489 
    result = isValidCatalogItemId_result()
3490 
    result.read(self._iprot)
3491 
    self._iprot.readMessageEnd()
3492 
    if result.success is not None:
3493 
      return result.success
3494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3495 
 
7330 amit.gupta 3496 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3497 
    """
3498 
    Parameters:
3499 
     - itemId
7330 amit.gupta 3500 
     - stateId
6039 amit.gupta 3501 
     - price
3502 
    """
7330 amit.gupta 3503 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3504 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3505 
 
7330 amit.gupta 3506 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3507 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3508 
    args = getVatPercentageForItem_args()
3509 
    args.itemId = itemId
7330 amit.gupta 3510 
    args.stateId = stateId
6039 amit.gupta 3511 
    args.price = price
3512 
    args.write(self._oprot)
3513 
    self._oprot.writeMessageEnd()
3514 
    self._oprot.trans.flush()
3515 
 
3516 
  def recv_getVatPercentageForItem(self, ):
3517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3518 
    if mtype == TMessageType.EXCEPTION:
3519 
      x = TApplicationException()
3520 
      x.read(self._iprot)
3521 
      self._iprot.readMessageEnd()
3522 
      raise x
3523 
    result = getVatPercentageForItem_result()
3524 
    result.read(self._iprot)
3525 
    self._iprot.readMessageEnd()
3526 
    if result.success is not None:
3527 
      return result.success
7340 amit.gupta 3528 
    if result.cex is not None:
3529 
      raise result.cex
6039 amit.gupta 3530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3531 
 
3532 
  def getVatAmountForItem(self, itemId, price):
3533 
    """
3534 
    Parameters:
3535 
     - itemId
3536 
     - price
3537 
    """
3538 
    self.send_getVatAmountForItem(itemId, price)
3539 
    return self.recv_getVatAmountForItem()
3540 
 
3541 
  def send_getVatAmountForItem(self, itemId, price):
3542 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3543 
    args = getVatAmountForItem_args()
3544 
    args.itemId = itemId
3545 
    args.price = price
3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_getVatAmountForItem(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = getVatAmountForItem_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3560 
    if result.success is not None:
3561 
      return result.success
3562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3563 
 
6531 vikram.rag 3564 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3565 
    """
3566 
    Parameters:
3567 
     - offset
3568 
     - limit
3569 
    """
3570 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3571 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3572 
 
6531 vikram.rag 3573 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3574 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3575 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3576 
    args.offset = offset
3577 
    args.limit = limit
3578 
    args.write(self._oprot)
3579 
    self._oprot.writeMessageEnd()
3580 
    self._oprot.trans.flush()
3581 
 
3582 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3584 
    if mtype == TMessageType.EXCEPTION:
3585 
      x = TApplicationException()
3586 
      x.read(self._iprot)
3587 
      self._iprot.readMessageEnd()
3588 
      raise x
3589 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3590 
    result.read(self._iprot)
3591 
    self._iprot.readMessageEnd()
3592 
    if result.success is not None:
3593 
      return result.success
3594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3595 
 
6821 amar.kumar 3596 
  def getAllAliveItems(self, ):
3597 
    self.send_getAllAliveItems()
3598 
    return self.recv_getAllAliveItems()
3599 
 
3600 
  def send_getAllAliveItems(self, ):
3601 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3602 
    args = getAllAliveItems_args()
3603 
    args.write(self._oprot)
3604 
    self._oprot.writeMessageEnd()
3605 
    self._oprot.trans.flush()
3606 
 
3607 
  def recv_getAllAliveItems(self, ):
3608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3609 
    if mtype == TMessageType.EXCEPTION:
3610 
      x = TApplicationException()
3611 
      x.read(self._iprot)
3612 
      self._iprot.readMessageEnd()
3613 
      raise x
3614 
    result = getAllAliveItems_result()
3615 
    result.read(self._iprot)
3616 
    self._iprot.readMessageEnd()
3617 
    if result.success is not None:
3618 
      return result.success
3619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3620 
 
6921 anupam.sin 3621 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3622 
    """
3623 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3624 
 
6805 anupam.sin 3625 
    Parameters:
3626 
     - itemId
6921 anupam.sin 3627 
     - price
6805 anupam.sin 3628 
     - insurerId
3629 
     - quantity
3630 
    """
6921 anupam.sin 3631 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3632 
    return self.recv_getInsuranceAmount()
3633 
 
6921 anupam.sin 3634 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3635 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3636 
    args = getInsuranceAmount_args()
3637 
    args.itemId = itemId
6921 anupam.sin 3638 
    args.price = price
6805 anupam.sin 3639 
    args.insurerId = insurerId
3640 
    args.quantity = quantity
3641 
    args.write(self._oprot)
3642 
    self._oprot.writeMessageEnd()
3643 
    self._oprot.trans.flush()
3644 
 
3645 
  def recv_getInsuranceAmount(self, ):
3646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3647 
    if mtype == TMessageType.EXCEPTION:
3648 
      x = TApplicationException()
3649 
      x.read(self._iprot)
3650 
      self._iprot.readMessageEnd()
3651 
      raise x
3652 
    result = getInsuranceAmount_result()
3653 
    result.read(self._iprot)
3654 
    self._iprot.readMessageEnd()
3655 
    if result.success is not None:
3656 
      return result.success
3657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3658 
 
3659 
  def getInsurer(self, insurerId):
3660 
    """
3661 
    Parameters:
3662 
     - insurerId
3663 
    """
3664 
    self.send_getInsurer(insurerId)
3665 
    return self.recv_getInsurer()
3666 
 
3667 
  def send_getInsurer(self, insurerId):
3668 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3669 
    args = getInsurer_args()
3670 
    args.insurerId = insurerId
3671 
    args.write(self._oprot)
3672 
    self._oprot.writeMessageEnd()
3673 
    self._oprot.trans.flush()
3674 
 
3675 
  def recv_getInsurer(self, ):
3676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3677 
    if mtype == TMessageType.EXCEPTION:
3678 
      x = TApplicationException()
3679 
      x.read(self._iprot)
3680 
      self._iprot.readMessageEnd()
3681 
      raise x
3682 
    result = getInsurer_result()
3683 
    result.read(self._iprot)
3684 
    self._iprot.readMessageEnd()
3685 
    if result.success is not None:
3686 
      return result.success
3687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3688 
 
6838 vikram.rag 3689 
  def getAllInsurers(self, ):
3690 
    self.send_getAllInsurers()
3691 
    return self.recv_getAllInsurers()
6805 anupam.sin 3692 
 
6838 vikram.rag 3693 
  def send_getAllInsurers(self, ):
3694 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3695 
    args = getAllInsurers_args()
3696 
    args.write(self._oprot)
3697 
    self._oprot.writeMessageEnd()
3698 
    self._oprot.trans.flush()
3699 
 
3700 
  def recv_getAllInsurers(self, ):
3701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3702 
    if mtype == TMessageType.EXCEPTION:
3703 
      x = TApplicationException()
3704 
      x.read(self._iprot)
3705 
      self._iprot.readMessageEnd()
3706 
      raise x
3707 
    result = getAllInsurers_result()
3708 
    result.read(self._iprot)
3709 
    self._iprot.readMessageEnd()
3710 
    if result.success is not None:
3711 
      return result.success
3712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3713 
 
6962 rajveer 3714 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3715 
    """
3716 
    Parameters:
3717 
     - insurerId
3718 
     - amount
3719 
    """
3720 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3721 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3722 
 
6962 rajveer 3723 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3724 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3725 
    args = updateInsuranceDeclaredAmount_args()
3726 
    args.insurerId = insurerId
3727 
    args.amount = amount
3728 
    args.write(self._oprot)
3729 
    self._oprot.writeMessageEnd()
3730 
    self._oprot.trans.flush()
3731 
 
3732 
  def recv_updateInsuranceDeclaredAmount(self, ):
3733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3734 
    if mtype == TMessageType.EXCEPTION:
3735 
      x = TApplicationException()
3736 
      x.read(self._iprot)
3737 
      self._iprot.readMessageEnd()
3738 
      raise x
3739 
    result = updateInsuranceDeclaredAmount_result()
3740 
    result.read(self._iprot)
3741 
    self._iprot.readMessageEnd()
3742 
    return
3743 
 
7190 amar.kumar 3744 
  def getFreebieForItem(self, itemId):
3745 
    """
3746 
    Parameters:
3747 
     - itemId
3748 
    """
3749 
    self.send_getFreebieForItem(itemId)
3750 
    return self.recv_getFreebieForItem()
6962 rajveer 3751 
 
7190 amar.kumar 3752 
  def send_getFreebieForItem(self, itemId):
3753 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3754 
    args = getFreebieForItem_args()
3755 
    args.itemId = itemId
3756 
    args.write(self._oprot)
3757 
    self._oprot.writeMessageEnd()
3758 
    self._oprot.trans.flush()
3759 
 
3760 
  def recv_getFreebieForItem(self, ):
3761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3762 
    if mtype == TMessageType.EXCEPTION:
3763 
      x = TApplicationException()
3764 
      x.read(self._iprot)
3765 
      self._iprot.readMessageEnd()
3766 
      raise x
3767 
    result = getFreebieForItem_result()
3768 
    result.read(self._iprot)
3769 
    self._iprot.readMessageEnd()
3770 
    if result.success is not None:
3771 
      return result.success
3772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3773 
 
3774 
  def addOrUpdateFreebieForItem(self, freebieItem):
3775 
    """
3776 
    Parameters:
3777 
     - freebieItem
3778 
    """
3779 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3780 
    self.recv_addOrUpdateFreebieForItem()
3781 
 
3782 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3783 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3784 
    args = addOrUpdateFreebieForItem_args()
3785 
    args.freebieItem = freebieItem
3786 
    args.write(self._oprot)
3787 
    self._oprot.writeMessageEnd()
3788 
    self._oprot.trans.flush()
3789 
 
3790 
  def recv_addOrUpdateFreebieForItem(self, ):
3791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3792 
    if mtype == TMessageType.EXCEPTION:
3793 
      x = TApplicationException()
3794 
      x.read(self._iprot)
3795 
      self._iprot.readMessageEnd()
3796 
      raise x
3797 
    result = addOrUpdateFreebieForItem_result()
3798 
    result.read(self._iprot)
3799 
    self._iprot.readMessageEnd()
3800 
    return
3801 
 
7272 amit.gupta 3802 
  def addOrUpdateBrandInfo(self, brandInfo):
3803 
    """
3804 
    Parameters:
3805 
     - brandInfo
3806 
    """
3807 
    self.send_addOrUpdateBrandInfo(brandInfo)
3808 
    self.recv_addOrUpdateBrandInfo()
3809 
 
3810 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3811 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3812 
    args = addOrUpdateBrandInfo_args()
3813 
    args.brandInfo = brandInfo
3814 
    args.write(self._oprot)
3815 
    self._oprot.writeMessageEnd()
3816 
    self._oprot.trans.flush()
3817 
 
3818 
  def recv_addOrUpdateBrandInfo(self, ):
3819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3820 
    if mtype == TMessageType.EXCEPTION:
3821 
      x = TApplicationException()
3822 
      x.read(self._iprot)
3823 
      self._iprot.readMessageEnd()
3824 
      raise x
3825 
    result = addOrUpdateBrandInfo_result()
3826 
    result.read(self._iprot)
3827 
    self._iprot.readMessageEnd()
3828 
    return
3829 
 
3830 
  def getBrandInfo(self, ):
3831 
    self.send_getBrandInfo()
3832 
    return self.recv_getBrandInfo()
3833 
 
3834 
  def send_getBrandInfo(self, ):
3835 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3836 
    args = getBrandInfo_args()
3837 
    args.write(self._oprot)
3838 
    self._oprot.writeMessageEnd()
3839 
    self._oprot.trans.flush()
3840 
 
3841 
  def recv_getBrandInfo(self, ):
3842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3843 
    if mtype == TMessageType.EXCEPTION:
3844 
      x = TApplicationException()
3845 
      x.read(self._iprot)
3846 
      self._iprot.readMessageEnd()
3847 
      raise x
3848 
    result = getBrandInfo_result()
3849 
    result.read(self._iprot)
3850 
    self._iprot.readMessageEnd()
3851 
    if result.success is not None:
3852 
      return result.success
3853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3854 
 
7256 rajveer 3855 
  def getStorePricing(self, itemId):
3856 
    """
3857 
    Parameters:
3858 
     - itemId
3859 
    """
3860 
    self.send_getStorePricing(itemId)
3861 
    return self.recv_getStorePricing()
7190 amar.kumar 3862 
 
7256 rajveer 3863 
  def send_getStorePricing(self, itemId):
3864 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3865 
    args = getStorePricing_args()
3866 
    args.itemId = itemId
3867 
    args.write(self._oprot)
3868 
    self._oprot.writeMessageEnd()
3869 
    self._oprot.trans.flush()
3870 
 
3871 
  def recv_getStorePricing(self, ):
3872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3873 
    if mtype == TMessageType.EXCEPTION:
3874 
      x = TApplicationException()
3875 
      x.read(self._iprot)
3876 
      self._iprot.readMessageEnd()
3877 
      raise x
3878 
    result = getStorePricing_result()
3879 
    result.read(self._iprot)
3880 
    self._iprot.readMessageEnd()
3881 
    if result.success is not None:
3882 
      return result.success
3883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3884 
 
7306 rajveer 3885 
  def getStorePricings(self, itemIds):
3886 
    """
3887 
    Parameters:
3888 
     - itemIds
3889 
    """
3890 
    self.send_getStorePricings(itemIds)
3891 
    return self.recv_getStorePricings()
3892 
 
3893 
  def send_getStorePricings(self, itemIds):
3894 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3895 
    args = getStorePricings_args()
3896 
    args.itemIds = itemIds
3897 
    args.write(self._oprot)
3898 
    self._oprot.writeMessageEnd()
3899 
    self._oprot.trans.flush()
3900 
 
3901 
  def recv_getStorePricings(self, ):
3902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3903 
    if mtype == TMessageType.EXCEPTION:
3904 
      x = TApplicationException()
3905 
      x.read(self._iprot)
3906 
      self._iprot.readMessageEnd()
3907 
      raise x
3908 
    result = getStorePricings_result()
3909 
    result.read(self._iprot)
3910 
    self._iprot.readMessageEnd()
3911 
    if result.success is not None:
3912 
      return result.success
3913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3914 
 
7382 rajveer 3915 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3916 
    """
3917 
    Parameters:
3918 
     - sp
7382 rajveer 3919 
     - allColors
7265 rajveer 3920 
    """
7382 rajveer 3921 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3922 
    self.recv_updateStorePricing()
7256 rajveer 3923 
 
7382 rajveer 3924 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3925 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3926 
    args = updateStorePricing_args()
3927 
    args.sp = sp
7382 rajveer 3928 
    args.allColors = allColors
7265 rajveer 3929 
    args.write(self._oprot)
3930 
    self._oprot.writeMessageEnd()
3931 
    self._oprot.trans.flush()
3932 
 
3933 
  def recv_updateStorePricing(self, ):
3934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3935 
    if mtype == TMessageType.EXCEPTION:
3936 
      x = TApplicationException()
3937 
      x.read(self._iprot)
3938 
      self._iprot.readMessageEnd()
3939 
      raise x
3940 
    result = updateStorePricing_result()
3941 
    result.read(self._iprot)
3942 
    self._iprot.readMessageEnd()
3943 
    return
3944 
 
7281 kshitij.so 3945 
  def getAllAmazonListedItems(self, ):
3946 
    self.send_getAllAmazonListedItems()
3947 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3948 
 
7281 kshitij.so 3949 
  def send_getAllAmazonListedItems(self, ):
3950 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3951 
    args = getAllAmazonListedItems_args()
3952 
    args.write(self._oprot)
3953 
    self._oprot.writeMessageEnd()
3954 
    self._oprot.trans.flush()
3955 
 
3956 
  def recv_getAllAmazonListedItems(self, ):
3957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3958 
    if mtype == TMessageType.EXCEPTION:
3959 
      x = TApplicationException()
3960 
      x.read(self._iprot)
3961 
      self._iprot.readMessageEnd()
3962 
      raise x
3963 
    result = getAllAmazonListedItems_result()
3964 
    result.read(self._iprot)
3965 
    self._iprot.readMessageEnd()
3966 
    if result.success is not None:
3967 
      return result.success
3968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3969 
 
3970 
  def getAmazonItemDetails(self, itemId):
3971 
    """
3972 
    Parameters:
3973 
     - itemId
3974 
    """
3975 
    self.send_getAmazonItemDetails(itemId)
3976 
    return self.recv_getAmazonItemDetails()
3977 
 
3978 
  def send_getAmazonItemDetails(self, itemId):
3979 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3980 
    args = getAmazonItemDetails_args()
3981 
    args.itemId = itemId
3982 
    args.write(self._oprot)
3983 
    self._oprot.writeMessageEnd()
3984 
    self._oprot.trans.flush()
3985 
 
3986 
  def recv_getAmazonItemDetails(self, ):
3987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3988 
    if mtype == TMessageType.EXCEPTION:
3989 
      x = TApplicationException()
3990 
      x.read(self._iprot)
3991 
      self._iprot.readMessageEnd()
3992 
      raise x
3993 
    result = getAmazonItemDetails_result()
3994 
    result.read(self._iprot)
3995 
    self._iprot.readMessageEnd()
3996 
    if result.success is not None:
3997 
      return result.success
3998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3999 
 
8168 kshitij.so 4000 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4001 
    """
4002 
    Parameters:
8168 kshitij.so 4003 
     - amazonlisted
7281 kshitij.so 4004 
    """
8168 kshitij.so 4005 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4006 
    self.recv_updateAmazonItemDetails()
4007 
 
8168 kshitij.so 4008 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4009 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4010 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4011 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4012 
    args.write(self._oprot)
4013 
    self._oprot.writeMessageEnd()
4014 
    self._oprot.trans.flush()
4015 
 
4016 
  def recv_updateAmazonItemDetails(self, ):
4017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4018 
    if mtype == TMessageType.EXCEPTION:
4019 
      x = TApplicationException()
4020 
      x.read(self._iprot)
4021 
      self._iprot.readMessageEnd()
4022 
      raise x
4023 
    result = updateAmazonItemDetails_result()
4024 
    result.read(self._iprot)
4025 
    self._iprot.readMessageEnd()
4026 
    return
4027 
 
4028 
  def addAmazonItem(self, amazonlisted):
4029 
    """
4030 
    Parameters:
4031 
     - amazonlisted
4032 
    """
4033 
    self.send_addAmazonItem(amazonlisted)
4034 
    self.recv_addAmazonItem()
4035 
 
4036 
  def send_addAmazonItem(self, amazonlisted):
4037 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4038 
    args = addAmazonItem_args()
4039 
    args.amazonlisted = amazonlisted
4040 
    args.write(self._oprot)
4041 
    self._oprot.writeMessageEnd()
4042 
    self._oprot.trans.flush()
4043 
 
4044 
  def recv_addAmazonItem(self, ):
4045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4046 
    if mtype == TMessageType.EXCEPTION:
4047 
      x = TApplicationException()
4048 
      x.read(self._iprot)
4049 
      self._iprot.readMessageEnd()
4050 
      raise x
4051 
    result = addAmazonItem_result()
4052 
    result.read(self._iprot)
4053 
    self._iprot.readMessageEnd()
4054 
    return
4055 
 
7291 vikram.rag 4056 
  def getAsinItems(self, ):
4057 
    self.send_getAsinItems()
4058 
    return self.recv_getAsinItems()
7281 kshitij.so 4059 
 
7291 vikram.rag 4060 
  def send_getAsinItems(self, ):
4061 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4062 
    args = getAsinItems_args()
4063 
    args.write(self._oprot)
4064 
    self._oprot.writeMessageEnd()
4065 
    self._oprot.trans.flush()
4066 
 
4067 
  def recv_getAsinItems(self, ):
4068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4069 
    if mtype == TMessageType.EXCEPTION:
4070 
      x = TApplicationException()
4071 
      x.read(self._iprot)
4072 
      self._iprot.readMessageEnd()
4073 
      raise x
4074 
    result = getAsinItems_result()
4075 
    result.read(self._iprot)
4076 
    self._iprot.readMessageEnd()
4077 
    if result.success is not None:
4078 
      return result.success
4079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4080 
 
4081 
  def getAllFbaListedItems(self, ):
4082 
    self.send_getAllFbaListedItems()
4083 
    return self.recv_getAllFbaListedItems()
4084 
 
4085 
  def send_getAllFbaListedItems(self, ):
4086 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4087 
    args = getAllFbaListedItems_args()
4088 
    args.write(self._oprot)
4089 
    self._oprot.writeMessageEnd()
4090 
    self._oprot.trans.flush()
4091 
 
4092 
  def recv_getAllFbaListedItems(self, ):
4093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4094 
    if mtype == TMessageType.EXCEPTION:
4095 
      x = TApplicationException()
4096 
      x.read(self._iprot)
4097 
      self._iprot.readMessageEnd()
4098 
      raise x
4099 
    result = getAllFbaListedItems_result()
4100 
    result.read(self._iprot)
4101 
    self._iprot.readMessageEnd()
4102 
    if result.success is not None:
4103 
      return result.success
4104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4105 
 
4106 
  def getAllNonFbaListedItems(self, ):
4107 
    self.send_getAllNonFbaListedItems()
4108 
    return self.recv_getAllNonFbaListedItems()
4109 
 
4110 
  def send_getAllNonFbaListedItems(self, ):
4111 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4112 
    args = getAllNonFbaListedItems_args()
4113 
    args.write(self._oprot)
4114 
    self._oprot.writeMessageEnd()
4115 
    self._oprot.trans.flush()
4116 
 
4117 
  def recv_getAllNonFbaListedItems(self, ):
4118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4119 
    if mtype == TMessageType.EXCEPTION:
4120 
      x = TApplicationException()
4121 
      x.read(self._iprot)
4122 
      self._iprot.readMessageEnd()
4123 
      raise x
4124 
    result = getAllNonFbaListedItems_result()
4125 
    result.read(self._iprot)
4126 
    self._iprot.readMessageEnd()
4127 
    if result.success is not None:
4128 
      return result.success
4129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4130 
 
7460 kshitij.so 4131 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4132 
    """
4133 
    Parameters:
4134 
     - itemId
4135 
     - holdInventory
4136 
     - defaultInventory
4137 
    """
4138 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4139 
    return self.recv_updateItemInventory()
7291 vikram.rag 4140 
 
7460 kshitij.so 4141 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4142 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4143 
    args = updateItemInventory_args()
4144 
    args.itemId = itemId
4145 
    args.holdInventory = holdInventory
4146 
    args.defaultInventory = defaultInventory
4147 
    args.write(self._oprot)
4148 
    self._oprot.writeMessageEnd()
4149 
    self._oprot.trans.flush()
4150 
 
4151 
  def recv_updateItemInventory(self, ):
4152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4153 
    if mtype == TMessageType.EXCEPTION:
4154 
      x = TApplicationException()
4155 
      x.read(self._iprot)
4156 
      self._iprot.readMessageEnd()
4157 
      raise x
4158 
    result = updateItemInventory_result()
4159 
    result.read(self._iprot)
4160 
    self._iprot.readMessageEnd()
4161 
    if result.success is not None:
4162 
      return result.success
4163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4164 
 
7770 kshitij.so 4165 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4166 
    """
4167 
    Parameters:
4168 
     - type
4169 
     - sku
4170 
     - timestamp
4171 
    """
4172 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4173 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4174 
 
7770 kshitij.so 4175 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4176 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4177 
    args = updateTimestampForAmazonFeeds_args()
4178 
    args.type = type
4179 
    args.sku = sku
4180 
    args.timestamp = timestamp
4181 
    args.write(self._oprot)
4182 
    self._oprot.writeMessageEnd()
4183 
    self._oprot.trans.flush()
4184 
 
4185 
  def recv_updateTimestampForAmazonFeeds(self, ):
4186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4187 
    if mtype == TMessageType.EXCEPTION:
4188 
      x = TApplicationException()
4189 
      x.read(self._iprot)
4190 
      self._iprot.readMessageEnd()
4191 
      raise x
4192 
    result = updateTimestampForAmazonFeeds_result()
4193 
    result.read(self._iprot)
4194 
    self._iprot.readMessageEnd()
4195 
    if result.success is not None:
4196 
      return result.success
4197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4198 
 
7897 amar.kumar 4199 
  def getAllParentCategories(self, ):
4200 
    self.send_getAllParentCategories()
4201 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4202 
 
7897 amar.kumar 4203 
  def send_getAllParentCategories(self, ):
4204 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4205 
    args = getAllParentCategories_args()
4206 
    args.write(self._oprot)
4207 
    self._oprot.writeMessageEnd()
4208 
    self._oprot.trans.flush()
4209 
 
4210 
  def recv_getAllParentCategories(self, ):
4211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4212 
    if mtype == TMessageType.EXCEPTION:
4213 
      x = TApplicationException()
4214 
      x.read(self._iprot)
4215 
      self._iprot.readMessageEnd()
4216 
      raise x
4217 
    result = getAllParentCategories_result()
4218 
    result.read(self._iprot)
4219 
    self._iprot.readMessageEnd()
4220 
    if result.success is not None:
4221 
      return result.success
4222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4223 
 
7977 kshitij.so 4224 
  def addPageViewEvent(self, pageViewEvents):
4225 
    """
4226 
    Parameters:
4227 
     - pageViewEvents
4228 
    """
4229 
    self.send_addPageViewEvent(pageViewEvents)
4230 
    self.recv_addPageViewEvent()
7897 amar.kumar 4231 
 
7977 kshitij.so 4232 
  def send_addPageViewEvent(self, pageViewEvents):
4233 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4234 
    args = addPageViewEvent_args()
4235 
    args.pageViewEvents = pageViewEvents
4236 
    args.write(self._oprot)
4237 
    self._oprot.writeMessageEnd()
4238 
    self._oprot.trans.flush()
4239 
 
4240 
  def recv_addPageViewEvent(self, ):
4241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4242 
    if mtype == TMessageType.EXCEPTION:
4243 
      x = TApplicationException()
4244 
      x.read(self._iprot)
4245 
      self._iprot.readMessageEnd()
4246 
      raise x
4247 
    result = addPageViewEvent_result()
4248 
    result.read(self._iprot)
4249 
    self._iprot.readMessageEnd()
4250 
    return
4251 
 
4252 
  def addCartEvent(self, cartEvents):
4253 
    """
4254 
    Parameters:
4255 
     - cartEvents
4256 
    """
4257 
    self.send_addCartEvent(cartEvents)
4258 
    self.recv_addCartEvent()
4259 
 
4260 
  def send_addCartEvent(self, cartEvents):
4261 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4262 
    args = addCartEvent_args()
4263 
    args.cartEvents = cartEvents
4264 
    args.write(self._oprot)
4265 
    self._oprot.writeMessageEnd()
4266 
    self._oprot.trans.flush()
4267 
 
4268 
  def recv_addCartEvent(self, ):
4269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4270 
    if mtype == TMessageType.EXCEPTION:
4271 
      x = TApplicationException()
4272 
      x.read(self._iprot)
4273 
      self._iprot.readMessageEnd()
4274 
      raise x
4275 
    result = addCartEvent_result()
4276 
    result.read(self._iprot)
4277 
    self._iprot.readMessageEnd()
4278 
    return
4279 
 
8182 amar.kumar 4280 
  def addEbayItem(self, ebayItem):
4281 
    """
4282 
    Parameters:
4283 
     - ebayItem
4284 
    """
4285 
    self.send_addEbayItem(ebayItem)
4286 
    self.recv_addEbayItem()
4287 
 
4288 
  def send_addEbayItem(self, ebayItem):
4289 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4290 
    args = addEbayItem_args()
4291 
    args.ebayItem = ebayItem
4292 
    args.write(self._oprot)
4293 
    self._oprot.writeMessageEnd()
4294 
    self._oprot.trans.flush()
4295 
 
4296 
  def recv_addEbayItem(self, ):
4297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4298 
    if mtype == TMessageType.EXCEPTION:
4299 
      x = TApplicationException()
4300 
      x.read(self._iprot)
4301 
      self._iprot.readMessageEnd()
4302 
      raise x
4303 
    result = addEbayItem_result()
4304 
    result.read(self._iprot)
4305 
    self._iprot.readMessageEnd()
4306 
    return
4307 
 
4308 
  def getEbayItem(self, listingId):
4309 
    """
4310 
    Parameters:
4311 
     - listingId
4312 
    """
4313 
    self.send_getEbayItem(listingId)
4314 
    return self.recv_getEbayItem()
4315 
 
4316 
  def send_getEbayItem(self, listingId):
4317 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4318 
    args = getEbayItem_args()
4319 
    args.listingId = listingId
4320 
    args.write(self._oprot)
4321 
    self._oprot.writeMessageEnd()
4322 
    self._oprot.trans.flush()
4323 
 
4324 
  def recv_getEbayItem(self, ):
4325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4326 
    if mtype == TMessageType.EXCEPTION:
4327 
      x = TApplicationException()
4328 
      x.read(self._iprot)
4329 
      self._iprot.readMessageEnd()
4330 
      raise x
4331 
    result = getEbayItem_result()
4332 
    result.read(self._iprot)
4333 
    self._iprot.readMessageEnd()
4334 
    if result.success is not None:
4335 
      return result.success
4336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4337 
 
4338 
  def updateEbayItem(self, ebayItem):
4339 
    """
4340 
    Parameters:
4341 
     - ebayItem
4342 
    """
4343 
    self.send_updateEbayItem(ebayItem)
4344 
    self.recv_updateEbayItem()
4345 
 
4346 
  def send_updateEbayItem(self, ebayItem):
4347 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4348 
    args = updateEbayItem_args()
4349 
    args.ebayItem = ebayItem
4350 
    args.write(self._oprot)
4351 
    self._oprot.writeMessageEnd()
4352 
    self._oprot.trans.flush()
4353 
 
4354 
  def recv_updateEbayItem(self, ):
4355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4356 
    if mtype == TMessageType.EXCEPTION:
4357 
      x = TApplicationException()
4358 
      x.read(self._iprot)
4359 
      self._iprot.readMessageEnd()
4360 
      raise x
4361 
    result = updateEbayItem_result()
4362 
    result.read(self._iprot)
4363 
    self._iprot.readMessageEnd()
4364 
    return
4365 
 
8139 kshitij.so 4366 
  def getAmazonListedItems(self, offset, limit):
4367 
    """
4368 
    Parameters:
4369 
     - offset
4370 
     - limit
4371 
    """
4372 
    self.send_getAmazonListedItems(offset, limit)
4373 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4374 
 
8139 kshitij.so 4375 
  def send_getAmazonListedItems(self, offset, limit):
4376 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4377 
    args = getAmazonListedItems_args()
4378 
    args.offset = offset
4379 
    args.limit = limit
4380 
    args.write(self._oprot)
4381 
    self._oprot.writeMessageEnd()
4382 
    self._oprot.trans.flush()
4383 
 
4384 
  def recv_getAmazonListedItems(self, ):
4385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4386 
    if mtype == TMessageType.EXCEPTION:
4387 
      x = TApplicationException()
4388 
      x.read(self._iprot)
4389 
      self._iprot.readMessageEnd()
4390 
      raise x
4391 
    result = getAmazonListedItems_result()
4392 
    result.read(self._iprot)
4393 
    self._iprot.readMessageEnd()
4394 
    if result.success is not None:
4395 
      return result.success
4396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4397 
 
8168 kshitij.so 4398 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4399 
    """
4400 
    Parameters:
4401 
     - amazonlisted
4402 
    """
4403 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4404 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4405 
 
8168 kshitij.so 4406 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4407 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4408 
    args = updateAmazonAttributesInBulk_args()
4409 
    args.amazonlisted = amazonlisted
4410 
    args.write(self._oprot)
4411 
    self._oprot.writeMessageEnd()
4412 
    self._oprot.trans.flush()
4413 
 
4414 
  def recv_updateAmazonAttributesInBulk(self, ):
4415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4416 
    if mtype == TMessageType.EXCEPTION:
4417 
      x = TApplicationException()
4418 
      x.read(self._iprot)
4419 
      self._iprot.readMessageEnd()
4420 
      raise x
4421 
    result = updateAmazonAttributesInBulk_result()
4422 
    result.read(self._iprot)
4423 
    self._iprot.readMessageEnd()
4424 
    if result.success is not None:
4425 
      return result.success
4426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4427 
 
8379 vikram.rag 4428 
  def getAllItemstoListOnFba(self, ):
4429 
    self.send_getAllItemstoListOnFba()
4430 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4431 
 
8379 vikram.rag 4432 
  def send_getAllItemstoListOnFba(self, ):
4433 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4434 
    args = getAllItemstoListOnFba_args()
4435 
    args.write(self._oprot)
4436 
    self._oprot.writeMessageEnd()
4437 
    self._oprot.trans.flush()
4438 
 
4439 
  def recv_getAllItemstoListOnFba(self, ):
4440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4441 
    if mtype == TMessageType.EXCEPTION:
4442 
      x = TApplicationException()
4443 
      x.read(self._iprot)
4444 
      self._iprot.readMessageEnd()
4445 
      raise x
4446 
    result = getAllItemstoListOnFba_result()
4447 
    result.read(self._iprot)
4448 
    self._iprot.readMessageEnd()
4449 
    if result.success is not None:
4450 
      return result.success
4451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4452 
 
4453 
  def getAllItemstoListOnNonFba(self, ):
4454 
    self.send_getAllItemstoListOnNonFba()
4455 
    return self.recv_getAllItemstoListOnNonFba()
4456 
 
4457 
  def send_getAllItemstoListOnNonFba(self, ):
4458 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4459 
    args = getAllItemstoListOnNonFba_args()
4460 
    args.write(self._oprot)
4461 
    self._oprot.writeMessageEnd()
4462 
    self._oprot.trans.flush()
4463 
 
4464 
  def recv_getAllItemstoListOnNonFba(self, ):
4465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4466 
    if mtype == TMessageType.EXCEPTION:
4467 
      x = TApplicationException()
4468 
      x.read(self._iprot)
4469 
      self._iprot.readMessageEnd()
4470 
      raise x
4471 
    result = getAllItemstoListOnNonFba_result()
4472 
    result.read(self._iprot)
4473 
    self._iprot.readMessageEnd()
4474 
    if result.success is not None:
4475 
      return result.success
4476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4477 
 
4478 
 
5944 mandeep.dh 4479 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4480 
  def __init__(self, handler):
4481 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4482 
    self._processMap["addItem"] = Processor.process_addItem
4483 
    self._processMap["updateItem"] = Processor.process_updateItem
4484 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4485 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4486 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4487 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4488 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4489 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4490 
    self._processMap["getItem"] = Processor.process_getItem
4491 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4492 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4493 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4494 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4495 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4496 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4497 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4498 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4499 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4500 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4501 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4502 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4503 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4504 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4505 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4506 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4507 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4508 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4509 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4510 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4511 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4512 
    self._processMap["addCategory"] = Processor.process_addCategory
4513 
    self._processMap["getCategory"] = Processor.process_getCategory
4514 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4515 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4516 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4517 
    self._processMap["addTag"] = Processor.process_addTag
4518 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4519 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4520 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4521 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4522 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4523 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4524 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4525 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4526 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4527 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4528 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4529 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 4530 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 4531 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4532 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 4533 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
4534 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
4535 
    self._processMap["addCampaign"] = Processor.process_addCampaign
4536 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
4537 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
4538 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
5944 mandeep.dh 4539 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4540 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4541 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4542 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4543 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4544 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4545 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4546 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4547 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4548 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4549 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4550 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4551 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4552 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4553 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4554 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4555 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4556 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4557 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4558 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4559 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4560 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4561 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4562 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4563 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4564 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4565 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4566 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4567 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4568 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4569 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4570 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4571 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4572 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4573 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4574 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4575 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4576 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4577 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4578 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4579 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4580 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4581 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4582 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4583 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4584 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4585 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4586 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4587 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4588 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4589 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4590 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4591 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4592 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4593 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4594 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4595 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4596 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 4597 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
4598 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
5944 mandeep.dh 4599 
 
4600 
  def process(self, iprot, oprot):
4601 
    (name, type, seqid) = iprot.readMessageBegin()
4602 
    if name not in self._processMap:
4603 
      iprot.skip(TType.STRUCT)
4604 
      iprot.readMessageEnd()
4605 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4606 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4607 
      x.write(oprot)
4608 
      oprot.writeMessageEnd()
4609 
      oprot.trans.flush()
4610 
      return
4611 
    else:
4612 
      self._processMap[name](self, seqid, iprot, oprot)
4613 
    return True
4614 
 
4615 
  def process_addItem(self, seqid, iprot, oprot):
4616 
    args = addItem_args()
4617 
    args.read(iprot)
4618 
    iprot.readMessageEnd()
4619 
    result = addItem_result()
4620 
    try:
4621 
      result.success = self._handler.addItem(args.item)
4622 
    except CatalogServiceException, cex:
4623 
      result.cex = cex
4624 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4625 
    result.write(oprot)
4626 
    oprot.writeMessageEnd()
4627 
    oprot.trans.flush()
4628 
 
4629 
  def process_updateItem(self, seqid, iprot, oprot):
4630 
    args = updateItem_args()
4631 
    args.read(iprot)
4632 
    iprot.readMessageEnd()
4633 
    result = updateItem_result()
4634 
    try:
4635 
      result.success = self._handler.updateItem(args.item)
4636 
    except CatalogServiceException, cex:
4637 
      result.cex = cex
4638 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4639 
    result.write(oprot)
4640 
    oprot.writeMessageEnd()
4641 
    oprot.trans.flush()
4642 
 
4643 
  def process_isActive(self, seqid, iprot, oprot):
4644 
    args = isActive_args()
4645 
    args.read(iprot)
4646 
    iprot.readMessageEnd()
4647 
    result = isActive_result()
4648 
    try:
4649 
      result.success = self._handler.isActive(args.itemId)
4650 
    except CatalogServiceException, isex:
4651 
      result.isex = isex
4652 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4653 
    result.write(oprot)
4654 
    oprot.writeMessageEnd()
4655 
    oprot.trans.flush()
4656 
 
7438 amit.gupta 4657 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4658 
    args = getItemsStatus_args()
4659 
    args.read(iprot)
4660 
    iprot.readMessageEnd()
4661 
    result = getItemsStatus_result()
4662 
    try:
4663 
      result.success = self._handler.getItemsStatus(args.itemIds)
4664 
    except CatalogServiceException, isex:
4665 
      result.isex = isex
4666 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4667 
    result.write(oprot)
4668 
    oprot.writeMessageEnd()
4669 
    oprot.trans.flush()
4670 
 
5944 mandeep.dh 4671 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4672 
    args = getItemStatusDescription_args()
4673 
    args.read(iprot)
4674 
    iprot.readMessageEnd()
4675 
    result = getItemStatusDescription_result()
4676 
    try:
4677 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4678 
    except CatalogServiceException, isex:
4679 
      result.isex = isex
4680 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4681 
    result.write(oprot)
4682 
    oprot.writeMessageEnd()
4683 
    oprot.trans.flush()
4684 
 
4685 
  def process_startItemOn(self, seqid, iprot, oprot):
4686 
    args = startItemOn_args()
4687 
    args.read(iprot)
4688 
    iprot.readMessageEnd()
4689 
    result = startItemOn_result()
4690 
    try:
4691 
      self._handler.startItemOn(args.item_id, args.timestamp)
4692 
    except CatalogServiceException, cex:
4693 
      result.cex = cex
4694 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4695 
    result.write(oprot)
4696 
    oprot.writeMessageEnd()
4697 
    oprot.trans.flush()
4698 
 
4699 
  def process_retireItemOn(self, seqid, iprot, oprot):
4700 
    args = retireItemOn_args()
4701 
    args.read(iprot)
4702 
    iprot.readMessageEnd()
4703 
    result = retireItemOn_result()
4704 
    try:
4705 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4706 
    except CatalogServiceException, cex:
4707 
      result.cex = cex
4708 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4709 
    result.write(oprot)
4710 
    oprot.writeMessageEnd()
4711 
    oprot.trans.flush()
4712 
 
4713 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4714 
    args = changeItemStatus_args()
4715 
    args.read(iprot)
4716 
    iprot.readMessageEnd()
4717 
    result = changeItemStatus_result()
4718 
    try:
4719 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4720 
    except CatalogServiceException, cex:
4721 
      result.cex = cex
4722 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4723 
    result.write(oprot)
4724 
    oprot.writeMessageEnd()
4725 
    oprot.trans.flush()
4726 
 
4727 
  def process_getItem(self, seqid, iprot, oprot):
4728 
    args = getItem_args()
4729 
    args.read(iprot)
4730 
    iprot.readMessageEnd()
4731 
    result = getItem_result()
4732 
    try:
4733 
      result.success = self._handler.getItem(args.item_id)
4734 
    except CatalogServiceException, cex:
4735 
      result.cex = cex
4736 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4737 
    result.write(oprot)
4738 
    oprot.writeMessageEnd()
4739 
    oprot.trans.flush()
4740 
 
4741 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4742 
    args = getItemsByCatalogId_args()
4743 
    args.read(iprot)
4744 
    iprot.readMessageEnd()
4745 
    result = getItemsByCatalogId_result()
4746 
    try:
4747 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4748 
    except CatalogServiceException, cex:
4749 
      result.cex = cex
4750 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4751 
    result.write(oprot)
4752 
    oprot.writeMessageEnd()
4753 
    oprot.trans.flush()
4754 
 
4755 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4756 
    args = getValidItemsByCatalogId_args()
4757 
    args.read(iprot)
4758 
    iprot.readMessageEnd()
4759 
    result = getValidItemsByCatalogId_result()
4760 
    try:
4761 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4762 
    except CatalogServiceException, cex:
4763 
      result.cex = cex
4764 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4765 
    result.write(oprot)
4766 
    oprot.writeMessageEnd()
4767 
    oprot.trans.flush()
4768 
 
4769 
  def process_getAllItems(self, seqid, iprot, oprot):
4770 
    args = getAllItems_args()
4771 
    args.read(iprot)
4772 
    iprot.readMessageEnd()
4773 
    result = getAllItems_result()
4774 
    try:
4775 
      result.success = self._handler.getAllItems(args.isActive)
4776 
    except CatalogServiceException, cex:
4777 
      result.cex = cex
4778 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4779 
    result.write(oprot)
4780 
    oprot.writeMessageEnd()
4781 
    oprot.trans.flush()
4782 
 
4783 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4784 
    args = getAllItemsByStatus_args()
4785 
    args.read(iprot)
4786 
    iprot.readMessageEnd()
4787 
    result = getAllItemsByStatus_result()
4788 
    try:
4789 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4790 
    except CatalogServiceException, cex:
4791 
      result.cex = cex
4792 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4793 
    result.write(oprot)
4794 
    oprot.writeMessageEnd()
4795 
    oprot.trans.flush()
4796 
 
4797 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4798 
    args = markItemAsContentComplete_args()
4799 
    args.read(iprot)
4800 
    iprot.readMessageEnd()
4801 
    result = markItemAsContentComplete_result()
4802 
    try:
4803 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4804 
    except CatalogServiceException, cex:
4805 
      result.cex = cex
4806 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4807 
    result.write(oprot)
4808 
    oprot.writeMessageEnd()
4809 
    oprot.trans.flush()
4810 
 
4811 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4812 
    args = getAllItemsInRange_args()
4813 
    args.read(iprot)
4814 
    iprot.readMessageEnd()
4815 
    result = getAllItemsInRange_result()
4816 
    try:
4817 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4818 
    except CatalogServiceException, cex:
4819 
      result.cex = cex
4820 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4821 
    result.write(oprot)
4822 
    oprot.writeMessageEnd()
4823 
    oprot.trans.flush()
4824 
 
4825 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4826 
    args = getAllItemsByStatusInRange_args()
4827 
    args.read(iprot)
4828 
    iprot.readMessageEnd()
4829 
    result = getAllItemsByStatusInRange_result()
4830 
    try:
4831 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4832 
    except CatalogServiceException, cex:
4833 
      result.cex = cex
4834 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4835 
    result.write(oprot)
4836 
    oprot.writeMessageEnd()
4837 
    oprot.trans.flush()
4838 
 
4839 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4840 
    args = getItemCountByStatus_args()
4841 
    args.read(iprot)
4842 
    iprot.readMessageEnd()
4843 
    result = getItemCountByStatus_result()
4844 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4845 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4846 
    result.write(oprot)
4847 
    oprot.writeMessageEnd()
4848 
    oprot.trans.flush()
4849 
 
4850 
  def process_getBestSellers(self, seqid, iprot, oprot):
4851 
    args = getBestSellers_args()
4852 
    args.read(iprot)
4853 
    iprot.readMessageEnd()
4854 
    result = getBestSellers_result()
4855 
    try:
4856 
      result.success = self._handler.getBestSellers()
4857 
    except CatalogServiceException, isex:
4858 
      result.isex = isex
4859 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4860 
    result.write(oprot)
4861 
    oprot.writeMessageEnd()
4862 
    oprot.trans.flush()
4863 
 
4864 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4865 
    args = getBestSellersCatalogIds_args()
4866 
    args.read(iprot)
4867 
    iprot.readMessageEnd()
4868 
    result = getBestSellersCatalogIds_result()
4869 
    try:
4870 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4871 
    except CatalogServiceException, cex:
4872 
      result.cex = cex
4873 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4874 
    result.write(oprot)
4875 
    oprot.writeMessageEnd()
4876 
    oprot.trans.flush()
4877 
 
4878 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4879 
    args = getBestSellersCount_args()
4880 
    args.read(iprot)
4881 
    iprot.readMessageEnd()
4882 
    result = getBestSellersCount_result()
4883 
    try:
4884 
      result.success = self._handler.getBestSellersCount()
4885 
    except CatalogServiceException, cex:
4886 
      result.cex = cex
4887 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4888 
    result.write(oprot)
4889 
    oprot.writeMessageEnd()
4890 
    oprot.trans.flush()
4891 
 
4892 
  def process_getBestDeals(self, seqid, iprot, oprot):
4893 
    args = getBestDeals_args()
4894 
    args.read(iprot)
4895 
    iprot.readMessageEnd()
4896 
    result = getBestDeals_result()
4897 
    try:
4898 
      result.success = self._handler.getBestDeals()
4899 
    except CatalogServiceException, isex:
4900 
      result.isex = isex
4901 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4902 
    result.write(oprot)
4903 
    oprot.writeMessageEnd()
4904 
    oprot.trans.flush()
4905 
 
4906 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4907 
    args = getBestDealsCatalogIds_args()
4908 
    args.read(iprot)
4909 
    iprot.readMessageEnd()
4910 
    result = getBestDealsCatalogIds_result()
4911 
    try:
4912 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4913 
    except CatalogServiceException, cex:
4914 
      result.cex = cex
4915 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4916 
    result.write(oprot)
4917 
    oprot.writeMessageEnd()
4918 
    oprot.trans.flush()
4919 
 
4920 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4921 
    args = getBestDealsCount_args()
4922 
    args.read(iprot)
4923 
    iprot.readMessageEnd()
4924 
    result = getBestDealsCount_result()
4925 
    try:
4926 
      result.success = self._handler.getBestDealsCount()
4927 
    except CatalogServiceException, cex:
4928 
      result.cex = cex
4929 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4930 
    result.write(oprot)
4931 
    oprot.writeMessageEnd()
4932 
    oprot.trans.flush()
4933 
 
4934 
  def process_getComingSoon(self, seqid, iprot, oprot):
4935 
    args = getComingSoon_args()
4936 
    args.read(iprot)
4937 
    iprot.readMessageEnd()
4938 
    result = getComingSoon_result()
4939 
    try:
4940 
      result.success = self._handler.getComingSoon()
4941 
    except CatalogServiceException, isex:
4942 
      result.isex = isex
4943 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4944 
    result.write(oprot)
4945 
    oprot.writeMessageEnd()
4946 
    oprot.trans.flush()
4947 
 
4948 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4949 
    args = getComingSoonCatalogIds_args()
4950 
    args.read(iprot)
4951 
    iprot.readMessageEnd()
4952 
    result = getComingSoonCatalogIds_result()
4953 
    try:
4954 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4955 
    except CatalogServiceException, cex:
4956 
      result.cex = cex
4957 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4958 
    result.write(oprot)
4959 
    oprot.writeMessageEnd()
4960 
    oprot.trans.flush()
4961 
 
4962 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4963 
    args = getComingSoonCount_args()
4964 
    args.read(iprot)
4965 
    iprot.readMessageEnd()
4966 
    result = getComingSoonCount_result()
4967 
    try:
4968 
      result.success = self._handler.getComingSoonCount()
4969 
    except CatalogServiceException, cex:
4970 
      result.cex = cex
4971 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4972 
    result.write(oprot)
4973 
    oprot.writeMessageEnd()
4974 
    oprot.trans.flush()
4975 
 
4976 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4977 
    args = getLatestArrivals_args()
4978 
    args.read(iprot)
4979 
    iprot.readMessageEnd()
4980 
    result = getLatestArrivals_result()
4981 
    try:
4982 
      result.success = self._handler.getLatestArrivals()
4983 
    except CatalogServiceException, isex:
4984 
      result.isex = isex
4985 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4986 
    result.write(oprot)
4987 
    oprot.writeMessageEnd()
4988 
    oprot.trans.flush()
4989 
 
4990 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4991 
    args = getLatestArrivalsCatalogIds_args()
4992 
    args.read(iprot)
4993 
    iprot.readMessageEnd()
4994 
    result = getLatestArrivalsCatalogIds_result()
4995 
    try:
4996 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4997 
    except CatalogServiceException, cex:
4998 
      result.cex = cex
4999 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5000 
    result.write(oprot)
5001 
    oprot.writeMessageEnd()
5002 
    oprot.trans.flush()
5003 
 
5004 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5005 
    args = getLatestArrivalsCount_args()
5006 
    args.read(iprot)
5007 
    iprot.readMessageEnd()
5008 
    result = getLatestArrivalsCount_result()
5009 
    try:
5010 
      result.success = self._handler.getLatestArrivalsCount()
5011 
    except CatalogServiceException, cex:
5012 
      result.cex = cex
5013 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5014 
    result.write(oprot)
5015 
    oprot.writeMessageEnd()
5016 
    oprot.trans.flush()
5017 
 
5018 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5019 
    args = generateNewEntityID_args()
5020 
    args.read(iprot)
5021 
    iprot.readMessageEnd()
5022 
    result = generateNewEntityID_result()
5023 
    result.success = self._handler.generateNewEntityID()
5024 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5025 
    result.write(oprot)
5026 
    oprot.writeMessageEnd()
5027 
    oprot.trans.flush()
5028 
 
5029 
  def process_addCategory(self, seqid, iprot, oprot):
5030 
    args = addCategory_args()
5031 
    args.read(iprot)
5032 
    iprot.readMessageEnd()
5033 
    result = addCategory_result()
5034 
    result.success = self._handler.addCategory(args.category)
5035 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5036 
    result.write(oprot)
5037 
    oprot.writeMessageEnd()
5038 
    oprot.trans.flush()
5039 
 
5040 
  def process_getCategory(self, seqid, iprot, oprot):
5041 
    args = getCategory_args()
5042 
    args.read(iprot)
5043 
    iprot.readMessageEnd()
5044 
    result = getCategory_result()
5045 
    result.success = self._handler.getCategory(args.id)
5046 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5047 
    result.write(oprot)
5048 
    oprot.writeMessageEnd()
5049 
    oprot.trans.flush()
5050 
 
5051 
  def process_getAllCategories(self, seqid, iprot, oprot):
5052 
    args = getAllCategories_args()
5053 
    args.read(iprot)
5054 
    iprot.readMessageEnd()
5055 
    result = getAllCategories_result()
5056 
    result.success = self._handler.getAllCategories()
5057 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5058 
    result.write(oprot)
5059 
    oprot.writeMessageEnd()
5060 
    oprot.trans.flush()
5061 
 
5062 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5063 
    args = getAllSimilarItems_args()
5064 
    args.read(iprot)
5065 
    iprot.readMessageEnd()
5066 
    result = getAllSimilarItems_result()
5067 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5068 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5069 
    result.write(oprot)
5070 
    oprot.writeMessageEnd()
5071 
    oprot.trans.flush()
5072 
 
5073 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5074 
    args = addSimilarItem_args()
5075 
    args.read(iprot)
5076 
    iprot.readMessageEnd()
5077 
    result = addSimilarItem_result()
5078 
    try:
5079 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5080 
    except CatalogServiceException, cex:
5081 
      result.cex = cex
5082 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5083 
    result.write(oprot)
5084 
    oprot.writeMessageEnd()
5085 
    oprot.trans.flush()
5086 
 
6512 kshitij.so 5087 
  def process_addTag(self, seqid, iprot, oprot):
5088 
    args = addTag_args()
5089 
    args.read(iprot)
5090 
    iprot.readMessageEnd()
5091 
    result = addTag_result()
5092 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5093 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5094 
    result.write(oprot)
5095 
    oprot.writeMessageEnd()
5096 
    oprot.trans.flush()
5097 
 
5098 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5099 
    args = deleteEntityTag_args()
5100 
    args.read(iprot)
5101 
    iprot.readMessageEnd()
5102 
    result = deleteEntityTag_result()
5103 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5104 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5105 
    result.write(oprot)
5106 
    oprot.writeMessageEnd()
5107 
    oprot.trans.flush()
5108 
 
5109 
  def process_deleteTag(self, seqid, iprot, oprot):
5110 
    args = deleteTag_args()
5111 
    args.read(iprot)
5112 
    iprot.readMessageEnd()
5113 
    result = deleteTag_result()
5114 
    result.success = self._handler.deleteTag(args.displayName)
5115 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5116 
    result.write(oprot)
5117 
    oprot.writeMessageEnd()
5118 
    oprot.trans.flush()
5119 
 
5120 
  def process_getAllTags(self, seqid, iprot, oprot):
5121 
    args = getAllTags_args()
5122 
    args.read(iprot)
5123 
    iprot.readMessageEnd()
5124 
    result = getAllTags_result()
5125 
    result.success = self._handler.getAllTags()
5126 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5127 
    result.write(oprot)
5128 
    oprot.writeMessageEnd()
5129 
    oprot.trans.flush()
5130 
 
5131 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5132 
    args = getAllEntitiesByTagName_args()
5133 
    args.read(iprot)
5134 
    iprot.readMessageEnd()
5135 
    result = getAllEntitiesByTagName_result()
5136 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5137 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5138 
    result.write(oprot)
5139 
    oprot.writeMessageEnd()
5140 
    oprot.trans.flush()
5141 
 
6845 amit.gupta 5142 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5143 
    args = getAllEntityTags_args()
5144 
    args.read(iprot)
5145 
    iprot.readMessageEnd()
5146 
    result = getAllEntityTags_result()
5147 
    result.success = self._handler.getAllEntityTags()
5148 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5149 
    result.write(oprot)
5150 
    oprot.writeMessageEnd()
5151 
    oprot.trans.flush()
5152 
 
6850 kshitij.so 5153 
  def process_addBanner(self, seqid, iprot, oprot):
5154 
    args = addBanner_args()
5155 
    args.read(iprot)
5156 
    iprot.readMessageEnd()
5157 
    result = addBanner_result()
8590 kshitij.so 5158 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5159 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5160 
    result.write(oprot)
5161 
    oprot.writeMessageEnd()
5162 
    oprot.trans.flush()
5163 
 
8579 kshitij.so 5164 
  def process_updateBanner(self, seqid, iprot, oprot):
5165 
    args = updateBanner_args()
5166 
    args.read(iprot)
5167 
    iprot.readMessageEnd()
5168 
    result = updateBanner_result()
5169 
    result.success = self._handler.updateBanner(args.banner)
5170 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5171 
    result.write(oprot)
5172 
    oprot.writeMessageEnd()
5173 
    oprot.trans.flush()
5174 
 
6850 kshitij.so 5175 
  def process_getAllBanners(self, seqid, iprot, oprot):
5176 
    args = getAllBanners_args()
5177 
    args.read(iprot)
5178 
    iprot.readMessageEnd()
5179 
    result = getAllBanners_result()
5180 
    result.success = self._handler.getAllBanners()
5181 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5182 
    result.write(oprot)
5183 
    oprot.writeMessageEnd()
5184 
    oprot.trans.flush()
5185 
 
5186 
  def process_deleteBanner(self, seqid, iprot, oprot):
5187 
    args = deleteBanner_args()
5188 
    args.read(iprot)
5189 
    iprot.readMessageEnd()
5190 
    result = deleteBanner_result()
5191 
    result.success = self._handler.deleteBanner(args.bannerName)
5192 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5193 
    result.write(oprot)
5194 
    oprot.writeMessageEnd()
5195 
    oprot.trans.flush()
5196 
 
5197 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5198 
    args = getBannerDetails_args()
5199 
    args.read(iprot)
5200 
    iprot.readMessageEnd()
5201 
    result = getBannerDetails_result()
5202 
    result.success = self._handler.getBannerDetails(args.bannerName)
5203 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5204 
    result.write(oprot)
5205 
    oprot.writeMessageEnd()
5206 
    oprot.trans.flush()
5207 
 
5208 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5209 
    args = getActiveBanners_args()
5210 
    args.read(iprot)
5211 
    iprot.readMessageEnd()
5212 
    result = getActiveBanners_result()
5213 
    result.success = self._handler.getActiveBanners()
5214 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5215 
    result.write(oprot)
5216 
    oprot.writeMessageEnd()
5217 
    oprot.trans.flush()
5218 
 
6849 kshitij.so 5219 
  def process_addBannerMap(self, seqid, iprot, oprot):
5220 
    args = addBannerMap_args()
5221 
    args.read(iprot)
5222 
    iprot.readMessageEnd()
5223 
    result = addBannerMap_result()
8579 kshitij.so 5224 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5225 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5226 
    result.write(oprot)
5227 
    oprot.writeMessageEnd()
5228 
    oprot.trans.flush()
5229 
 
8579 kshitij.so 5230 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5231 
    args = updateBannerMap_args()
5232 
    args.read(iprot)
5233 
    iprot.readMessageEnd()
5234 
    result = updateBannerMap_result()
5235 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5236 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5237 
    result.write(oprot)
5238 
    oprot.writeMessageEnd()
5239 
    oprot.trans.flush()
5240 
 
6849 kshitij.so 5241 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5242 
    args = deleteBannerMap_args()
5243 
    args.read(iprot)
5244 
    iprot.readMessageEnd()
5245 
    result = deleteBannerMap_result()
5246 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5247 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5248 
    result.write(oprot)
5249 
    oprot.writeMessageEnd()
5250 
    oprot.trans.flush()
5251 
 
5252 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5253 
    args = getBannerMapDetails_args()
5254 
    args.read(iprot)
5255 
    iprot.readMessageEnd()
5256 
    result = getBannerMapDetails_result()
5257 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
5258 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5259 
    result.write(oprot)
5260 
    oprot.writeMessageEnd()
5261 
    oprot.trans.flush()
5262 
 
8579 kshitij.so 5263 
  def process_addBannerUri(self, seqid, iprot, oprot):
5264 
    args = addBannerUri_args()
5265 
    args.read(iprot)
5266 
    iprot.readMessageEnd()
5267 
    result = addBannerUri_result()
5268 
    self._handler.addBannerUri(args.bannerUriMappings)
5269 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5270 
    result.write(oprot)
5271 
    oprot.writeMessageEnd()
5272 
    oprot.trans.flush()
5273 
 
5274 
  def process_getUriMapping(self, seqid, iprot, oprot):
5275 
    args = getUriMapping_args()
5276 
    args.read(iprot)
5277 
    iprot.readMessageEnd()
5278 
    result = getUriMapping_result()
5279 
    result.success = self._handler.getUriMapping(args.bannerName)
5280 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5281 
    result.write(oprot)
5282 
    oprot.writeMessageEnd()
5283 
    oprot.trans.flush()
5284 
 
5285 
  def process_addCampaign(self, seqid, iprot, oprot):
5286 
    args = addCampaign_args()
5287 
    args.read(iprot)
5288 
    iprot.readMessageEnd()
5289 
    result = addCampaign_result()
5290 
    self._handler.addCampaign(args.campaign)
5291 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5292 
    result.write(oprot)
5293 
    oprot.writeMessageEnd()
5294 
    oprot.trans.flush()
5295 
 
5296 
  def process_getCampaigns(self, seqid, iprot, oprot):
5297 
    args = getCampaigns_args()
5298 
    args.read(iprot)
5299 
    iprot.readMessageEnd()
5300 
    result = getCampaigns_result()
5301 
    result.success = self._handler.getCampaigns(args.campaignName)
5302 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5303 
    result.write(oprot)
5304 
    oprot.writeMessageEnd()
5305 
    oprot.trans.flush()
5306 
 
5307 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5308 
    args = deleteCampaign_args()
5309 
    args.read(iprot)
5310 
    iprot.readMessageEnd()
5311 
    result = deleteCampaign_result()
5312 
    self._handler.deleteCampaign(args.campaignId)
5313 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5314 
    result.write(oprot)
5315 
    oprot.writeMessageEnd()
5316 
    oprot.trans.flush()
5317 
 
5318 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5319 
    args = getAllCampaigns_args()
5320 
    args.read(iprot)
5321 
    iprot.readMessageEnd()
5322 
    result = getAllCampaigns_result()
5323 
    result.success = self._handler.getAllCampaigns()
5324 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5325 
    result.write(oprot)
5326 
    oprot.writeMessageEnd()
5327 
    oprot.trans.flush()
5328 
 
5944 mandeep.dh 5329 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5330 
    args = deleteSimilarItem_args()
5331 
    args.read(iprot)
5332 
    iprot.readMessageEnd()
5333 
    result = deleteSimilarItem_result()
5334 
    try:
5335 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5336 
    except CatalogServiceException, cex:
5337 
      result.cex = cex
5338 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5339 
    result.write(oprot)
5340 
    oprot.writeMessageEnd()
5341 
    oprot.trans.flush()
5342 
 
5343 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5344 
    args = checkSimilarItem_args()
5345 
    args.read(iprot)
5346 
    iprot.readMessageEnd()
5347 
    result = checkSimilarItem_result()
5348 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5349 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5350 
    result.write(oprot)
5351 
    oprot.writeMessageEnd()
5352 
    oprot.trans.flush()
5353 
 
5354 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5355 
    args = validateRiskyStatus_args()
5356 
    args.read(iprot)
5357 
    iprot.readMessageEnd()
5358 
    result = validateRiskyStatus_result()
5359 
    self._handler.validateRiskyStatus(args.itemId)
5360 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5361 
    result.write(oprot)
5362 
    oprot.writeMessageEnd()
5363 
    oprot.trans.flush()
5364 
 
5365 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5366 
    args = changeItemRiskyFlag_args()
5367 
    args.read(iprot)
5368 
    iprot.readMessageEnd()
5369 
    result = changeItemRiskyFlag_result()
5370 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5371 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5372 
    result.write(oprot)
5373 
    oprot.writeMessageEnd()
5374 
    oprot.trans.flush()
5375 
 
5376 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5377 
    args = getItemsByRiskyFlag_args()
5378 
    args.read(iprot)
5379 
    iprot.readMessageEnd()
5380 
    result = getItemsByRiskyFlag_result()
5381 
    result.success = self._handler.getItemsByRiskyFlag()
5382 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5383 
    result.write(oprot)
5384 
    oprot.writeMessageEnd()
5385 
    oprot.trans.flush()
5386 
 
5387 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5388 
    args = getItemsForMasterSheet_args()
5389 
    args.read(iprot)
5390 
    iprot.readMessageEnd()
5391 
    result = getItemsForMasterSheet_result()
5392 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5393 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5394 
    result.write(oprot)
5395 
    oprot.writeMessageEnd()
5396 
    oprot.trans.flush()
5397 
 
5398 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5399 
    args = getSimilarItemsCatalogIds_args()
5400 
    args.read(iprot)
5401 
    iprot.readMessageEnd()
5402 
    result = getSimilarItemsCatalogIds_result()
5403 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5404 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5405 
    result.write(oprot)
5406 
    oprot.writeMessageEnd()
5407 
    oprot.trans.flush()
5408 
 
5409 
  def process_addProductNotification(self, seqid, iprot, oprot):
5410 
    args = addProductNotification_args()
5411 
    args.read(iprot)
5412 
    iprot.readMessageEnd()
5413 
    result = addProductNotification_result()
5414 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5415 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5416 
    result.write(oprot)
5417 
    oprot.writeMessageEnd()
5418 
    oprot.trans.flush()
5419 
 
5420 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5421 
    args = sendProductNotifications_args()
5422 
    args.read(iprot)
5423 
    iprot.readMessageEnd()
5424 
    result = sendProductNotifications_result()
5425 
    result.success = self._handler.sendProductNotifications()
5426 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5427 
    result.write(oprot)
5428 
    oprot.writeMessageEnd()
5429 
    oprot.trans.flush()
5430 
 
5431 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5432 
    args = getAllBrandsByCategory_args()
5433 
    args.read(iprot)
5434 
    iprot.readMessageEnd()
5435 
    result = getAllBrandsByCategory_result()
5436 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5437 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5438 
    result.write(oprot)
5439 
    oprot.writeMessageEnd()
5440 
    oprot.trans.flush()
5441 
 
5442 
  def process_getAllBrands(self, seqid, iprot, oprot):
5443 
    args = getAllBrands_args()
5444 
    args.read(iprot)
5445 
    iprot.readMessageEnd()
5446 
    result = getAllBrands_result()
5447 
    result.success = self._handler.getAllBrands()
5448 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5449 
    result.write(oprot)
5450 
    oprot.writeMessageEnd()
5451 
    oprot.trans.flush()
5452 
 
5453 
  def process_getAllSources(self, seqid, iprot, oprot):
5454 
    args = getAllSources_args()
5455 
    args.read(iprot)
5456 
    iprot.readMessageEnd()
5457 
    result = getAllSources_result()
5458 
    result.success = self._handler.getAllSources()
5459 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5460 
    result.write(oprot)
5461 
    oprot.writeMessageEnd()
5462 
    oprot.trans.flush()
5463 
 
5464 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5465 
    args = getItemPricingBySource_args()
5466 
    args.read(iprot)
5467 
    iprot.readMessageEnd()
5468 
    result = getItemPricingBySource_result()
5469 
    try:
5470 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5471 
    except CatalogServiceException, cex:
5472 
      result.cex = cex
5473 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5474 
    result.write(oprot)
5475 
    oprot.writeMessageEnd()
5476 
    oprot.trans.flush()
5477 
 
5478 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5479 
    args = addSourceItemPricing_args()
5480 
    args.read(iprot)
5481 
    iprot.readMessageEnd()
5482 
    result = addSourceItemPricing_result()
5483 
    try:
5484 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5485 
    except CatalogServiceException, cex:
5486 
      result.cex = cex
5487 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5488 
    result.write(oprot)
5489 
    oprot.writeMessageEnd()
5490 
    oprot.trans.flush()
5491 
 
5492 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5493 
    args = getAllSourcePricing_args()
5494 
    args.read(iprot)
5495 
    iprot.readMessageEnd()
5496 
    result = getAllSourcePricing_result()
5497 
    try:
5498 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5499 
    except CatalogServiceException, cex:
5500 
      result.cex = cex
5501 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5502 
    result.write(oprot)
5503 
    oprot.writeMessageEnd()
5504 
    oprot.trans.flush()
5505 
 
5506 
  def process_getItemForSource(self, seqid, iprot, oprot):
5507 
    args = getItemForSource_args()
5508 
    args.read(iprot)
5509 
    iprot.readMessageEnd()
5510 
    result = getItemForSource_result()
5511 
    try:
5512 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5513 
    except CatalogServiceException, cex:
5514 
      result.cex = cex
5515 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5516 
    result.write(oprot)
5517 
    oprot.writeMessageEnd()
5518 
    oprot.trans.flush()
5519 
 
5520 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5521 
    args = searchItemsInRange_args()
5522 
    args.read(iprot)
5523 
    iprot.readMessageEnd()
5524 
    result = searchItemsInRange_result()
5525 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5526 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5527 
    result.write(oprot)
5528 
    oprot.writeMessageEnd()
5529 
    oprot.trans.flush()
5530 
 
5531 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5532 
    args = getSearchResultCount_args()
5533 
    args.read(iprot)
5534 
    iprot.readMessageEnd()
5535 
    result = getSearchResultCount_result()
5536 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5537 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5538 
    result.write(oprot)
5539 
    oprot.writeMessageEnd()
5540 
    oprot.trans.flush()
5541 
 
5542 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5543 
    args = getProductNotifications_args()
5544 
    args.read(iprot)
5545 
    iprot.readMessageEnd()
5546 
    result = getProductNotifications_result()
5547 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5548 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5549 
    result.write(oprot)
5550 
    oprot.writeMessageEnd()
5551 
    oprot.trans.flush()
5552 
 
5553 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5554 
    args = getProductNotificationRequestCount_args()
5555 
    args.read(iprot)
5556 
    iprot.readMessageEnd()
5557 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5558 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5559 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5560 
    result.write(oprot)
5561 
    oprot.writeMessageEnd()
5562 
    oprot.trans.flush()
5563 
 
5564 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5565 
    args = addAuthorizationLog_args()
5566 
    args.read(iprot)
5567 
    iprot.readMessageEnd()
5568 
    result = addAuthorizationLog_result()
5569 
    try:
5570 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5571 
    except CatalogServiceException, cex:
5572 
      result.cex = cex
5573 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5574 
    result.write(oprot)
5575 
    oprot.writeMessageEnd()
5576 
    oprot.trans.flush()
5577 
 
5578 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5579 
    args = addupdateVoucherForItem_args()
5580 
    args.read(iprot)
5581 
    iprot.readMessageEnd()
5582 
    result = addupdateVoucherForItem_result()
5583 
    try:
5584 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5585 
    except CatalogServiceException, cex:
5586 
      result.cex = cex
5587 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5588 
    result.write(oprot)
5589 
    oprot.writeMessageEnd()
5590 
    oprot.trans.flush()
5591 
 
5592 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5593 
    args = deleteVoucherForItem_args()
5594 
    args.read(iprot)
5595 
    iprot.readMessageEnd()
5596 
    result = deleteVoucherForItem_result()
5597 
    try:
5598 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5599 
    except CatalogServiceException, cex:
5600 
      result.cex = cex
5601 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5602 
    result.write(oprot)
5603 
    oprot.writeMessageEnd()
5604 
    oprot.trans.flush()
5605 
 
5606 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5607 
    args = getVoucherAmount_args()
5608 
    args.read(iprot)
5609 
    iprot.readMessageEnd()
5610 
    result = getVoucherAmount_result()
5611 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5612 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5613 
    result.write(oprot)
5614 
    oprot.writeMessageEnd()
5615 
    oprot.trans.flush()
5616 
 
5617 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5618 
    args = getAllItemVouchers_args()
5619 
    args.read(iprot)
5620 
    iprot.readMessageEnd()
5621 
    result = getAllItemVouchers_result()
5622 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5623 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5624 
    result.write(oprot)
5625 
    oprot.writeMessageEnd()
5626 
    oprot.trans.flush()
5627 
 
5628 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5629 
    args = isValidCatalogItemId_args()
5630 
    args.read(iprot)
5631 
    iprot.readMessageEnd()
5632 
    result = isValidCatalogItemId_result()
5633 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5634 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5635 
    result.write(oprot)
5636 
    oprot.writeMessageEnd()
5637 
    oprot.trans.flush()
5638 
 
6039 amit.gupta 5639 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5640 
    args = getVatPercentageForItem_args()
5641 
    args.read(iprot)
5642 
    iprot.readMessageEnd()
5643 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5644 
    try:
5645 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5646 
    except CatalogServiceException, cex:
5647 
      result.cex = cex
6039 amit.gupta 5648 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5649 
    result.write(oprot)
5650 
    oprot.writeMessageEnd()
5651 
    oprot.trans.flush()
5944 mandeep.dh 5652 
 
6039 amit.gupta 5653 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5654 
    args = getVatAmountForItem_args()
5655 
    args.read(iprot)
5656 
    iprot.readMessageEnd()
5657 
    result = getVatAmountForItem_result()
5658 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5659 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5660 
    result.write(oprot)
5661 
    oprot.writeMessageEnd()
5662 
    oprot.trans.flush()
5663 
 
6531 vikram.rag 5664 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5665 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5666 
    args.read(iprot)
5667 
    iprot.readMessageEnd()
5668 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5669 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5670 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5671 
    result.write(oprot)
5672 
    oprot.writeMessageEnd()
5673 
    oprot.trans.flush()
6039 amit.gupta 5674 
 
6821 amar.kumar 5675 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5676 
    args = getAllAliveItems_args()
5677 
    args.read(iprot)
5678 
    iprot.readMessageEnd()
5679 
    result = getAllAliveItems_result()
5680 
    result.success = self._handler.getAllAliveItems()
5681 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5682 
    result.write(oprot)
5683 
    oprot.writeMessageEnd()
5684 
    oprot.trans.flush()
5685 
 
6805 anupam.sin 5686 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5687 
    args = getInsuranceAmount_args()
5688 
    args.read(iprot)
5689 
    iprot.readMessageEnd()
5690 
    result = getInsuranceAmount_result()
6921 anupam.sin 5691 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5692 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5693 
    result.write(oprot)
5694 
    oprot.writeMessageEnd()
5695 
    oprot.trans.flush()
6531 vikram.rag 5696 
 
6805 anupam.sin 5697 
  def process_getInsurer(self, seqid, iprot, oprot):
5698 
    args = getInsurer_args()
5699 
    args.read(iprot)
5700 
    iprot.readMessageEnd()
5701 
    result = getInsurer_result()
5702 
    result.success = self._handler.getInsurer(args.insurerId)
5703 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5704 
    result.write(oprot)
5705 
    oprot.writeMessageEnd()
5706 
    oprot.trans.flush()
5707 
 
6838 vikram.rag 5708 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5709 
    args = getAllInsurers_args()
5710 
    args.read(iprot)
5711 
    iprot.readMessageEnd()
5712 
    result = getAllInsurers_result()
5713 
    result.success = self._handler.getAllInsurers()
5714 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5715 
    result.write(oprot)
5716 
    oprot.writeMessageEnd()
5717 
    oprot.trans.flush()
6805 anupam.sin 5718 
 
6962 rajveer 5719 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5720 
    args = updateInsuranceDeclaredAmount_args()
5721 
    args.read(iprot)
5722 
    iprot.readMessageEnd()
5723 
    result = updateInsuranceDeclaredAmount_result()
5724 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5725 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5726 
    result.write(oprot)
5727 
    oprot.writeMessageEnd()
5728 
    oprot.trans.flush()
6838 vikram.rag 5729 
 
7190 amar.kumar 5730 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5731 
    args = getFreebieForItem_args()
5732 
    args.read(iprot)
5733 
    iprot.readMessageEnd()
5734 
    result = getFreebieForItem_result()
5735 
    result.success = self._handler.getFreebieForItem(args.itemId)
5736 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5737 
    result.write(oprot)
5738 
    oprot.writeMessageEnd()
5739 
    oprot.trans.flush()
6962 rajveer 5740 
 
7190 amar.kumar 5741 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5742 
    args = addOrUpdateFreebieForItem_args()
5743 
    args.read(iprot)
5744 
    iprot.readMessageEnd()
5745 
    result = addOrUpdateFreebieForItem_result()
5746 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5747 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5748 
    result.write(oprot)
5749 
    oprot.writeMessageEnd()
5750 
    oprot.trans.flush()
5751 
 
7272 amit.gupta 5752 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5753 
    args = addOrUpdateBrandInfo_args()
5754 
    args.read(iprot)
5755 
    iprot.readMessageEnd()
5756 
    result = addOrUpdateBrandInfo_result()
5757 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5758 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5759 
    result.write(oprot)
5760 
    oprot.writeMessageEnd()
5761 
    oprot.trans.flush()
5762 
 
5763 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5764 
    args = getBrandInfo_args()
5765 
    args.read(iprot)
5766 
    iprot.readMessageEnd()
5767 
    result = getBrandInfo_result()
5768 
    result.success = self._handler.getBrandInfo()
5769 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5770 
    result.write(oprot)
5771 
    oprot.writeMessageEnd()
5772 
    oprot.trans.flush()
5773 
 
7256 rajveer 5774 
  def process_getStorePricing(self, seqid, iprot, oprot):
5775 
    args = getStorePricing_args()
5776 
    args.read(iprot)
5777 
    iprot.readMessageEnd()
5778 
    result = getStorePricing_result()
5779 
    result.success = self._handler.getStorePricing(args.itemId)
5780 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5781 
    result.write(oprot)
5782 
    oprot.writeMessageEnd()
5783 
    oprot.trans.flush()
7190 amar.kumar 5784 
 
7306 rajveer 5785 
  def process_getStorePricings(self, seqid, iprot, oprot):
5786 
    args = getStorePricings_args()
5787 
    args.read(iprot)
5788 
    iprot.readMessageEnd()
5789 
    result = getStorePricings_result()
5790 
    result.success = self._handler.getStorePricings(args.itemIds)
5791 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5792 
    result.write(oprot)
5793 
    oprot.writeMessageEnd()
5794 
    oprot.trans.flush()
5795 
 
7265 rajveer 5796 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5797 
    args = updateStorePricing_args()
5798 
    args.read(iprot)
5799 
    iprot.readMessageEnd()
5800 
    result = updateStorePricing_result()
7382 rajveer 5801 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5802 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5803 
    result.write(oprot)
5804 
    oprot.writeMessageEnd()
5805 
    oprot.trans.flush()
7256 rajveer 5806 
 
7281 kshitij.so 5807 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5808 
    args = getAllAmazonListedItems_args()
5809 
    args.read(iprot)
5810 
    iprot.readMessageEnd()
5811 
    result = getAllAmazonListedItems_result()
5812 
    result.success = self._handler.getAllAmazonListedItems()
5813 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5814 
    result.write(oprot)
5815 
    oprot.writeMessageEnd()
5816 
    oprot.trans.flush()
7265 rajveer 5817 
 
7281 kshitij.so 5818 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5819 
    args = getAmazonItemDetails_args()
5820 
    args.read(iprot)
5821 
    iprot.readMessageEnd()
5822 
    result = getAmazonItemDetails_result()
5823 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5824 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5825 
    result.write(oprot)
5826 
    oprot.writeMessageEnd()
5827 
    oprot.trans.flush()
5828 
 
5829 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5830 
    args = updateAmazonItemDetails_args()
5831 
    args.read(iprot)
5832 
    iprot.readMessageEnd()
5833 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 5834 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 5835 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5836 
    result.write(oprot)
5837 
    oprot.writeMessageEnd()
5838 
    oprot.trans.flush()
5839 
 
5840 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5841 
    args = addAmazonItem_args()
5842 
    args.read(iprot)
5843 
    iprot.readMessageEnd()
5844 
    result = addAmazonItem_result()
5845 
    self._handler.addAmazonItem(args.amazonlisted)
5846 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5847 
    result.write(oprot)
5848 
    oprot.writeMessageEnd()
5849 
    oprot.trans.flush()
5850 
 
7291 vikram.rag 5851 
  def process_getAsinItems(self, seqid, iprot, oprot):
5852 
    args = getAsinItems_args()
5853 
    args.read(iprot)
5854 
    iprot.readMessageEnd()
5855 
    result = getAsinItems_result()
5856 
    result.success = self._handler.getAsinItems()
5857 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5858 
    result.write(oprot)
5859 
    oprot.writeMessageEnd()
5860 
    oprot.trans.flush()
7281 kshitij.so 5861 
 
7291 vikram.rag 5862 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5863 
    args = getAllFbaListedItems_args()
5864 
    args.read(iprot)
5865 
    iprot.readMessageEnd()
5866 
    result = getAllFbaListedItems_result()
5867 
    result.success = self._handler.getAllFbaListedItems()
5868 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5869 
    result.write(oprot)
5870 
    oprot.writeMessageEnd()
5871 
    oprot.trans.flush()
5872 
 
5873 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5874 
    args = getAllNonFbaListedItems_args()
5875 
    args.read(iprot)
5876 
    iprot.readMessageEnd()
5877 
    result = getAllNonFbaListedItems_result()
5878 
    result.success = self._handler.getAllNonFbaListedItems()
5879 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5880 
    result.write(oprot)
5881 
    oprot.writeMessageEnd()
5882 
    oprot.trans.flush()
5883 
 
7460 kshitij.so 5884 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5885 
    args = updateItemInventory_args()
5886 
    args.read(iprot)
5887 
    iprot.readMessageEnd()
5888 
    result = updateItemInventory_result()
5889 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5890 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5891 
    result.write(oprot)
5892 
    oprot.writeMessageEnd()
5893 
    oprot.trans.flush()
7291 vikram.rag 5894 
 
7770 kshitij.so 5895 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5896 
    args = updateTimestampForAmazonFeeds_args()
5897 
    args.read(iprot)
5898 
    iprot.readMessageEnd()
5899 
    result = updateTimestampForAmazonFeeds_result()
5900 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5901 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5902 
    result.write(oprot)
5903 
    oprot.writeMessageEnd()
5904 
    oprot.trans.flush()
7460 kshitij.so 5905 
 
7897 amar.kumar 5906 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5907 
    args = getAllParentCategories_args()
5908 
    args.read(iprot)
5909 
    iprot.readMessageEnd()
5910 
    result = getAllParentCategories_result()
5911 
    result.success = self._handler.getAllParentCategories()
5912 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5913 
    result.write(oprot)
5914 
    oprot.writeMessageEnd()
5915 
    oprot.trans.flush()
7770 kshitij.so 5916 
 
7977 kshitij.so 5917 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5918 
    args = addPageViewEvent_args()
5919 
    args.read(iprot)
5920 
    iprot.readMessageEnd()
5921 
    result = addPageViewEvent_result()
5922 
    self._handler.addPageViewEvent(args.pageViewEvents)
5923 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5924 
    result.write(oprot)
5925 
    oprot.writeMessageEnd()
5926 
    oprot.trans.flush()
7897 amar.kumar 5927 
 
7977 kshitij.so 5928 
  def process_addCartEvent(self, seqid, iprot, oprot):
5929 
    args = addCartEvent_args()
5930 
    args.read(iprot)
5931 
    iprot.readMessageEnd()
5932 
    result = addCartEvent_result()
5933 
    self._handler.addCartEvent(args.cartEvents)
5934 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5935 
    result.write(oprot)
5936 
    oprot.writeMessageEnd()
5937 
    oprot.trans.flush()
5938 
 
8182 amar.kumar 5939 
  def process_addEbayItem(self, seqid, iprot, oprot):
5940 
    args = addEbayItem_args()
5941 
    args.read(iprot)
5942 
    iprot.readMessageEnd()
5943 
    result = addEbayItem_result()
5944 
    self._handler.addEbayItem(args.ebayItem)
5945 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
5946 
    result.write(oprot)
5947 
    oprot.writeMessageEnd()
5948 
    oprot.trans.flush()
5949 
 
5950 
  def process_getEbayItem(self, seqid, iprot, oprot):
5951 
    args = getEbayItem_args()
5952 
    args.read(iprot)
5953 
    iprot.readMessageEnd()
5954 
    result = getEbayItem_result()
5955 
    result.success = self._handler.getEbayItem(args.listingId)
5956 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
5957 
    result.write(oprot)
5958 
    oprot.writeMessageEnd()
5959 
    oprot.trans.flush()
5960 
 
5961 
  def process_updateEbayItem(self, seqid, iprot, oprot):
5962 
    args = updateEbayItem_args()
5963 
    args.read(iprot)
5964 
    iprot.readMessageEnd()
5965 
    result = updateEbayItem_result()
5966 
    self._handler.updateEbayItem(args.ebayItem)
5967 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
5968 
    result.write(oprot)
5969 
    oprot.writeMessageEnd()
5970 
    oprot.trans.flush()
5971 
 
8139 kshitij.so 5972 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
5973 
    args = getAmazonListedItems_args()
5974 
    args.read(iprot)
5975 
    iprot.readMessageEnd()
5976 
    result = getAmazonListedItems_result()
5977 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
5978 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
5979 
    result.write(oprot)
5980 
    oprot.writeMessageEnd()
5981 
    oprot.trans.flush()
7977 kshitij.so 5982 
 
8168 kshitij.so 5983 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
5984 
    args = updateAmazonAttributesInBulk_args()
5985 
    args.read(iprot)
5986 
    iprot.readMessageEnd()
5987 
    result = updateAmazonAttributesInBulk_result()
5988 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
5989 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
5990 
    result.write(oprot)
5991 
    oprot.writeMessageEnd()
5992 
    oprot.trans.flush()
8139 kshitij.so 5993 
 
8379 vikram.rag 5994 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
5995 
    args = getAllItemstoListOnFba_args()
5996 
    args.read(iprot)
5997 
    iprot.readMessageEnd()
5998 
    result = getAllItemstoListOnFba_result()
5999 
    result.success = self._handler.getAllItemstoListOnFba()
6000 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6001 
    result.write(oprot)
6002 
    oprot.writeMessageEnd()
6003 
    oprot.trans.flush()
8168 kshitij.so 6004 
 
8379 vikram.rag 6005 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6006 
    args = getAllItemstoListOnNonFba_args()
6007 
    args.read(iprot)
6008 
    iprot.readMessageEnd()
6009 
    result = getAllItemstoListOnNonFba_result()
6010 
    result.success = self._handler.getAllItemstoListOnNonFba()
6011 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6012 
    result.write(oprot)
6013 
    oprot.writeMessageEnd()
6014 
    oprot.trans.flush()
6015 
 
6016 
 
5944 mandeep.dh 6017 
# HELPER FUNCTIONS AND STRUCTURES
6018 
 
6019 
class addItem_args:
6020 
  """
6021 
  Attributes:
6022 
   - item
6023 
  """
6024 
 
6025 
  thrift_spec = (
6026 
    None, # 0
6027 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6028 
  )
6029 
 
6030 
  def __init__(self, item=None,):
6031 
    self.item = item
6032 
 
6033 
  def read(self, iprot):
6034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6036 
      return
6037 
    iprot.readStructBegin()
6038 
    while True:
6039 
      (fname, ftype, fid) = iprot.readFieldBegin()
6040 
      if ftype == TType.STOP:
6041 
        break
6042 
      if fid == 1:
6043 
        if ftype == TType.STRUCT:
6044 
          self.item = Item()
6045 
          self.item.read(iprot)
6046 
        else:
6047 
          iprot.skip(ftype)
6048 
      else:
6049 
        iprot.skip(ftype)
6050 
      iprot.readFieldEnd()
6051 
    iprot.readStructEnd()
6052 
 
6053 
  def write(self, oprot):
6054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6056 
      return
6057 
    oprot.writeStructBegin('addItem_args')
6058 
    if self.item is not None:
6059 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6060 
      self.item.write(oprot)
6061 
      oprot.writeFieldEnd()
6062 
    oprot.writeFieldStop()
6063 
    oprot.writeStructEnd()
6064 
 
6065 
  def validate(self):
6066 
    return
6067 
 
6068 
 
6069 
  def __repr__(self):
6070 
    L = ['%s=%r' % (key, value)
6071 
      for key, value in self.__dict__.iteritems()]
6072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6073 
 
6074 
  def __eq__(self, other):
6075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6076 
 
6077 
  def __ne__(self, other):
6078 
    return not (self == other)
6079 
 
6080 
class addItem_result:
6081 
  """
6082 
  Attributes:
6083 
   - success
6084 
   - cex
6085 
  """
6086 
 
6087 
  thrift_spec = (
6088 
    (0, TType.I64, 'success', None, None, ), # 0
6089 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6090 
  )
6091 
 
6092 
  def __init__(self, success=None, cex=None,):
6093 
    self.success = success
6094 
    self.cex = cex
6095 
 
6096 
  def read(self, iprot):
6097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6099 
      return
6100 
    iprot.readStructBegin()
6101 
    while True:
6102 
      (fname, ftype, fid) = iprot.readFieldBegin()
6103 
      if ftype == TType.STOP:
6104 
        break
6105 
      if fid == 0:
6106 
        if ftype == TType.I64:
6107 
          self.success = iprot.readI64();
6108 
        else:
6109 
          iprot.skip(ftype)
6110 
      elif fid == 1:
6111 
        if ftype == TType.STRUCT:
6112 
          self.cex = CatalogServiceException()
6113 
          self.cex.read(iprot)
6114 
        else:
6115 
          iprot.skip(ftype)
6116 
      else:
6117 
        iprot.skip(ftype)
6118 
      iprot.readFieldEnd()
6119 
    iprot.readStructEnd()
6120 
 
6121 
  def write(self, oprot):
6122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6124 
      return
6125 
    oprot.writeStructBegin('addItem_result')
6126 
    if self.success is not None:
6127 
      oprot.writeFieldBegin('success', TType.I64, 0)
6128 
      oprot.writeI64(self.success)
6129 
      oprot.writeFieldEnd()
6130 
    if self.cex is not None:
6131 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6132 
      self.cex.write(oprot)
6133 
      oprot.writeFieldEnd()
6134 
    oprot.writeFieldStop()
6135 
    oprot.writeStructEnd()
6136 
 
6137 
  def validate(self):
6138 
    return
6139 
 
6140 
 
6141 
  def __repr__(self):
6142 
    L = ['%s=%r' % (key, value)
6143 
      for key, value in self.__dict__.iteritems()]
6144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6145 
 
6146 
  def __eq__(self, other):
6147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6148 
 
6149 
  def __ne__(self, other):
6150 
    return not (self == other)
6151 
 
6152 
class updateItem_args:
6153 
  """
6154 
  Attributes:
6155 
   - item
6156 
  """
6157 
 
6158 
  thrift_spec = (
6159 
    None, # 0
6160 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6161 
  )
6162 
 
6163 
  def __init__(self, item=None,):
6164 
    self.item = item
6165 
 
6166 
  def read(self, iprot):
6167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6169 
      return
6170 
    iprot.readStructBegin()
6171 
    while True:
6172 
      (fname, ftype, fid) = iprot.readFieldBegin()
6173 
      if ftype == TType.STOP:
6174 
        break
6175 
      if fid == 1:
6176 
        if ftype == TType.STRUCT:
6177 
          self.item = Item()
6178 
          self.item.read(iprot)
6179 
        else:
6180 
          iprot.skip(ftype)
6181 
      else:
6182 
        iprot.skip(ftype)
6183 
      iprot.readFieldEnd()
6184 
    iprot.readStructEnd()
6185 
 
6186 
  def write(self, oprot):
6187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6189 
      return
6190 
    oprot.writeStructBegin('updateItem_args')
6191 
    if self.item is not None:
6192 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6193 
      self.item.write(oprot)
6194 
      oprot.writeFieldEnd()
6195 
    oprot.writeFieldStop()
6196 
    oprot.writeStructEnd()
6197 
 
6198 
  def validate(self):
6199 
    return
6200 
 
6201 
 
6202 
  def __repr__(self):
6203 
    L = ['%s=%r' % (key, value)
6204 
      for key, value in self.__dict__.iteritems()]
6205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6206 
 
6207 
  def __eq__(self, other):
6208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6209 
 
6210 
  def __ne__(self, other):
6211 
    return not (self == other)
6212 
 
6213 
class updateItem_result:
6214 
  """
6215 
  Attributes:
6216 
   - success
6217 
   - cex
6218 
  """
6219 
 
6220 
  thrift_spec = (
6221 
    (0, TType.I64, 'success', None, None, ), # 0
6222 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6223 
  )
6224 
 
6225 
  def __init__(self, success=None, cex=None,):
6226 
    self.success = success
6227 
    self.cex = cex
6228 
 
6229 
  def read(self, iprot):
6230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6232 
      return
6233 
    iprot.readStructBegin()
6234 
    while True:
6235 
      (fname, ftype, fid) = iprot.readFieldBegin()
6236 
      if ftype == TType.STOP:
6237 
        break
6238 
      if fid == 0:
6239 
        if ftype == TType.I64:
6240 
          self.success = iprot.readI64();
6241 
        else:
6242 
          iprot.skip(ftype)
6243 
      elif fid == 1:
6244 
        if ftype == TType.STRUCT:
6245 
          self.cex = CatalogServiceException()
6246 
          self.cex.read(iprot)
6247 
        else:
6248 
          iprot.skip(ftype)
6249 
      else:
6250 
        iprot.skip(ftype)
6251 
      iprot.readFieldEnd()
6252 
    iprot.readStructEnd()
6253 
 
6254 
  def write(self, oprot):
6255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6257 
      return
6258 
    oprot.writeStructBegin('updateItem_result')
6259 
    if self.success is not None:
6260 
      oprot.writeFieldBegin('success', TType.I64, 0)
6261 
      oprot.writeI64(self.success)
6262 
      oprot.writeFieldEnd()
6263 
    if self.cex is not None:
6264 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6265 
      self.cex.write(oprot)
6266 
      oprot.writeFieldEnd()
6267 
    oprot.writeFieldStop()
6268 
    oprot.writeStructEnd()
6269 
 
6270 
  def validate(self):
6271 
    return
6272 
 
6273 
 
6274 
  def __repr__(self):
6275 
    L = ['%s=%r' % (key, value)
6276 
      for key, value in self.__dict__.iteritems()]
6277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6278 
 
6279 
  def __eq__(self, other):
6280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6281 
 
6282 
  def __ne__(self, other):
6283 
    return not (self == other)
6284 
 
6285 
class isActive_args:
6286 
  """
6287 
  Attributes:
6288 
   - itemId
6289 
  """
6290 
 
6291 
  thrift_spec = (
6292 
    None, # 0
6293 
    (1, TType.I64, 'itemId', None, None, ), # 1
6294 
  )
6295 
 
6296 
  def __init__(self, itemId=None,):
6297 
    self.itemId = itemId
6298 
 
6299 
  def read(self, iprot):
6300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6302 
      return
6303 
    iprot.readStructBegin()
6304 
    while True:
6305 
      (fname, ftype, fid) = iprot.readFieldBegin()
6306 
      if ftype == TType.STOP:
6307 
        break
6308 
      if fid == 1:
6309 
        if ftype == TType.I64:
6310 
          self.itemId = iprot.readI64();
6311 
        else:
6312 
          iprot.skip(ftype)
6313 
      else:
6314 
        iprot.skip(ftype)
6315 
      iprot.readFieldEnd()
6316 
    iprot.readStructEnd()
6317 
 
6318 
  def write(self, oprot):
6319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6321 
      return
6322 
    oprot.writeStructBegin('isActive_args')
6323 
    if self.itemId is not None:
6324 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6325 
      oprot.writeI64(self.itemId)
6326 
      oprot.writeFieldEnd()
6327 
    oprot.writeFieldStop()
6328 
    oprot.writeStructEnd()
6329 
 
6330 
  def validate(self):
6331 
    return
6332 
 
6333 
 
6334 
  def __repr__(self):
6335 
    L = ['%s=%r' % (key, value)
6336 
      for key, value in self.__dict__.iteritems()]
6337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6338 
 
6339 
  def __eq__(self, other):
6340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6341 
 
6342 
  def __ne__(self, other):
6343 
    return not (self == other)
6344 
 
6345 
class isActive_result:
6346 
  """
6347 
  Attributes:
6348 
   - success
6349 
   - isex
6350 
  """
6351 
 
6352 
  thrift_spec = (
6353 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6354 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6355 
  )
6356 
 
6357 
  def __init__(self, success=None, isex=None,):
6358 
    self.success = success
6359 
    self.isex = isex
6360 
 
6361 
  def read(self, iprot):
6362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6364 
      return
6365 
    iprot.readStructBegin()
6366 
    while True:
6367 
      (fname, ftype, fid) = iprot.readFieldBegin()
6368 
      if ftype == TType.STOP:
6369 
        break
6370 
      if fid == 0:
6371 
        if ftype == TType.STRUCT:
6372 
          self.success = ItemShippingInfo()
6373 
          self.success.read(iprot)
6374 
        else:
6375 
          iprot.skip(ftype)
6376 
      elif fid == 1:
6377 
        if ftype == TType.STRUCT:
6378 
          self.isex = CatalogServiceException()
6379 
          self.isex.read(iprot)
6380 
        else:
6381 
          iprot.skip(ftype)
6382 
      else:
6383 
        iprot.skip(ftype)
6384 
      iprot.readFieldEnd()
6385 
    iprot.readStructEnd()
6386 
 
6387 
  def write(self, oprot):
6388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6390 
      return
6391 
    oprot.writeStructBegin('isActive_result')
6392 
    if self.success is not None:
6393 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6394 
      self.success.write(oprot)
6395 
      oprot.writeFieldEnd()
6396 
    if self.isex is not None:
6397 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6398 
      self.isex.write(oprot)
6399 
      oprot.writeFieldEnd()
6400 
    oprot.writeFieldStop()
6401 
    oprot.writeStructEnd()
6402 
 
6403 
  def validate(self):
6404 
    return
6405 
 
6406 
 
6407 
  def __repr__(self):
6408 
    L = ['%s=%r' % (key, value)
6409 
      for key, value in self.__dict__.iteritems()]
6410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6411 
 
6412 
  def __eq__(self, other):
6413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6414 
 
6415 
  def __ne__(self, other):
6416 
    return not (self == other)
6417 
 
7438 amit.gupta 6418 
class getItemsStatus_args:
6419 
  """
6420 
  Attributes:
6421 
   - itemIds
6422 
  """
6423 
 
6424 
  thrift_spec = (
6425 
    None, # 0
6426 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
6427 
  )
6428 
 
6429 
  def __init__(self, itemIds=None,):
6430 
    self.itemIds = itemIds
6431 
 
6432 
  def read(self, iprot):
6433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6435 
      return
6436 
    iprot.readStructBegin()
6437 
    while True:
6438 
      (fname, ftype, fid) = iprot.readFieldBegin()
6439 
      if ftype == TType.STOP:
6440 
        break
6441 
      if fid == 1:
6442 
        if ftype == TType.LIST:
6443 
          self.itemIds = []
8590 kshitij.so 6444 
          (_etype33, _size30) = iprot.readListBegin()
6445 
          for _i34 in xrange(_size30):
6446 
            _elem35 = iprot.readI64();
6447 
            self.itemIds.append(_elem35)
7438 amit.gupta 6448 
          iprot.readListEnd()
6449 
        else:
6450 
          iprot.skip(ftype)
6451 
      else:
6452 
        iprot.skip(ftype)
6453 
      iprot.readFieldEnd()
6454 
    iprot.readStructEnd()
6455 
 
6456 
  def write(self, oprot):
6457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6459 
      return
6460 
    oprot.writeStructBegin('getItemsStatus_args')
6461 
    if self.itemIds is not None:
6462 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6463 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 6464 
      for iter36 in self.itemIds:
6465 
        oprot.writeI64(iter36)
7438 amit.gupta 6466 
      oprot.writeListEnd()
6467 
      oprot.writeFieldEnd()
6468 
    oprot.writeFieldStop()
6469 
    oprot.writeStructEnd()
6470 
 
6471 
  def validate(self):
6472 
    return
6473 
 
6474 
 
6475 
  def __repr__(self):
6476 
    L = ['%s=%r' % (key, value)
6477 
      for key, value in self.__dict__.iteritems()]
6478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6479 
 
6480 
  def __eq__(self, other):
6481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6482 
 
6483 
  def __ne__(self, other):
6484 
    return not (self == other)
6485 
 
6486 
class getItemsStatus_result:
6487 
  """
6488 
  Attributes:
6489 
   - success
6490 
   - isex
6491 
  """
6492 
 
6493 
  thrift_spec = (
6494 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6495 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6496 
  )
6497 
 
6498 
  def __init__(self, success=None, isex=None,):
6499 
    self.success = success
6500 
    self.isex = isex
6501 
 
6502 
  def read(self, iprot):
6503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6505 
      return
6506 
    iprot.readStructBegin()
6507 
    while True:
6508 
      (fname, ftype, fid) = iprot.readFieldBegin()
6509 
      if ftype == TType.STOP:
6510 
        break
6511 
      if fid == 0:
6512 
        if ftype == TType.MAP:
6513 
          self.success = {}
8590 kshitij.so 6514 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
6515 
          for _i41 in xrange(_size37):
6516 
            _key42 = iprot.readI64();
6517 
            _val43 = iprot.readBool();
6518 
            self.success[_key42] = _val43
7438 amit.gupta 6519 
          iprot.readMapEnd()
6520 
        else:
6521 
          iprot.skip(ftype)
6522 
      elif fid == 1:
6523 
        if ftype == TType.STRUCT:
6524 
          self.isex = CatalogServiceException()
6525 
          self.isex.read(iprot)
6526 
        else:
6527 
          iprot.skip(ftype)
6528 
      else:
6529 
        iprot.skip(ftype)
6530 
      iprot.readFieldEnd()
6531 
    iprot.readStructEnd()
6532 
 
6533 
  def write(self, oprot):
6534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6536 
      return
6537 
    oprot.writeStructBegin('getItemsStatus_result')
6538 
    if self.success is not None:
6539 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6540 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 6541 
      for kiter44,viter45 in self.success.items():
6542 
        oprot.writeI64(kiter44)
6543 
        oprot.writeBool(viter45)
7438 amit.gupta 6544 
      oprot.writeMapEnd()
6545 
      oprot.writeFieldEnd()
6546 
    if self.isex is not None:
6547 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6548 
      self.isex.write(oprot)
6549 
      oprot.writeFieldEnd()
6550 
    oprot.writeFieldStop()
6551 
    oprot.writeStructEnd()
6552 
 
6553 
  def validate(self):
6554 
    return
6555 
 
6556 
 
6557 
  def __repr__(self):
6558 
    L = ['%s=%r' % (key, value)
6559 
      for key, value in self.__dict__.iteritems()]
6560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6561 
 
6562 
  def __eq__(self, other):
6563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6564 
 
6565 
  def __ne__(self, other):
6566 
    return not (self == other)
6567 
 
5944 mandeep.dh 6568 
class getItemStatusDescription_args:
6569 
  """
6570 
  Attributes:
6571 
   - itemId
6572 
  """
6573 
 
6574 
  thrift_spec = (
6575 
    None, # 0
6576 
    (1, TType.I64, 'itemId', None, None, ), # 1
6577 
  )
6578 
 
6579 
  def __init__(self, itemId=None,):
6580 
    self.itemId = itemId
6581 
 
6582 
  def read(self, iprot):
6583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6585 
      return
6586 
    iprot.readStructBegin()
6587 
    while True:
6588 
      (fname, ftype, fid) = iprot.readFieldBegin()
6589 
      if ftype == TType.STOP:
6590 
        break
6591 
      if fid == 1:
6592 
        if ftype == TType.I64:
6593 
          self.itemId = iprot.readI64();
6594 
        else:
6595 
          iprot.skip(ftype)
6596 
      else:
6597 
        iprot.skip(ftype)
6598 
      iprot.readFieldEnd()
6599 
    iprot.readStructEnd()
6600 
 
6601 
  def write(self, oprot):
6602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6604 
      return
6605 
    oprot.writeStructBegin('getItemStatusDescription_args')
6606 
    if self.itemId is not None:
6607 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6608 
      oprot.writeI64(self.itemId)
6609 
      oprot.writeFieldEnd()
6610 
    oprot.writeFieldStop()
6611 
    oprot.writeStructEnd()
6612 
 
6613 
  def validate(self):
6614 
    return
6615 
 
6616 
 
6617 
  def __repr__(self):
6618 
    L = ['%s=%r' % (key, value)
6619 
      for key, value in self.__dict__.iteritems()]
6620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6621 
 
6622 
  def __eq__(self, other):
6623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6624 
 
6625 
  def __ne__(self, other):
6626 
    return not (self == other)
6627 
 
6628 
class getItemStatusDescription_result:
6629 
  """
6630 
  Attributes:
6631 
   - success
6632 
   - isex
6633 
  """
6634 
 
6635 
  thrift_spec = (
6636 
    (0, TType.STRING, 'success', None, None, ), # 0
6637 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6638 
  )
6639 
 
6640 
  def __init__(self, success=None, isex=None,):
6641 
    self.success = success
6642 
    self.isex = isex
6643 
 
6644 
  def read(self, iprot):
6645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6647 
      return
6648 
    iprot.readStructBegin()
6649 
    while True:
6650 
      (fname, ftype, fid) = iprot.readFieldBegin()
6651 
      if ftype == TType.STOP:
6652 
        break
6653 
      if fid == 0:
6654 
        if ftype == TType.STRING:
6655 
          self.success = iprot.readString();
6656 
        else:
6657 
          iprot.skip(ftype)
6658 
      elif fid == 1:
6659 
        if ftype == TType.STRUCT:
6660 
          self.isex = CatalogServiceException()
6661 
          self.isex.read(iprot)
6662 
        else:
6663 
          iprot.skip(ftype)
6664 
      else:
6665 
        iprot.skip(ftype)
6666 
      iprot.readFieldEnd()
6667 
    iprot.readStructEnd()
6668 
 
6669 
  def write(self, oprot):
6670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6672 
      return
6673 
    oprot.writeStructBegin('getItemStatusDescription_result')
6674 
    if self.success is not None:
6675 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6676 
      oprot.writeString(self.success)
6677 
      oprot.writeFieldEnd()
6678 
    if self.isex is not None:
6679 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6680 
      self.isex.write(oprot)
6681 
      oprot.writeFieldEnd()
6682 
    oprot.writeFieldStop()
6683 
    oprot.writeStructEnd()
6684 
 
6685 
  def validate(self):
6686 
    return
6687 
 
6688 
 
6689 
  def __repr__(self):
6690 
    L = ['%s=%r' % (key, value)
6691 
      for key, value in self.__dict__.iteritems()]
6692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6693 
 
6694 
  def __eq__(self, other):
6695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6696 
 
6697 
  def __ne__(self, other):
6698 
    return not (self == other)
6699 
 
6700 
class startItemOn_args:
6701 
  """
6702 
  Attributes:
6703 
   - item_id
6704 
   - timestamp
6705 
  """
6706 
 
6707 
  thrift_spec = (
6708 
    None, # 0
6709 
    (1, TType.I64, 'item_id', None, None, ), # 1
6710 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6711 
  )
6712 
 
6713 
  def __init__(self, item_id=None, timestamp=None,):
6714 
    self.item_id = item_id
6715 
    self.timestamp = timestamp
6716 
 
6717 
  def read(self, iprot):
6718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6720 
      return
6721 
    iprot.readStructBegin()
6722 
    while True:
6723 
      (fname, ftype, fid) = iprot.readFieldBegin()
6724 
      if ftype == TType.STOP:
6725 
        break
6726 
      if fid == 1:
6727 
        if ftype == TType.I64:
6728 
          self.item_id = iprot.readI64();
6729 
        else:
6730 
          iprot.skip(ftype)
6731 
      elif fid == 2:
6732 
        if ftype == TType.I64:
6733 
          self.timestamp = iprot.readI64();
6734 
        else:
6735 
          iprot.skip(ftype)
6736 
      else:
6737 
        iprot.skip(ftype)
6738 
      iprot.readFieldEnd()
6739 
    iprot.readStructEnd()
6740 
 
6741 
  def write(self, oprot):
6742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6744 
      return
6745 
    oprot.writeStructBegin('startItemOn_args')
6746 
    if self.item_id is not None:
6747 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6748 
      oprot.writeI64(self.item_id)
6749 
      oprot.writeFieldEnd()
6750 
    if self.timestamp is not None:
6751 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6752 
      oprot.writeI64(self.timestamp)
6753 
      oprot.writeFieldEnd()
6754 
    oprot.writeFieldStop()
6755 
    oprot.writeStructEnd()
6756 
 
6757 
  def validate(self):
6758 
    return
6759 
 
6760 
 
6761 
  def __repr__(self):
6762 
    L = ['%s=%r' % (key, value)
6763 
      for key, value in self.__dict__.iteritems()]
6764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6765 
 
6766 
  def __eq__(self, other):
6767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6768 
 
6769 
  def __ne__(self, other):
6770 
    return not (self == other)
6771 
 
6772 
class startItemOn_result:
6773 
  """
6774 
  Attributes:
6775 
   - cex
6776 
  """
6777 
 
6778 
  thrift_spec = (
6779 
    None, # 0
6780 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6781 
  )
6782 
 
6783 
  def __init__(self, cex=None,):
6784 
    self.cex = cex
6785 
 
6786 
  def read(self, iprot):
6787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6789 
      return
6790 
    iprot.readStructBegin()
6791 
    while True:
6792 
      (fname, ftype, fid) = iprot.readFieldBegin()
6793 
      if ftype == TType.STOP:
6794 
        break
6795 
      if fid == 1:
6796 
        if ftype == TType.STRUCT:
6797 
          self.cex = CatalogServiceException()
6798 
          self.cex.read(iprot)
6799 
        else:
6800 
          iprot.skip(ftype)
6801 
      else:
6802 
        iprot.skip(ftype)
6803 
      iprot.readFieldEnd()
6804 
    iprot.readStructEnd()
6805 
 
6806 
  def write(self, oprot):
6807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6809 
      return
6810 
    oprot.writeStructBegin('startItemOn_result')
6811 
    if self.cex is not None:
6812 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6813 
      self.cex.write(oprot)
6814 
      oprot.writeFieldEnd()
6815 
    oprot.writeFieldStop()
6816 
    oprot.writeStructEnd()
6817 
 
6818 
  def validate(self):
6819 
    return
6820 
 
6821 
 
6822 
  def __repr__(self):
6823 
    L = ['%s=%r' % (key, value)
6824 
      for key, value in self.__dict__.iteritems()]
6825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6826 
 
6827 
  def __eq__(self, other):
6828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6829 
 
6830 
  def __ne__(self, other):
6831 
    return not (self == other)
6832 
 
6833 
class retireItemOn_args:
6834 
  """
6835 
  Attributes:
6836 
   - item_id
6837 
   - timestamp
6838 
  """
6839 
 
6840 
  thrift_spec = (
6841 
    None, # 0
6842 
    (1, TType.I64, 'item_id', None, None, ), # 1
6843 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6844 
  )
6845 
 
6846 
  def __init__(self, item_id=None, timestamp=None,):
6847 
    self.item_id = item_id
6848 
    self.timestamp = timestamp
6849 
 
6850 
  def read(self, iprot):
6851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6853 
      return
6854 
    iprot.readStructBegin()
6855 
    while True:
6856 
      (fname, ftype, fid) = iprot.readFieldBegin()
6857 
      if ftype == TType.STOP:
6858 
        break
6859 
      if fid == 1:
6860 
        if ftype == TType.I64:
6861 
          self.item_id = iprot.readI64();
6862 
        else:
6863 
          iprot.skip(ftype)
6864 
      elif fid == 2:
6865 
        if ftype == TType.I64:
6866 
          self.timestamp = iprot.readI64();
6867 
        else:
6868 
          iprot.skip(ftype)
6869 
      else:
6870 
        iprot.skip(ftype)
6871 
      iprot.readFieldEnd()
6872 
    iprot.readStructEnd()
6873 
 
6874 
  def write(self, oprot):
6875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6877 
      return
6878 
    oprot.writeStructBegin('retireItemOn_args')
6879 
    if self.item_id is not None:
6880 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6881 
      oprot.writeI64(self.item_id)
6882 
      oprot.writeFieldEnd()
6883 
    if self.timestamp is not None:
6884 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6885 
      oprot.writeI64(self.timestamp)
6886 
      oprot.writeFieldEnd()
6887 
    oprot.writeFieldStop()
6888 
    oprot.writeStructEnd()
6889 
 
6890 
  def validate(self):
6891 
    return
6892 
 
6893 
 
6894 
  def __repr__(self):
6895 
    L = ['%s=%r' % (key, value)
6896 
      for key, value in self.__dict__.iteritems()]
6897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6898 
 
6899 
  def __eq__(self, other):
6900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6901 
 
6902 
  def __ne__(self, other):
6903 
    return not (self == other)
6904 
 
6905 
class retireItemOn_result:
6906 
  """
6907 
  Attributes:
6908 
   - cex
6909 
  """
6910 
 
6911 
  thrift_spec = (
6912 
    None, # 0
6913 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6914 
  )
6915 
 
6916 
  def __init__(self, cex=None,):
6917 
    self.cex = cex
6918 
 
6919 
  def read(self, iprot):
6920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6922 
      return
6923 
    iprot.readStructBegin()
6924 
    while True:
6925 
      (fname, ftype, fid) = iprot.readFieldBegin()
6926 
      if ftype == TType.STOP:
6927 
        break
6928 
      if fid == 1:
6929 
        if ftype == TType.STRUCT:
6930 
          self.cex = CatalogServiceException()
6931 
          self.cex.read(iprot)
6932 
        else:
6933 
          iprot.skip(ftype)
6934 
      else:
6935 
        iprot.skip(ftype)
6936 
      iprot.readFieldEnd()
6937 
    iprot.readStructEnd()
6938 
 
6939 
  def write(self, oprot):
6940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6942 
      return
6943 
    oprot.writeStructBegin('retireItemOn_result')
6944 
    if self.cex is not None:
6945 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6946 
      self.cex.write(oprot)
6947 
      oprot.writeFieldEnd()
6948 
    oprot.writeFieldStop()
6949 
    oprot.writeStructEnd()
6950 
 
6951 
  def validate(self):
6952 
    return
6953 
 
6954 
 
6955 
  def __repr__(self):
6956 
    L = ['%s=%r' % (key, value)
6957 
      for key, value in self.__dict__.iteritems()]
6958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6959 
 
6960 
  def __eq__(self, other):
6961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6962 
 
6963 
  def __ne__(self, other):
6964 
    return not (self == other)
6965 
 
6966 
class changeItemStatus_args:
6967 
  """
6968 
  Attributes:
6969 
   - item_id
6970 
   - timestamp
6971 
   - newstatus
6972 
  """
6973 
 
6974 
  thrift_spec = (
6975 
    None, # 0
6976 
    (1, TType.I64, 'item_id', None, None, ), # 1
6977 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6978 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6979 
  )
6980 
 
6981 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6982 
    self.item_id = item_id
6983 
    self.timestamp = timestamp
6984 
    self.newstatus = newstatus
6985 
 
6986 
  def read(self, iprot):
6987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6989 
      return
6990 
    iprot.readStructBegin()
6991 
    while True:
6992 
      (fname, ftype, fid) = iprot.readFieldBegin()
6993 
      if ftype == TType.STOP:
6994 
        break
6995 
      if fid == 1:
6996 
        if ftype == TType.I64:
6997 
          self.item_id = iprot.readI64();
6998 
        else:
6999 
          iprot.skip(ftype)
7000 
      elif fid == 2:
7001 
        if ftype == TType.I64:
7002 
          self.timestamp = iprot.readI64();
7003 
        else:
7004 
          iprot.skip(ftype)
7005 
      elif fid == 3:
7006 
        if ftype == TType.I32:
7007 
          self.newstatus = iprot.readI32();
7008 
        else:
7009 
          iprot.skip(ftype)
7010 
      else:
7011 
        iprot.skip(ftype)
7012 
      iprot.readFieldEnd()
7013 
    iprot.readStructEnd()
7014 
 
7015 
  def write(self, oprot):
7016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7018 
      return
7019 
    oprot.writeStructBegin('changeItemStatus_args')
7020 
    if self.item_id is not None:
7021 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7022 
      oprot.writeI64(self.item_id)
7023 
      oprot.writeFieldEnd()
7024 
    if self.timestamp is not None:
7025 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7026 
      oprot.writeI64(self.timestamp)
7027 
      oprot.writeFieldEnd()
7028 
    if self.newstatus is not None:
7029 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7030 
      oprot.writeI32(self.newstatus)
7031 
      oprot.writeFieldEnd()
7032 
    oprot.writeFieldStop()
7033 
    oprot.writeStructEnd()
7034 
 
7035 
  def validate(self):
7036 
    return
7037 
 
7038 
 
7039 
  def __repr__(self):
7040 
    L = ['%s=%r' % (key, value)
7041 
      for key, value in self.__dict__.iteritems()]
7042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7043 
 
7044 
  def __eq__(self, other):
7045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7046 
 
7047 
  def __ne__(self, other):
7048 
    return not (self == other)
7049 
 
7050 
class changeItemStatus_result:
7051 
  """
7052 
  Attributes:
7053 
   - cex
7054 
  """
7055 
 
7056 
  thrift_spec = (
7057 
    None, # 0
7058 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7059 
  )
7060 
 
7061 
  def __init__(self, cex=None,):
7062 
    self.cex = cex
7063 
 
7064 
  def read(self, iprot):
7065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7067 
      return
7068 
    iprot.readStructBegin()
7069 
    while True:
7070 
      (fname, ftype, fid) = iprot.readFieldBegin()
7071 
      if ftype == TType.STOP:
7072 
        break
7073 
      if fid == 1:
7074 
        if ftype == TType.STRUCT:
7075 
          self.cex = CatalogServiceException()
7076 
          self.cex.read(iprot)
7077 
        else:
7078 
          iprot.skip(ftype)
7079 
      else:
7080 
        iprot.skip(ftype)
7081 
      iprot.readFieldEnd()
7082 
    iprot.readStructEnd()
7083 
 
7084 
  def write(self, oprot):
7085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7087 
      return
7088 
    oprot.writeStructBegin('changeItemStatus_result')
7089 
    if self.cex is not None:
7090 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7091 
      self.cex.write(oprot)
7092 
      oprot.writeFieldEnd()
7093 
    oprot.writeFieldStop()
7094 
    oprot.writeStructEnd()
7095 
 
7096 
  def validate(self):
7097 
    return
7098 
 
7099 
 
7100 
  def __repr__(self):
7101 
    L = ['%s=%r' % (key, value)
7102 
      for key, value in self.__dict__.iteritems()]
7103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7104 
 
7105 
  def __eq__(self, other):
7106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7107 
 
7108 
  def __ne__(self, other):
7109 
    return not (self == other)
7110 
 
7111 
class getItem_args:
7112 
  """
7113 
  Attributes:
7114 
   - item_id
7115 
  """
7116 
 
7117 
  thrift_spec = (
7118 
    None, # 0
7119 
    (1, TType.I64, 'item_id', None, None, ), # 1
7120 
  )
7121 
 
7122 
  def __init__(self, item_id=None,):
7123 
    self.item_id = item_id
7124 
 
7125 
  def read(self, iprot):
7126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7128 
      return
7129 
    iprot.readStructBegin()
7130 
    while True:
7131 
      (fname, ftype, fid) = iprot.readFieldBegin()
7132 
      if ftype == TType.STOP:
7133 
        break
7134 
      if fid == 1:
7135 
        if ftype == TType.I64:
7136 
          self.item_id = iprot.readI64();
7137 
        else:
7138 
          iprot.skip(ftype)
7139 
      else:
7140 
        iprot.skip(ftype)
7141 
      iprot.readFieldEnd()
7142 
    iprot.readStructEnd()
7143 
 
7144 
  def write(self, oprot):
7145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7147 
      return
7148 
    oprot.writeStructBegin('getItem_args')
7149 
    if self.item_id is not None:
7150 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7151 
      oprot.writeI64(self.item_id)
7152 
      oprot.writeFieldEnd()
7153 
    oprot.writeFieldStop()
7154 
    oprot.writeStructEnd()
7155 
 
7156 
  def validate(self):
7157 
    return
7158 
 
7159 
 
7160 
  def __repr__(self):
7161 
    L = ['%s=%r' % (key, value)
7162 
      for key, value in self.__dict__.iteritems()]
7163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7164 
 
7165 
  def __eq__(self, other):
7166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7167 
 
7168 
  def __ne__(self, other):
7169 
    return not (self == other)
7170 
 
7171 
class getItem_result:
7172 
  """
7173 
  Attributes:
7174 
   - success
7175 
   - cex
7176 
  """
7177 
 
7178 
  thrift_spec = (
7179 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7180 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7181 
  )
7182 
 
7183 
  def __init__(self, success=None, cex=None,):
7184 
    self.success = success
7185 
    self.cex = cex
7186 
 
7187 
  def read(self, iprot):
7188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7190 
      return
7191 
    iprot.readStructBegin()
7192 
    while True:
7193 
      (fname, ftype, fid) = iprot.readFieldBegin()
7194 
      if ftype == TType.STOP:
7195 
        break
7196 
      if fid == 0:
7197 
        if ftype == TType.STRUCT:
7198 
          self.success = Item()
7199 
          self.success.read(iprot)
7200 
        else:
7201 
          iprot.skip(ftype)
7202 
      elif fid == 1:
7203 
        if ftype == TType.STRUCT:
7204 
          self.cex = CatalogServiceException()
7205 
          self.cex.read(iprot)
7206 
        else:
7207 
          iprot.skip(ftype)
7208 
      else:
7209 
        iprot.skip(ftype)
7210 
      iprot.readFieldEnd()
7211 
    iprot.readStructEnd()
7212 
 
7213 
  def write(self, oprot):
7214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7216 
      return
7217 
    oprot.writeStructBegin('getItem_result')
7218 
    if self.success is not None:
7219 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7220 
      self.success.write(oprot)
7221 
      oprot.writeFieldEnd()
7222 
    if self.cex is not None:
7223 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7224 
      self.cex.write(oprot)
7225 
      oprot.writeFieldEnd()
7226 
    oprot.writeFieldStop()
7227 
    oprot.writeStructEnd()
7228 
 
7229 
  def validate(self):
7230 
    return
7231 
 
7232 
 
7233 
  def __repr__(self):
7234 
    L = ['%s=%r' % (key, value)
7235 
      for key, value in self.__dict__.iteritems()]
7236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7237 
 
7238 
  def __eq__(self, other):
7239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7240 
 
7241 
  def __ne__(self, other):
7242 
    return not (self == other)
7243 
 
7244 
class getItemsByCatalogId_args:
7245 
  """
7246 
  Attributes:
7247 
   - catalog_item_id
7248 
  """
7249 
 
7250 
  thrift_spec = (
7251 
    None, # 0
7252 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7253 
  )
7254 
 
7255 
  def __init__(self, catalog_item_id=None,):
7256 
    self.catalog_item_id = catalog_item_id
7257 
 
7258 
  def read(self, iprot):
7259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7261 
      return
7262 
    iprot.readStructBegin()
7263 
    while True:
7264 
      (fname, ftype, fid) = iprot.readFieldBegin()
7265 
      if ftype == TType.STOP:
7266 
        break
7267 
      if fid == 1:
7268 
        if ftype == TType.I64:
7269 
          self.catalog_item_id = iprot.readI64();
7270 
        else:
7271 
          iprot.skip(ftype)
7272 
      else:
7273 
        iprot.skip(ftype)
7274 
      iprot.readFieldEnd()
7275 
    iprot.readStructEnd()
7276 
 
7277 
  def write(self, oprot):
7278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7280 
      return
7281 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7282 
    if self.catalog_item_id is not None:
7283 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7284 
      oprot.writeI64(self.catalog_item_id)
7285 
      oprot.writeFieldEnd()
7286 
    oprot.writeFieldStop()
7287 
    oprot.writeStructEnd()
7288 
 
7289 
  def validate(self):
7290 
    return
7291 
 
7292 
 
7293 
  def __repr__(self):
7294 
    L = ['%s=%r' % (key, value)
7295 
      for key, value in self.__dict__.iteritems()]
7296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7297 
 
7298 
  def __eq__(self, other):
7299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7300 
 
7301 
  def __ne__(self, other):
7302 
    return not (self == other)
7303 
 
7304 
class getItemsByCatalogId_result:
7305 
  """
7306 
  Attributes:
7307 
   - success
7308 
   - cex
7309 
  """
7310 
 
7311 
  thrift_spec = (
7312 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7313 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7314 
  )
7315 
 
7316 
  def __init__(self, success=None, cex=None,):
7317 
    self.success = success
7318 
    self.cex = cex
7319 
 
7320 
  def read(self, iprot):
7321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7323 
      return
7324 
    iprot.readStructBegin()
7325 
    while True:
7326 
      (fname, ftype, fid) = iprot.readFieldBegin()
7327 
      if ftype == TType.STOP:
7328 
        break
7329 
      if fid == 0:
7330 
        if ftype == TType.LIST:
7331 
          self.success = []
8590 kshitij.so 7332 
          (_etype49, _size46) = iprot.readListBegin()
7333 
          for _i50 in xrange(_size46):
7334 
            _elem51 = Item()
7335 
            _elem51.read(iprot)
7336 
            self.success.append(_elem51)
5944 mandeep.dh 7337 
          iprot.readListEnd()
7338 
        else:
7339 
          iprot.skip(ftype)
7340 
      elif fid == 1:
7341 
        if ftype == TType.STRUCT:
7342 
          self.cex = CatalogServiceException()
7343 
          self.cex.read(iprot)
7344 
        else:
7345 
          iprot.skip(ftype)
7346 
      else:
7347 
        iprot.skip(ftype)
7348 
      iprot.readFieldEnd()
7349 
    iprot.readStructEnd()
7350 
 
7351 
  def write(self, oprot):
7352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7354 
      return
7355 
    oprot.writeStructBegin('getItemsByCatalogId_result')
7356 
    if self.success is not None:
7357 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7358 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7359 
      for iter52 in self.success:
7360 
        iter52.write(oprot)
5944 mandeep.dh 7361 
      oprot.writeListEnd()
7362 
      oprot.writeFieldEnd()
7363 
    if self.cex is not None:
7364 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7365 
      self.cex.write(oprot)
7366 
      oprot.writeFieldEnd()
7367 
    oprot.writeFieldStop()
7368 
    oprot.writeStructEnd()
7369 
 
7370 
  def validate(self):
7371 
    return
7372 
 
7373 
 
7374 
  def __repr__(self):
7375 
    L = ['%s=%r' % (key, value)
7376 
      for key, value in self.__dict__.iteritems()]
7377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7378 
 
7379 
  def __eq__(self, other):
7380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7381 
 
7382 
  def __ne__(self, other):
7383 
    return not (self == other)
7384 
 
7385 
class getValidItemsByCatalogId_args:
7386 
  """
7387 
  Attributes:
7388 
   - catalog_item_id
7389 
  """
7390 
 
7391 
  thrift_spec = (
7392 
    None, # 0
7393 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7394 
  )
7395 
 
7396 
  def __init__(self, catalog_item_id=None,):
7397 
    self.catalog_item_id = catalog_item_id
7398 
 
7399 
  def read(self, iprot):
7400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7402 
      return
7403 
    iprot.readStructBegin()
7404 
    while True:
7405 
      (fname, ftype, fid) = iprot.readFieldBegin()
7406 
      if ftype == TType.STOP:
7407 
        break
7408 
      if fid == 1:
7409 
        if ftype == TType.I64:
7410 
          self.catalog_item_id = iprot.readI64();
7411 
        else:
7412 
          iprot.skip(ftype)
7413 
      else:
7414 
        iprot.skip(ftype)
7415 
      iprot.readFieldEnd()
7416 
    iprot.readStructEnd()
7417 
 
7418 
  def write(self, oprot):
7419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7421 
      return
7422 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
7423 
    if self.catalog_item_id is not None:
7424 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7425 
      oprot.writeI64(self.catalog_item_id)
7426 
      oprot.writeFieldEnd()
7427 
    oprot.writeFieldStop()
7428 
    oprot.writeStructEnd()
7429 
 
7430 
  def validate(self):
7431 
    return
7432 
 
7433 
 
7434 
  def __repr__(self):
7435 
    L = ['%s=%r' % (key, value)
7436 
      for key, value in self.__dict__.iteritems()]
7437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7438 
 
7439 
  def __eq__(self, other):
7440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7441 
 
7442 
  def __ne__(self, other):
7443 
    return not (self == other)
7444 
 
7445 
class getValidItemsByCatalogId_result:
7446 
  """
7447 
  Attributes:
7448 
   - success
7449 
   - cex
7450 
  """
7451 
 
7452 
  thrift_spec = (
7453 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7454 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7455 
  )
7456 
 
7457 
  def __init__(self, success=None, cex=None,):
7458 
    self.success = success
7459 
    self.cex = cex
7460 
 
7461 
  def read(self, iprot):
7462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7464 
      return
7465 
    iprot.readStructBegin()
7466 
    while True:
7467 
      (fname, ftype, fid) = iprot.readFieldBegin()
7468 
      if ftype == TType.STOP:
7469 
        break
7470 
      if fid == 0:
7471 
        if ftype == TType.LIST:
7472 
          self.success = []
8590 kshitij.so 7473 
          (_etype56, _size53) = iprot.readListBegin()
7474 
          for _i57 in xrange(_size53):
7475 
            _elem58 = Item()
7476 
            _elem58.read(iprot)
7477 
            self.success.append(_elem58)
5944 mandeep.dh 7478 
          iprot.readListEnd()
7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      elif fid == 1:
7482 
        if ftype == TType.STRUCT:
7483 
          self.cex = CatalogServiceException()
7484 
          self.cex.read(iprot)
7485 
        else:
7486 
          iprot.skip(ftype)
7487 
      else:
7488 
        iprot.skip(ftype)
7489 
      iprot.readFieldEnd()
7490 
    iprot.readStructEnd()
7491 
 
7492 
  def write(self, oprot):
7493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7495 
      return
7496 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7497 
    if self.success is not None:
7498 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7499 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7500 
      for iter59 in self.success:
7501 
        iter59.write(oprot)
5944 mandeep.dh 7502 
      oprot.writeListEnd()
7503 
      oprot.writeFieldEnd()
7504 
    if self.cex is not None:
7505 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7506 
      self.cex.write(oprot)
7507 
      oprot.writeFieldEnd()
7508 
    oprot.writeFieldStop()
7509 
    oprot.writeStructEnd()
7510 
 
7511 
  def validate(self):
7512 
    return
7513 
 
7514 
 
7515 
  def __repr__(self):
7516 
    L = ['%s=%r' % (key, value)
7517 
      for key, value in self.__dict__.iteritems()]
7518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7519 
 
7520 
  def __eq__(self, other):
7521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7522 
 
7523 
  def __ne__(self, other):
7524 
    return not (self == other)
7525 
 
7526 
class getAllItems_args:
7527 
  """
7528 
  Attributes:
7529 
   - isActive
7530 
  """
7531 
 
7532 
  thrift_spec = (
7533 
    None, # 0
7534 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7535 
  )
7536 
 
7537 
  def __init__(self, isActive=None,):
7538 
    self.isActive = isActive
7539 
 
7540 
  def read(self, iprot):
7541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7543 
      return
7544 
    iprot.readStructBegin()
7545 
    while True:
7546 
      (fname, ftype, fid) = iprot.readFieldBegin()
7547 
      if ftype == TType.STOP:
7548 
        break
7549 
      if fid == 1:
7550 
        if ftype == TType.BOOL:
7551 
          self.isActive = iprot.readBool();
7552 
        else:
7553 
          iprot.skip(ftype)
7554 
      else:
7555 
        iprot.skip(ftype)
7556 
      iprot.readFieldEnd()
7557 
    iprot.readStructEnd()
7558 
 
7559 
  def write(self, oprot):
7560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7562 
      return
7563 
    oprot.writeStructBegin('getAllItems_args')
7564 
    if self.isActive is not None:
7565 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7566 
      oprot.writeBool(self.isActive)
7567 
      oprot.writeFieldEnd()
7568 
    oprot.writeFieldStop()
7569 
    oprot.writeStructEnd()
7570 
 
7571 
  def validate(self):
7572 
    return
7573 
 
7574 
 
7575 
  def __repr__(self):
7576 
    L = ['%s=%r' % (key, value)
7577 
      for key, value in self.__dict__.iteritems()]
7578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7579 
 
7580 
  def __eq__(self, other):
7581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7582 
 
7583 
  def __ne__(self, other):
7584 
    return not (self == other)
7585 
 
7586 
class getAllItems_result:
7587 
  """
7588 
  Attributes:
7589 
   - success
7590 
   - cex
7591 
  """
7592 
 
7593 
  thrift_spec = (
7594 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7595 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7596 
  )
7597 
 
7598 
  def __init__(self, success=None, cex=None,):
7599 
    self.success = success
7600 
    self.cex = cex
7601 
 
7602 
  def read(self, iprot):
7603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7605 
      return
7606 
    iprot.readStructBegin()
7607 
    while True:
7608 
      (fname, ftype, fid) = iprot.readFieldBegin()
7609 
      if ftype == TType.STOP:
7610 
        break
7611 
      if fid == 0:
7612 
        if ftype == TType.LIST:
7613 
          self.success = []
8590 kshitij.so 7614 
          (_etype63, _size60) = iprot.readListBegin()
7615 
          for _i64 in xrange(_size60):
7616 
            _elem65 = Item()
7617 
            _elem65.read(iprot)
7618 
            self.success.append(_elem65)
5944 mandeep.dh 7619 
          iprot.readListEnd()
7620 
        else:
7621 
          iprot.skip(ftype)
7622 
      elif fid == 1:
7623 
        if ftype == TType.STRUCT:
7624 
          self.cex = CatalogServiceException()
7625 
          self.cex.read(iprot)
7626 
        else:
7627 
          iprot.skip(ftype)
7628 
      else:
7629 
        iprot.skip(ftype)
7630 
      iprot.readFieldEnd()
7631 
    iprot.readStructEnd()
7632 
 
7633 
  def write(self, oprot):
7634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7636 
      return
7637 
    oprot.writeStructBegin('getAllItems_result')
7638 
    if self.success is not None:
7639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7641 
      for iter66 in self.success:
7642 
        iter66.write(oprot)
5944 mandeep.dh 7643 
      oprot.writeListEnd()
7644 
      oprot.writeFieldEnd()
7645 
    if self.cex is not None:
7646 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7647 
      self.cex.write(oprot)
7648 
      oprot.writeFieldEnd()
7649 
    oprot.writeFieldStop()
7650 
    oprot.writeStructEnd()
7651 
 
7652 
  def validate(self):
7653 
    return
7654 
 
7655 
 
7656 
  def __repr__(self):
7657 
    L = ['%s=%r' % (key, value)
7658 
      for key, value in self.__dict__.iteritems()]
7659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7660 
 
7661 
  def __eq__(self, other):
7662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7663 
 
7664 
  def __ne__(self, other):
7665 
    return not (self == other)
7666 
 
7667 
class getAllItemsByStatus_args:
7668 
  """
7669 
  Attributes:
7670 
   - itemStatus
7671 
  """
7672 
 
7673 
  thrift_spec = (
7674 
    None, # 0
7675 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7676 
  )
7677 
 
7678 
  def __init__(self, itemStatus=None,):
7679 
    self.itemStatus = itemStatus
7680 
 
7681 
  def read(self, iprot):
7682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7684 
      return
7685 
    iprot.readStructBegin()
7686 
    while True:
7687 
      (fname, ftype, fid) = iprot.readFieldBegin()
7688 
      if ftype == TType.STOP:
7689 
        break
7690 
      if fid == 1:
7691 
        if ftype == TType.I32:
7692 
          self.itemStatus = iprot.readI32();
7693 
        else:
7694 
          iprot.skip(ftype)
7695 
      else:
7696 
        iprot.skip(ftype)
7697 
      iprot.readFieldEnd()
7698 
    iprot.readStructEnd()
7699 
 
7700 
  def write(self, oprot):
7701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7703 
      return
7704 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7705 
    if self.itemStatus is not None:
7706 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7707 
      oprot.writeI32(self.itemStatus)
7708 
      oprot.writeFieldEnd()
7709 
    oprot.writeFieldStop()
7710 
    oprot.writeStructEnd()
7711 
 
7712 
  def validate(self):
7713 
    return
7714 
 
7715 
 
7716 
  def __repr__(self):
7717 
    L = ['%s=%r' % (key, value)
7718 
      for key, value in self.__dict__.iteritems()]
7719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7720 
 
7721 
  def __eq__(self, other):
7722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7723 
 
7724 
  def __ne__(self, other):
7725 
    return not (self == other)
7726 
 
7727 
class getAllItemsByStatus_result:
7728 
  """
7729 
  Attributes:
7730 
   - success
7731 
   - cex
7732 
  """
7733 
 
7734 
  thrift_spec = (
7735 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7736 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7737 
  )
7738 
 
7739 
  def __init__(self, success=None, cex=None,):
7740 
    self.success = success
7741 
    self.cex = cex
7742 
 
7743 
  def read(self, iprot):
7744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7746 
      return
7747 
    iprot.readStructBegin()
7748 
    while True:
7749 
      (fname, ftype, fid) = iprot.readFieldBegin()
7750 
      if ftype == TType.STOP:
7751 
        break
7752 
      if fid == 0:
7753 
        if ftype == TType.LIST:
7754 
          self.success = []
8590 kshitij.so 7755 
          (_etype70, _size67) = iprot.readListBegin()
7756 
          for _i71 in xrange(_size67):
7757 
            _elem72 = Item()
7758 
            _elem72.read(iprot)
7759 
            self.success.append(_elem72)
5944 mandeep.dh 7760 
          iprot.readListEnd()
7761 
        else:
7762 
          iprot.skip(ftype)
7763 
      elif fid == 1:
7764 
        if ftype == TType.STRUCT:
7765 
          self.cex = CatalogServiceException()
7766 
          self.cex.read(iprot)
7767 
        else:
7768 
          iprot.skip(ftype)
7769 
      else:
7770 
        iprot.skip(ftype)
7771 
      iprot.readFieldEnd()
7772 
    iprot.readStructEnd()
7773 
 
7774 
  def write(self, oprot):
7775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7777 
      return
7778 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7779 
    if self.success is not None:
7780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7781 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7782 
      for iter73 in self.success:
7783 
        iter73.write(oprot)
5944 mandeep.dh 7784 
      oprot.writeListEnd()
7785 
      oprot.writeFieldEnd()
7786 
    if self.cex is not None:
7787 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7788 
      self.cex.write(oprot)
7789 
      oprot.writeFieldEnd()
7790 
    oprot.writeFieldStop()
7791 
    oprot.writeStructEnd()
7792 
 
7793 
  def validate(self):
7794 
    return
7795 
 
7796 
 
7797 
  def __repr__(self):
7798 
    L = ['%s=%r' % (key, value)
7799 
      for key, value in self.__dict__.iteritems()]
7800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7801 
 
7802 
  def __eq__(self, other):
7803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7804 
 
7805 
  def __ne__(self, other):
7806 
    return not (self == other)
7807 
 
7808 
class markItemAsContentComplete_args:
7809 
  """
7810 
  Attributes:
7811 
   - entityId
7812 
   - category
7813 
   - brand
7814 
   - modelName
7815 
   - modelNumber
7816 
  """
7817 
 
7818 
  thrift_spec = (
7819 
    None, # 0
7820 
    (1, TType.I64, 'entityId', None, None, ), # 1
7821 
    (2, TType.I64, 'category', None, None, ), # 2
7822 
    (3, TType.STRING, 'brand', None, None, ), # 3
7823 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7824 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7825 
  )
7826 
 
7827 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7828 
    self.entityId = entityId
7829 
    self.category = category
7830 
    self.brand = brand
7831 
    self.modelName = modelName
7832 
    self.modelNumber = modelNumber
7833 
 
7834 
  def read(self, iprot):
7835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7837 
      return
7838 
    iprot.readStructBegin()
7839 
    while True:
7840 
      (fname, ftype, fid) = iprot.readFieldBegin()
7841 
      if ftype == TType.STOP:
7842 
        break
7843 
      if fid == 1:
7844 
        if ftype == TType.I64:
7845 
          self.entityId = iprot.readI64();
7846 
        else:
7847 
          iprot.skip(ftype)
7848 
      elif fid == 2:
7849 
        if ftype == TType.I64:
7850 
          self.category = iprot.readI64();
7851 
        else:
7852 
          iprot.skip(ftype)
7853 
      elif fid == 3:
7854 
        if ftype == TType.STRING:
7855 
          self.brand = iprot.readString();
7856 
        else:
7857 
          iprot.skip(ftype)
7858 
      elif fid == 4:
7859 
        if ftype == TType.STRING:
7860 
          self.modelName = iprot.readString();
7861 
        else:
7862 
          iprot.skip(ftype)
7863 
      elif fid == 5:
7864 
        if ftype == TType.STRING:
7865 
          self.modelNumber = iprot.readString();
7866 
        else:
7867 
          iprot.skip(ftype)
7868 
      else:
7869 
        iprot.skip(ftype)
7870 
      iprot.readFieldEnd()
7871 
    iprot.readStructEnd()
7872 
 
7873 
  def write(self, oprot):
7874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7876 
      return
7877 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7878 
    if self.entityId is not None:
7879 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7880 
      oprot.writeI64(self.entityId)
7881 
      oprot.writeFieldEnd()
7882 
    if self.category is not None:
7883 
      oprot.writeFieldBegin('category', TType.I64, 2)
7884 
      oprot.writeI64(self.category)
7885 
      oprot.writeFieldEnd()
7886 
    if self.brand is not None:
7887 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7888 
      oprot.writeString(self.brand)
7889 
      oprot.writeFieldEnd()
7890 
    if self.modelName is not None:
7891 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7892 
      oprot.writeString(self.modelName)
7893 
      oprot.writeFieldEnd()
7894 
    if self.modelNumber is not None:
7895 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7896 
      oprot.writeString(self.modelNumber)
7897 
      oprot.writeFieldEnd()
7898 
    oprot.writeFieldStop()
7899 
    oprot.writeStructEnd()
7900 
 
7901 
  def validate(self):
7902 
    return
7903 
 
7904 
 
7905 
  def __repr__(self):
7906 
    L = ['%s=%r' % (key, value)
7907 
      for key, value in self.__dict__.iteritems()]
7908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7909 
 
7910 
  def __eq__(self, other):
7911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7912 
 
7913 
  def __ne__(self, other):
7914 
    return not (self == other)
7915 
 
7916 
class markItemAsContentComplete_result:
7917 
  """
7918 
  Attributes:
7919 
   - success
7920 
   - cex
7921 
  """
7922 
 
7923 
  thrift_spec = (
7924 
    (0, TType.BOOL, 'success', None, None, ), # 0
7925 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7926 
  )
7927 
 
7928 
  def __init__(self, success=None, cex=None,):
7929 
    self.success = success
7930 
    self.cex = cex
7931 
 
7932 
  def read(self, iprot):
7933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7935 
      return
7936 
    iprot.readStructBegin()
7937 
    while True:
7938 
      (fname, ftype, fid) = iprot.readFieldBegin()
7939 
      if ftype == TType.STOP:
7940 
        break
7941 
      if fid == 0:
7942 
        if ftype == TType.BOOL:
7943 
          self.success = iprot.readBool();
7944 
        else:
7945 
          iprot.skip(ftype)
7946 
      elif fid == 1:
7947 
        if ftype == TType.STRUCT:
7948 
          self.cex = CatalogServiceException()
7949 
          self.cex.read(iprot)
7950 
        else:
7951 
          iprot.skip(ftype)
7952 
      else:
7953 
        iprot.skip(ftype)
7954 
      iprot.readFieldEnd()
7955 
    iprot.readStructEnd()
7956 
 
7957 
  def write(self, oprot):
7958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7960 
      return
7961 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7962 
    if self.success is not None:
7963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7964 
      oprot.writeBool(self.success)
7965 
      oprot.writeFieldEnd()
7966 
    if self.cex is not None:
7967 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7968 
      self.cex.write(oprot)
7969 
      oprot.writeFieldEnd()
7970 
    oprot.writeFieldStop()
7971 
    oprot.writeStructEnd()
7972 
 
7973 
  def validate(self):
7974 
    return
7975 
 
7976 
 
7977 
  def __repr__(self):
7978 
    L = ['%s=%r' % (key, value)
7979 
      for key, value in self.__dict__.iteritems()]
7980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7981 
 
7982 
  def __eq__(self, other):
7983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7984 
 
7985 
  def __ne__(self, other):
7986 
    return not (self == other)
7987 
 
7988 
class getAllItemsInRange_args:
7989 
  """
7990 
  Attributes:
7991 
   - offset
7992 
   - limit
7993 
  """
7994 
 
7995 
  thrift_spec = (
7996 
    None, # 0
7997 
    (1, TType.I64, 'offset', None, None, ), # 1
7998 
    (2, TType.I64, 'limit', None, None, ), # 2
7999 
  )
8000 
 
8001 
  def __init__(self, offset=None, limit=None,):
8002 
    self.offset = offset
8003 
    self.limit = limit
8004 
 
8005 
  def read(self, iprot):
8006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8008 
      return
8009 
    iprot.readStructBegin()
8010 
    while True:
8011 
      (fname, ftype, fid) = iprot.readFieldBegin()
8012 
      if ftype == TType.STOP:
8013 
        break
8014 
      if fid == 1:
8015 
        if ftype == TType.I64:
8016 
          self.offset = iprot.readI64();
8017 
        else:
8018 
          iprot.skip(ftype)
8019 
      elif fid == 2:
8020 
        if ftype == TType.I64:
8021 
          self.limit = iprot.readI64();
8022 
        else:
8023 
          iprot.skip(ftype)
8024 
      else:
8025 
        iprot.skip(ftype)
8026 
      iprot.readFieldEnd()
8027 
    iprot.readStructEnd()
8028 
 
8029 
  def write(self, oprot):
8030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8032 
      return
8033 
    oprot.writeStructBegin('getAllItemsInRange_args')
8034 
    if self.offset is not None:
8035 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8036 
      oprot.writeI64(self.offset)
8037 
      oprot.writeFieldEnd()
8038 
    if self.limit is not None:
8039 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8040 
      oprot.writeI64(self.limit)
8041 
      oprot.writeFieldEnd()
8042 
    oprot.writeFieldStop()
8043 
    oprot.writeStructEnd()
8044 
 
8045 
  def validate(self):
8046 
    return
8047 
 
8048 
 
8049 
  def __repr__(self):
8050 
    L = ['%s=%r' % (key, value)
8051 
      for key, value in self.__dict__.iteritems()]
8052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8053 
 
8054 
  def __eq__(self, other):
8055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8056 
 
8057 
  def __ne__(self, other):
8058 
    return not (self == other)
8059 
 
8060 
class getAllItemsInRange_result:
8061 
  """
8062 
  Attributes:
8063 
   - success
8064 
   - cex
8065 
  """
8066 
 
8067 
  thrift_spec = (
8068 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8069 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8070 
  )
8071 
 
8072 
  def __init__(self, success=None, cex=None,):
8073 
    self.success = success
8074 
    self.cex = cex
8075 
 
8076 
  def read(self, iprot):
8077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8079 
      return
8080 
    iprot.readStructBegin()
8081 
    while True:
8082 
      (fname, ftype, fid) = iprot.readFieldBegin()
8083 
      if ftype == TType.STOP:
8084 
        break
8085 
      if fid == 0:
8086 
        if ftype == TType.LIST:
8087 
          self.success = []
8590 kshitij.so 8088 
          (_etype77, _size74) = iprot.readListBegin()
8089 
          for _i78 in xrange(_size74):
8090 
            _elem79 = Item()
8091 
            _elem79.read(iprot)
8092 
            self.success.append(_elem79)
5944 mandeep.dh 8093 
          iprot.readListEnd()
8094 
        else:
8095 
          iprot.skip(ftype)
8096 
      elif fid == 1:
8097 
        if ftype == TType.STRUCT:
8098 
          self.cex = CatalogServiceException()
8099 
          self.cex.read(iprot)
8100 
        else:
8101 
          iprot.skip(ftype)
8102 
      else:
8103 
        iprot.skip(ftype)
8104 
      iprot.readFieldEnd()
8105 
    iprot.readStructEnd()
8106 
 
8107 
  def write(self, oprot):
8108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8110 
      return
8111 
    oprot.writeStructBegin('getAllItemsInRange_result')
8112 
    if self.success is not None:
8113 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8114 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8115 
      for iter80 in self.success:
8116 
        iter80.write(oprot)
5944 mandeep.dh 8117 
      oprot.writeListEnd()
8118 
      oprot.writeFieldEnd()
8119 
    if self.cex is not None:
8120 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8121 
      self.cex.write(oprot)
8122 
      oprot.writeFieldEnd()
8123 
    oprot.writeFieldStop()
8124 
    oprot.writeStructEnd()
8125 
 
8126 
  def validate(self):
8127 
    return
8128 
 
8129 
 
8130 
  def __repr__(self):
8131 
    L = ['%s=%r' % (key, value)
8132 
      for key, value in self.__dict__.iteritems()]
8133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8134 
 
8135 
  def __eq__(self, other):
8136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8137 
 
8138 
  def __ne__(self, other):
8139 
    return not (self == other)
8140 
 
8141 
class getAllItemsByStatusInRange_args:
8142 
  """
8143 
  Attributes:
8144 
   - itemStatus
8145 
   - offset
8146 
   - limit
8147 
  """
8148 
 
8149 
  thrift_spec = (
8150 
    None, # 0
8151 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8152 
    (2, TType.I64, 'offset', None, None, ), # 2
8153 
    (3, TType.I64, 'limit', None, None, ), # 3
8154 
  )
8155 
 
8156 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8157 
    self.itemStatus = itemStatus
8158 
    self.offset = offset
8159 
    self.limit = limit
8160 
 
8161 
  def read(self, iprot):
8162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8164 
      return
8165 
    iprot.readStructBegin()
8166 
    while True:
8167 
      (fname, ftype, fid) = iprot.readFieldBegin()
8168 
      if ftype == TType.STOP:
8169 
        break
8170 
      if fid == 1:
8171 
        if ftype == TType.I32:
8172 
          self.itemStatus = iprot.readI32();
8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      elif fid == 2:
8176 
        if ftype == TType.I64:
8177 
          self.offset = iprot.readI64();
8178 
        else:
8179 
          iprot.skip(ftype)
8180 
      elif fid == 3:
8181 
        if ftype == TType.I64:
8182 
          self.limit = iprot.readI64();
8183 
        else:
8184 
          iprot.skip(ftype)
8185 
      else:
8186 
        iprot.skip(ftype)
8187 
      iprot.readFieldEnd()
8188 
    iprot.readStructEnd()
8189 
 
8190 
  def write(self, oprot):
8191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8193 
      return
8194 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8195 
    if self.itemStatus is not None:
8196 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8197 
      oprot.writeI32(self.itemStatus)
8198 
      oprot.writeFieldEnd()
8199 
    if self.offset is not None:
8200 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8201 
      oprot.writeI64(self.offset)
8202 
      oprot.writeFieldEnd()
8203 
    if self.limit is not None:
8204 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8205 
      oprot.writeI64(self.limit)
8206 
      oprot.writeFieldEnd()
8207 
    oprot.writeFieldStop()
8208 
    oprot.writeStructEnd()
8209 
 
8210 
  def validate(self):
8211 
    return
8212 
 
8213 
 
8214 
  def __repr__(self):
8215 
    L = ['%s=%r' % (key, value)
8216 
      for key, value in self.__dict__.iteritems()]
8217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8218 
 
8219 
  def __eq__(self, other):
8220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8221 
 
8222 
  def __ne__(self, other):
8223 
    return not (self == other)
8224 
 
8225 
class getAllItemsByStatusInRange_result:
8226 
  """
8227 
  Attributes:
8228 
   - success
8229 
   - cex
8230 
  """
8231 
 
8232 
  thrift_spec = (
8233 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8234 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8235 
  )
8236 
 
8237 
  def __init__(self, success=None, cex=None,):
8238 
    self.success = success
8239 
    self.cex = cex
8240 
 
8241 
  def read(self, iprot):
8242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8244 
      return
8245 
    iprot.readStructBegin()
8246 
    while True:
8247 
      (fname, ftype, fid) = iprot.readFieldBegin()
8248 
      if ftype == TType.STOP:
8249 
        break
8250 
      if fid == 0:
8251 
        if ftype == TType.LIST:
8252 
          self.success = []
8590 kshitij.so 8253 
          (_etype84, _size81) = iprot.readListBegin()
8254 
          for _i85 in xrange(_size81):
8255 
            _elem86 = Item()
8256 
            _elem86.read(iprot)
8257 
            self.success.append(_elem86)
5944 mandeep.dh 8258 
          iprot.readListEnd()
8259 
        else:
8260 
          iprot.skip(ftype)
8261 
      elif fid == 1:
8262 
        if ftype == TType.STRUCT:
8263 
          self.cex = CatalogServiceException()
8264 
          self.cex.read(iprot)
8265 
        else:
8266 
          iprot.skip(ftype)
8267 
      else:
8268 
        iprot.skip(ftype)
8269 
      iprot.readFieldEnd()
8270 
    iprot.readStructEnd()
8271 
 
8272 
  def write(self, oprot):
8273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8275 
      return
8276 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8277 
    if self.success is not None:
8278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8279 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8280 
      for iter87 in self.success:
8281 
        iter87.write(oprot)
5944 mandeep.dh 8282 
      oprot.writeListEnd()
8283 
      oprot.writeFieldEnd()
8284 
    if self.cex is not None:
8285 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8286 
      self.cex.write(oprot)
8287 
      oprot.writeFieldEnd()
8288 
    oprot.writeFieldStop()
8289 
    oprot.writeStructEnd()
8290 
 
8291 
  def validate(self):
8292 
    return
8293 
 
8294 
 
8295 
  def __repr__(self):
8296 
    L = ['%s=%r' % (key, value)
8297 
      for key, value in self.__dict__.iteritems()]
8298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8299 
 
8300 
  def __eq__(self, other):
8301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8302 
 
8303 
  def __ne__(self, other):
8304 
    return not (self == other)
8305 
 
8306 
class getItemCountByStatus_args:
8307 
  """
8308 
  Attributes:
8309 
   - useStatus
8310 
   - itemStatus
8311 
  """
8312 
 
8313 
  thrift_spec = (
8314 
    None, # 0
8315 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8316 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8317 
  )
8318 
 
8319 
  def __init__(self, useStatus=None, itemStatus=None,):
8320 
    self.useStatus = useStatus
8321 
    self.itemStatus = itemStatus
8322 
 
8323 
  def read(self, iprot):
8324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8326 
      return
8327 
    iprot.readStructBegin()
8328 
    while True:
8329 
      (fname, ftype, fid) = iprot.readFieldBegin()
8330 
      if ftype == TType.STOP:
8331 
        break
8332 
      if fid == 1:
8333 
        if ftype == TType.BOOL:
8334 
          self.useStatus = iprot.readBool();
8335 
        else:
8336 
          iprot.skip(ftype)
8337 
      elif fid == 2:
8338 
        if ftype == TType.I32:
8339 
          self.itemStatus = iprot.readI32();
8340 
        else:
8341 
          iprot.skip(ftype)
8342 
      else:
8343 
        iprot.skip(ftype)
8344 
      iprot.readFieldEnd()
8345 
    iprot.readStructEnd()
8346 
 
8347 
  def write(self, oprot):
8348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8350 
      return
8351 
    oprot.writeStructBegin('getItemCountByStatus_args')
8352 
    if self.useStatus is not None:
8353 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8354 
      oprot.writeBool(self.useStatus)
8355 
      oprot.writeFieldEnd()
8356 
    if self.itemStatus is not None:
8357 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8358 
      oprot.writeI32(self.itemStatus)
8359 
      oprot.writeFieldEnd()
8360 
    oprot.writeFieldStop()
8361 
    oprot.writeStructEnd()
8362 
 
8363 
  def validate(self):
8364 
    return
8365 
 
8366 
 
8367 
  def __repr__(self):
8368 
    L = ['%s=%r' % (key, value)
8369 
      for key, value in self.__dict__.iteritems()]
8370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8371 
 
8372 
  def __eq__(self, other):
8373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8374 
 
8375 
  def __ne__(self, other):
8376 
    return not (self == other)
8377 
 
8378 
class getItemCountByStatus_result:
8379 
  """
8380 
  Attributes:
8381 
   - success
8382 
  """
8383 
 
8384 
  thrift_spec = (
8385 
    (0, TType.I32, 'success', None, None, ), # 0
8386 
  )
8387 
 
8388 
  def __init__(self, success=None,):
8389 
    self.success = success
8390 
 
8391 
  def read(self, iprot):
8392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8394 
      return
8395 
    iprot.readStructBegin()
8396 
    while True:
8397 
      (fname, ftype, fid) = iprot.readFieldBegin()
8398 
      if ftype == TType.STOP:
8399 
        break
8400 
      if fid == 0:
8401 
        if ftype == TType.I32:
8402 
          self.success = iprot.readI32();
8403 
        else:
8404 
          iprot.skip(ftype)
8405 
      else:
8406 
        iprot.skip(ftype)
8407 
      iprot.readFieldEnd()
8408 
    iprot.readStructEnd()
8409 
 
8410 
  def write(self, oprot):
8411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8413 
      return
8414 
    oprot.writeStructBegin('getItemCountByStatus_result')
8415 
    if self.success is not None:
8416 
      oprot.writeFieldBegin('success', TType.I32, 0)
8417 
      oprot.writeI32(self.success)
8418 
      oprot.writeFieldEnd()
8419 
    oprot.writeFieldStop()
8420 
    oprot.writeStructEnd()
8421 
 
8422 
  def validate(self):
8423 
    return
8424 
 
8425 
 
8426 
  def __repr__(self):
8427 
    L = ['%s=%r' % (key, value)
8428 
      for key, value in self.__dict__.iteritems()]
8429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8430 
 
8431 
  def __eq__(self, other):
8432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8433 
 
8434 
  def __ne__(self, other):
8435 
    return not (self == other)
8436 
 
8437 
class getBestSellers_args:
8438 
 
8439 
  thrift_spec = (
8440 
  )
8441 
 
8442 
  def read(self, iprot):
8443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8445 
      return
8446 
    iprot.readStructBegin()
8447 
    while True:
8448 
      (fname, ftype, fid) = iprot.readFieldBegin()
8449 
      if ftype == TType.STOP:
8450 
        break
8451 
      else:
8452 
        iprot.skip(ftype)
8453 
      iprot.readFieldEnd()
8454 
    iprot.readStructEnd()
8455 
 
8456 
  def write(self, oprot):
8457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8459 
      return
8460 
    oprot.writeStructBegin('getBestSellers_args')
8461 
    oprot.writeFieldStop()
8462 
    oprot.writeStructEnd()
8463 
 
8464 
  def validate(self):
8465 
    return
8466 
 
8467 
 
8468 
  def __repr__(self):
8469 
    L = ['%s=%r' % (key, value)
8470 
      for key, value in self.__dict__.iteritems()]
8471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8472 
 
8473 
  def __eq__(self, other):
8474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8475 
 
8476 
  def __ne__(self, other):
8477 
    return not (self == other)
8478 
 
8479 
class getBestSellers_result:
8480 
  """
8481 
  Attributes:
8482 
   - success
8483 
   - isex
8484 
  """
8485 
 
8486 
  thrift_spec = (
8487 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8488 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8489 
  )
8490 
 
8491 
  def __init__(self, success=None, isex=None,):
8492 
    self.success = success
8493 
    self.isex = isex
8494 
 
8495 
  def read(self, iprot):
8496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8498 
      return
8499 
    iprot.readStructBegin()
8500 
    while True:
8501 
      (fname, ftype, fid) = iprot.readFieldBegin()
8502 
      if ftype == TType.STOP:
8503 
        break
8504 
      if fid == 0:
8505 
        if ftype == TType.LIST:
8506 
          self.success = []
8590 kshitij.so 8507 
          (_etype91, _size88) = iprot.readListBegin()
8508 
          for _i92 in xrange(_size88):
8509 
            _elem93 = Item()
8510 
            _elem93.read(iprot)
8511 
            self.success.append(_elem93)
5944 mandeep.dh 8512 
          iprot.readListEnd()
8513 
        else:
8514 
          iprot.skip(ftype)
8515 
      elif fid == 1:
8516 
        if ftype == TType.STRUCT:
8517 
          self.isex = CatalogServiceException()
8518 
          self.isex.read(iprot)
8519 
        else:
8520 
          iprot.skip(ftype)
8521 
      else:
8522 
        iprot.skip(ftype)
8523 
      iprot.readFieldEnd()
8524 
    iprot.readStructEnd()
8525 
 
8526 
  def write(self, oprot):
8527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8529 
      return
8530 
    oprot.writeStructBegin('getBestSellers_result')
8531 
    if self.success is not None:
8532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8533 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8534 
      for iter94 in self.success:
8535 
        iter94.write(oprot)
5944 mandeep.dh 8536 
      oprot.writeListEnd()
8537 
      oprot.writeFieldEnd()
8538 
    if self.isex is not None:
8539 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8540 
      self.isex.write(oprot)
8541 
      oprot.writeFieldEnd()
8542 
    oprot.writeFieldStop()
8543 
    oprot.writeStructEnd()
8544 
 
8545 
  def validate(self):
8546 
    return
8547 
 
8548 
 
8549 
  def __repr__(self):
8550 
    L = ['%s=%r' % (key, value)
8551 
      for key, value in self.__dict__.iteritems()]
8552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8553 
 
8554 
  def __eq__(self, other):
8555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8556 
 
8557 
  def __ne__(self, other):
8558 
    return not (self == other)
8559 
 
8560 
class getBestSellersCatalogIds_args:
8561 
  """
8562 
  Attributes:
8563 
   - beginIndex
8564 
   - totalItems
8565 
   - brand
8566 
   - category
8567 
  """
8568 
 
8569 
  thrift_spec = (
8570 
    None, # 0
8571 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8572 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8573 
    (3, TType.STRING, 'brand', None, None, ), # 3
8574 
    (4, TType.I64, 'category', None, None, ), # 4
8575 
  )
8576 
 
8577 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8578 
    self.beginIndex = beginIndex
8579 
    self.totalItems = totalItems
8580 
    self.brand = brand
8581 
    self.category = category
8582 
 
8583 
  def read(self, iprot):
8584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8586 
      return
8587 
    iprot.readStructBegin()
8588 
    while True:
8589 
      (fname, ftype, fid) = iprot.readFieldBegin()
8590 
      if ftype == TType.STOP:
8591 
        break
8592 
      if fid == 1:
8593 
        if ftype == TType.I64:
8594 
          self.beginIndex = iprot.readI64();
8595 
        else:
8596 
          iprot.skip(ftype)
8597 
      elif fid == 2:
8598 
        if ftype == TType.I64:
8599 
          self.totalItems = iprot.readI64();
8600 
        else:
8601 
          iprot.skip(ftype)
8602 
      elif fid == 3:
8603 
        if ftype == TType.STRING:
8604 
          self.brand = iprot.readString();
8605 
        else:
8606 
          iprot.skip(ftype)
8607 
      elif fid == 4:
8608 
        if ftype == TType.I64:
8609 
          self.category = iprot.readI64();
8610 
        else:
8611 
          iprot.skip(ftype)
8612 
      else:
8613 
        iprot.skip(ftype)
8614 
      iprot.readFieldEnd()
8615 
    iprot.readStructEnd()
8616 
 
8617 
  def write(self, oprot):
8618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8620 
      return
8621 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8622 
    if self.beginIndex is not None:
8623 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8624 
      oprot.writeI64(self.beginIndex)
8625 
      oprot.writeFieldEnd()
8626 
    if self.totalItems is not None:
8627 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8628 
      oprot.writeI64(self.totalItems)
8629 
      oprot.writeFieldEnd()
8630 
    if self.brand is not None:
8631 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8632 
      oprot.writeString(self.brand)
8633 
      oprot.writeFieldEnd()
8634 
    if self.category is not None:
8635 
      oprot.writeFieldBegin('category', TType.I64, 4)
8636 
      oprot.writeI64(self.category)
8637 
      oprot.writeFieldEnd()
8638 
    oprot.writeFieldStop()
8639 
    oprot.writeStructEnd()
8640 
 
8641 
  def validate(self):
8642 
    return
8643 
 
8644 
 
8645 
  def __repr__(self):
8646 
    L = ['%s=%r' % (key, value)
8647 
      for key, value in self.__dict__.iteritems()]
8648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8649 
 
8650 
  def __eq__(self, other):
8651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8652 
 
8653 
  def __ne__(self, other):
8654 
    return not (self == other)
8655 
 
8656 
class getBestSellersCatalogIds_result:
8657 
  """
8658 
  Attributes:
8659 
   - success
8660 
   - cex
8661 
  """
8662 
 
8663 
  thrift_spec = (
8664 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8665 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8666 
  )
8667 
 
8668 
  def __init__(self, success=None, cex=None,):
8669 
    self.success = success
8670 
    self.cex = cex
8671 
 
8672 
  def read(self, iprot):
8673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8675 
      return
8676 
    iprot.readStructBegin()
8677 
    while True:
8678 
      (fname, ftype, fid) = iprot.readFieldBegin()
8679 
      if ftype == TType.STOP:
8680 
        break
8681 
      if fid == 0:
8682 
        if ftype == TType.LIST:
8683 
          self.success = []
8590 kshitij.so 8684 
          (_etype98, _size95) = iprot.readListBegin()
8685 
          for _i99 in xrange(_size95):
8686 
            _elem100 = iprot.readI64();
8687 
            self.success.append(_elem100)
5944 mandeep.dh 8688 
          iprot.readListEnd()
8689 
        else:
8690 
          iprot.skip(ftype)
8691 
      elif fid == 1:
8692 
        if ftype == TType.STRUCT:
8693 
          self.cex = CatalogServiceException()
8694 
          self.cex.read(iprot)
8695 
        else:
8696 
          iprot.skip(ftype)
8697 
      else:
8698 
        iprot.skip(ftype)
8699 
      iprot.readFieldEnd()
8700 
    iprot.readStructEnd()
8701 
 
8702 
  def write(self, oprot):
8703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8705 
      return
8706 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8707 
    if self.success is not None:
8708 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8709 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 8710 
      for iter101 in self.success:
8711 
        oprot.writeI64(iter101)
5944 mandeep.dh 8712 
      oprot.writeListEnd()
8713 
      oprot.writeFieldEnd()
8714 
    if self.cex is not None:
8715 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8716 
      self.cex.write(oprot)
8717 
      oprot.writeFieldEnd()
8718 
    oprot.writeFieldStop()
8719 
    oprot.writeStructEnd()
8720 
 
8721 
  def validate(self):
8722 
    return
8723 
 
8724 
 
8725 
  def __repr__(self):
8726 
    L = ['%s=%r' % (key, value)
8727 
      for key, value in self.__dict__.iteritems()]
8728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8729 
 
8730 
  def __eq__(self, other):
8731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8732 
 
8733 
  def __ne__(self, other):
8734 
    return not (self == other)
8735 
 
8736 
class getBestSellersCount_args:
8737 
 
8738 
  thrift_spec = (
8739 
  )
8740 
 
8741 
  def read(self, iprot):
8742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8744 
      return
8745 
    iprot.readStructBegin()
8746 
    while True:
8747 
      (fname, ftype, fid) = iprot.readFieldBegin()
8748 
      if ftype == TType.STOP:
8749 
        break
8750 
      else:
8751 
        iprot.skip(ftype)
8752 
      iprot.readFieldEnd()
8753 
    iprot.readStructEnd()
8754 
 
8755 
  def write(self, oprot):
8756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8758 
      return
8759 
    oprot.writeStructBegin('getBestSellersCount_args')
8760 
    oprot.writeFieldStop()
8761 
    oprot.writeStructEnd()
8762 
 
8763 
  def validate(self):
8764 
    return
8765 
 
8766 
 
8767 
  def __repr__(self):
8768 
    L = ['%s=%r' % (key, value)
8769 
      for key, value in self.__dict__.iteritems()]
8770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8771 
 
8772 
  def __eq__(self, other):
8773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8774 
 
8775 
  def __ne__(self, other):
8776 
    return not (self == other)
8777 
 
8778 
class getBestSellersCount_result:
8779 
  """
8780 
  Attributes:
8781 
   - success
8782 
   - cex
8783 
  """
8784 
 
8785 
  thrift_spec = (
8786 
    (0, TType.I64, 'success', None, None, ), # 0
8787 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8788 
  )
8789 
 
8790 
  def __init__(self, success=None, cex=None,):
8791 
    self.success = success
8792 
    self.cex = cex
8793 
 
8794 
  def read(self, iprot):
8795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8797 
      return
8798 
    iprot.readStructBegin()
8799 
    while True:
8800 
      (fname, ftype, fid) = iprot.readFieldBegin()
8801 
      if ftype == TType.STOP:
8802 
        break
8803 
      if fid == 0:
8804 
        if ftype == TType.I64:
8805 
          self.success = iprot.readI64();
8806 
        else:
8807 
          iprot.skip(ftype)
8808 
      elif fid == 1:
8809 
        if ftype == TType.STRUCT:
8810 
          self.cex = CatalogServiceException()
8811 
          self.cex.read(iprot)
8812 
        else:
8813 
          iprot.skip(ftype)
8814 
      else:
8815 
        iprot.skip(ftype)
8816 
      iprot.readFieldEnd()
8817 
    iprot.readStructEnd()
8818 
 
8819 
  def write(self, oprot):
8820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8822 
      return
8823 
    oprot.writeStructBegin('getBestSellersCount_result')
8824 
    if self.success is not None:
8825 
      oprot.writeFieldBegin('success', TType.I64, 0)
8826 
      oprot.writeI64(self.success)
8827 
      oprot.writeFieldEnd()
8828 
    if self.cex is not None:
8829 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8830 
      self.cex.write(oprot)
8831 
      oprot.writeFieldEnd()
8832 
    oprot.writeFieldStop()
8833 
    oprot.writeStructEnd()
8834 
 
8835 
  def validate(self):
8836 
    return
8837 
 
8838 
 
8839 
  def __repr__(self):
8840 
    L = ['%s=%r' % (key, value)
8841 
      for key, value in self.__dict__.iteritems()]
8842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8843 
 
8844 
  def __eq__(self, other):
8845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8846 
 
8847 
  def __ne__(self, other):
8848 
    return not (self == other)
8849 
 
8850 
class getBestDeals_args:
8851 
 
8852 
  thrift_spec = (
8853 
  )
8854 
 
8855 
  def read(self, iprot):
8856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8858 
      return
8859 
    iprot.readStructBegin()
8860 
    while True:
8861 
      (fname, ftype, fid) = iprot.readFieldBegin()
8862 
      if ftype == TType.STOP:
8863 
        break
8864 
      else:
8865 
        iprot.skip(ftype)
8866 
      iprot.readFieldEnd()
8867 
    iprot.readStructEnd()
8868 
 
8869 
  def write(self, oprot):
8870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8872 
      return
8873 
    oprot.writeStructBegin('getBestDeals_args')
8874 
    oprot.writeFieldStop()
8875 
    oprot.writeStructEnd()
8876 
 
8877 
  def validate(self):
8878 
    return
8879 
 
8880 
 
8881 
  def __repr__(self):
8882 
    L = ['%s=%r' % (key, value)
8883 
      for key, value in self.__dict__.iteritems()]
8884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8885 
 
8886 
  def __eq__(self, other):
8887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8888 
 
8889 
  def __ne__(self, other):
8890 
    return not (self == other)
8891 
 
8892 
class getBestDeals_result:
8893 
  """
8894 
  Attributes:
8895 
   - success
8896 
   - isex
8897 
  """
8898 
 
8899 
  thrift_spec = (
8900 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8901 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8902 
  )
8903 
 
8904 
  def __init__(self, success=None, isex=None,):
8905 
    self.success = success
8906 
    self.isex = isex
8907 
 
8908 
  def read(self, iprot):
8909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8911 
      return
8912 
    iprot.readStructBegin()
8913 
    while True:
8914 
      (fname, ftype, fid) = iprot.readFieldBegin()
8915 
      if ftype == TType.STOP:
8916 
        break
8917 
      if fid == 0:
8918 
        if ftype == TType.LIST:
8919 
          self.success = []
8590 kshitij.so 8920 
          (_etype105, _size102) = iprot.readListBegin()
8921 
          for _i106 in xrange(_size102):
8922 
            _elem107 = Item()
8923 
            _elem107.read(iprot)
8924 
            self.success.append(_elem107)
5944 mandeep.dh 8925 
          iprot.readListEnd()
8926 
        else:
8927 
          iprot.skip(ftype)
8928 
      elif fid == 1:
8929 
        if ftype == TType.STRUCT:
8930 
          self.isex = CatalogServiceException()
8931 
          self.isex.read(iprot)
8932 
        else:
8933 
          iprot.skip(ftype)
8934 
      else:
8935 
        iprot.skip(ftype)
8936 
      iprot.readFieldEnd()
8937 
    iprot.readStructEnd()
8938 
 
8939 
  def write(self, oprot):
8940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8942 
      return
8943 
    oprot.writeStructBegin('getBestDeals_result')
8944 
    if self.success is not None:
8945 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8946 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8947 
      for iter108 in self.success:
8948 
        iter108.write(oprot)
5944 mandeep.dh 8949 
      oprot.writeListEnd()
8950 
      oprot.writeFieldEnd()
8951 
    if self.isex is not None:
8952 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8953 
      self.isex.write(oprot)
8954 
      oprot.writeFieldEnd()
8955 
    oprot.writeFieldStop()
8956 
    oprot.writeStructEnd()
8957 
 
8958 
  def validate(self):
8959 
    return
8960 
 
8961 
 
8962 
  def __repr__(self):
8963 
    L = ['%s=%r' % (key, value)
8964 
      for key, value in self.__dict__.iteritems()]
8965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8966 
 
8967 
  def __eq__(self, other):
8968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8969 
 
8970 
  def __ne__(self, other):
8971 
    return not (self == other)
8972 
 
8973 
class getBestDealsCatalogIds_args:
8974 
  """
8975 
  Attributes:
8976 
   - beginIndex
8977 
   - totalItems
8978 
   - brand
8979 
   - category
8980 
  """
8981 
 
8982 
  thrift_spec = (
8983 
    None, # 0
8984 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8985 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8986 
    (3, TType.STRING, 'brand', None, None, ), # 3
8987 
    (4, TType.I64, 'category', None, None, ), # 4
8988 
  )
8989 
 
8990 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8991 
    self.beginIndex = beginIndex
8992 
    self.totalItems = totalItems
8993 
    self.brand = brand
8994 
    self.category = category
8995 
 
8996 
  def read(self, iprot):
8997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8999 
      return
9000 
    iprot.readStructBegin()
9001 
    while True:
9002 
      (fname, ftype, fid) = iprot.readFieldBegin()
9003 
      if ftype == TType.STOP:
9004 
        break
9005 
      if fid == 1:
9006 
        if ftype == TType.I64:
9007 
          self.beginIndex = iprot.readI64();
9008 
        else:
9009 
          iprot.skip(ftype)
9010 
      elif fid == 2:
9011 
        if ftype == TType.I64:
9012 
          self.totalItems = iprot.readI64();
9013 
        else:
9014 
          iprot.skip(ftype)
9015 
      elif fid == 3:
9016 
        if ftype == TType.STRING:
9017 
          self.brand = iprot.readString();
9018 
        else:
9019 
          iprot.skip(ftype)
9020 
      elif fid == 4:
9021 
        if ftype == TType.I64:
9022 
          self.category = iprot.readI64();
9023 
        else:
9024 
          iprot.skip(ftype)
9025 
      else:
9026 
        iprot.skip(ftype)
9027 
      iprot.readFieldEnd()
9028 
    iprot.readStructEnd()
9029 
 
9030 
  def write(self, oprot):
9031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9033 
      return
9034 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9035 
    if self.beginIndex is not None:
9036 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9037 
      oprot.writeI64(self.beginIndex)
9038 
      oprot.writeFieldEnd()
9039 
    if self.totalItems is not None:
9040 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9041 
      oprot.writeI64(self.totalItems)
9042 
      oprot.writeFieldEnd()
9043 
    if self.brand is not None:
9044 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9045 
      oprot.writeString(self.brand)
9046 
      oprot.writeFieldEnd()
9047 
    if self.category is not None:
9048 
      oprot.writeFieldBegin('category', TType.I64, 4)
9049 
      oprot.writeI64(self.category)
9050 
      oprot.writeFieldEnd()
9051 
    oprot.writeFieldStop()
9052 
    oprot.writeStructEnd()
9053 
 
9054 
  def validate(self):
9055 
    return
9056 
 
9057 
 
9058 
  def __repr__(self):
9059 
    L = ['%s=%r' % (key, value)
9060 
      for key, value in self.__dict__.iteritems()]
9061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9062 
 
9063 
  def __eq__(self, other):
9064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9065 
 
9066 
  def __ne__(self, other):
9067 
    return not (self == other)
9068 
 
9069 
class getBestDealsCatalogIds_result:
9070 
  """
9071 
  Attributes:
9072 
   - success
9073 
   - cex
9074 
  """
9075 
 
9076 
  thrift_spec = (
9077 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9078 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9079 
  )
9080 
 
9081 
  def __init__(self, success=None, cex=None,):
9082 
    self.success = success
9083 
    self.cex = cex
9084 
 
9085 
  def read(self, iprot):
9086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9088 
      return
9089 
    iprot.readStructBegin()
9090 
    while True:
9091 
      (fname, ftype, fid) = iprot.readFieldBegin()
9092 
      if ftype == TType.STOP:
9093 
        break
9094 
      if fid == 0:
9095 
        if ftype == TType.LIST:
9096 
          self.success = []
8590 kshitij.so 9097 
          (_etype112, _size109) = iprot.readListBegin()
9098 
          for _i113 in xrange(_size109):
9099 
            _elem114 = iprot.readI64();
9100 
            self.success.append(_elem114)
5944 mandeep.dh 9101 
          iprot.readListEnd()
9102 
        else:
9103 
          iprot.skip(ftype)
9104 
      elif fid == 1:
9105 
        if ftype == TType.STRUCT:
9106 
          self.cex = CatalogServiceException()
9107 
          self.cex.read(iprot)
9108 
        else:
9109 
          iprot.skip(ftype)
9110 
      else:
9111 
        iprot.skip(ftype)
9112 
      iprot.readFieldEnd()
9113 
    iprot.readStructEnd()
9114 
 
9115 
  def write(self, oprot):
9116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9118 
      return
9119 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9120 
    if self.success is not None:
9121 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9122 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9123 
      for iter115 in self.success:
9124 
        oprot.writeI64(iter115)
5944 mandeep.dh 9125 
      oprot.writeListEnd()
9126 
      oprot.writeFieldEnd()
9127 
    if self.cex is not None:
9128 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9129 
      self.cex.write(oprot)
9130 
      oprot.writeFieldEnd()
9131 
    oprot.writeFieldStop()
9132 
    oprot.writeStructEnd()
9133 
 
9134 
  def validate(self):
9135 
    return
9136 
 
9137 
 
9138 
  def __repr__(self):
9139 
    L = ['%s=%r' % (key, value)
9140 
      for key, value in self.__dict__.iteritems()]
9141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9142 
 
9143 
  def __eq__(self, other):
9144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9145 
 
9146 
  def __ne__(self, other):
9147 
    return not (self == other)
9148 
 
9149 
class getBestDealsCount_args:
9150 
 
9151 
  thrift_spec = (
9152 
  )
9153 
 
9154 
  def read(self, iprot):
9155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9157 
      return
9158 
    iprot.readStructBegin()
9159 
    while True:
9160 
      (fname, ftype, fid) = iprot.readFieldBegin()
9161 
      if ftype == TType.STOP:
9162 
        break
9163 
      else:
9164 
        iprot.skip(ftype)
9165 
      iprot.readFieldEnd()
9166 
    iprot.readStructEnd()
9167 
 
9168 
  def write(self, oprot):
9169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9171 
      return
9172 
    oprot.writeStructBegin('getBestDealsCount_args')
9173 
    oprot.writeFieldStop()
9174 
    oprot.writeStructEnd()
9175 
 
9176 
  def validate(self):
9177 
    return
9178 
 
9179 
 
9180 
  def __repr__(self):
9181 
    L = ['%s=%r' % (key, value)
9182 
      for key, value in self.__dict__.iteritems()]
9183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9184 
 
9185 
  def __eq__(self, other):
9186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9187 
 
9188 
  def __ne__(self, other):
9189 
    return not (self == other)
9190 
 
9191 
class getBestDealsCount_result:
9192 
  """
9193 
  Attributes:
9194 
   - success
9195 
   - cex
9196 
  """
9197 
 
9198 
  thrift_spec = (
9199 
    (0, TType.I64, 'success', None, None, ), # 0
9200 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9201 
  )
9202 
 
9203 
  def __init__(self, success=None, cex=None,):
9204 
    self.success = success
9205 
    self.cex = cex
9206 
 
9207 
  def read(self, iprot):
9208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9210 
      return
9211 
    iprot.readStructBegin()
9212 
    while True:
9213 
      (fname, ftype, fid) = iprot.readFieldBegin()
9214 
      if ftype == TType.STOP:
9215 
        break
9216 
      if fid == 0:
9217 
        if ftype == TType.I64:
9218 
          self.success = iprot.readI64();
9219 
        else:
9220 
          iprot.skip(ftype)
9221 
      elif fid == 1:
9222 
        if ftype == TType.STRUCT:
9223 
          self.cex = CatalogServiceException()
9224 
          self.cex.read(iprot)
9225 
        else:
9226 
          iprot.skip(ftype)
9227 
      else:
9228 
        iprot.skip(ftype)
9229 
      iprot.readFieldEnd()
9230 
    iprot.readStructEnd()
9231 
 
9232 
  def write(self, oprot):
9233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9235 
      return
9236 
    oprot.writeStructBegin('getBestDealsCount_result')
9237 
    if self.success is not None:
9238 
      oprot.writeFieldBegin('success', TType.I64, 0)
9239 
      oprot.writeI64(self.success)
9240 
      oprot.writeFieldEnd()
9241 
    if self.cex is not None:
9242 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9243 
      self.cex.write(oprot)
9244 
      oprot.writeFieldEnd()
9245 
    oprot.writeFieldStop()
9246 
    oprot.writeStructEnd()
9247 
 
9248 
  def validate(self):
9249 
    return
9250 
 
9251 
 
9252 
  def __repr__(self):
9253 
    L = ['%s=%r' % (key, value)
9254 
      for key, value in self.__dict__.iteritems()]
9255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9256 
 
9257 
  def __eq__(self, other):
9258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9259 
 
9260 
  def __ne__(self, other):
9261 
    return not (self == other)
9262 
 
9263 
class getComingSoon_args:
9264 
 
9265 
  thrift_spec = (
9266 
  )
9267 
 
9268 
  def read(self, iprot):
9269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9271 
      return
9272 
    iprot.readStructBegin()
9273 
    while True:
9274 
      (fname, ftype, fid) = iprot.readFieldBegin()
9275 
      if ftype == TType.STOP:
9276 
        break
9277 
      else:
9278 
        iprot.skip(ftype)
9279 
      iprot.readFieldEnd()
9280 
    iprot.readStructEnd()
9281 
 
9282 
  def write(self, oprot):
9283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9285 
      return
9286 
    oprot.writeStructBegin('getComingSoon_args')
9287 
    oprot.writeFieldStop()
9288 
    oprot.writeStructEnd()
9289 
 
9290 
  def validate(self):
9291 
    return
9292 
 
9293 
 
9294 
  def __repr__(self):
9295 
    L = ['%s=%r' % (key, value)
9296 
      for key, value in self.__dict__.iteritems()]
9297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9298 
 
9299 
  def __eq__(self, other):
9300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9301 
 
9302 
  def __ne__(self, other):
9303 
    return not (self == other)
9304 
 
9305 
class getComingSoon_result:
9306 
  """
9307 
  Attributes:
9308 
   - success
9309 
   - isex
9310 
  """
9311 
 
9312 
  thrift_spec = (
9313 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9314 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9315 
  )
9316 
 
9317 
  def __init__(self, success=None, isex=None,):
9318 
    self.success = success
9319 
    self.isex = isex
9320 
 
9321 
  def read(self, iprot):
9322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9324 
      return
9325 
    iprot.readStructBegin()
9326 
    while True:
9327 
      (fname, ftype, fid) = iprot.readFieldBegin()
9328 
      if ftype == TType.STOP:
9329 
        break
9330 
      if fid == 0:
9331 
        if ftype == TType.LIST:
9332 
          self.success = []
8590 kshitij.so 9333 
          (_etype119, _size116) = iprot.readListBegin()
9334 
          for _i120 in xrange(_size116):
9335 
            _elem121 = Item()
9336 
            _elem121.read(iprot)
9337 
            self.success.append(_elem121)
5944 mandeep.dh 9338 
          iprot.readListEnd()
9339 
        else:
9340 
          iprot.skip(ftype)
9341 
      elif fid == 1:
9342 
        if ftype == TType.STRUCT:
9343 
          self.isex = CatalogServiceException()
9344 
          self.isex.read(iprot)
9345 
        else:
9346 
          iprot.skip(ftype)
9347 
      else:
9348 
        iprot.skip(ftype)
9349 
      iprot.readFieldEnd()
9350 
    iprot.readStructEnd()
9351 
 
9352 
  def write(self, oprot):
9353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9355 
      return
9356 
    oprot.writeStructBegin('getComingSoon_result')
9357 
    if self.success is not None:
9358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9359 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9360 
      for iter122 in self.success:
9361 
        iter122.write(oprot)
5944 mandeep.dh 9362 
      oprot.writeListEnd()
9363 
      oprot.writeFieldEnd()
9364 
    if self.isex is not None:
9365 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9366 
      self.isex.write(oprot)
9367 
      oprot.writeFieldEnd()
9368 
    oprot.writeFieldStop()
9369 
    oprot.writeStructEnd()
9370 
 
9371 
  def validate(self):
9372 
    return
9373 
 
9374 
 
9375 
  def __repr__(self):
9376 
    L = ['%s=%r' % (key, value)
9377 
      for key, value in self.__dict__.iteritems()]
9378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9379 
 
9380 
  def __eq__(self, other):
9381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9382 
 
9383 
  def __ne__(self, other):
9384 
    return not (self == other)
9385 
 
9386 
class getComingSoonCatalogIds_args:
9387 
  """
9388 
  Attributes:
9389 
   - beginIndex
9390 
   - totalItems
9391 
   - brand
9392 
   - category
9393 
  """
9394 
 
9395 
  thrift_spec = (
9396 
    None, # 0
9397 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9398 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9399 
    (3, TType.STRING, 'brand', None, None, ), # 3
9400 
    (4, TType.I64, 'category', None, None, ), # 4
9401 
  )
9402 
 
9403 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9404 
    self.beginIndex = beginIndex
9405 
    self.totalItems = totalItems
9406 
    self.brand = brand
9407 
    self.category = category
9408 
 
9409 
  def read(self, iprot):
9410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9412 
      return
9413 
    iprot.readStructBegin()
9414 
    while True:
9415 
      (fname, ftype, fid) = iprot.readFieldBegin()
9416 
      if ftype == TType.STOP:
9417 
        break
9418 
      if fid == 1:
9419 
        if ftype == TType.I64:
9420 
          self.beginIndex = iprot.readI64();
9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      elif fid == 2:
9424 
        if ftype == TType.I64:
9425 
          self.totalItems = iprot.readI64();
9426 
        else:
9427 
          iprot.skip(ftype)
9428 
      elif fid == 3:
9429 
        if ftype == TType.STRING:
9430 
          self.brand = iprot.readString();
9431 
        else:
9432 
          iprot.skip(ftype)
9433 
      elif fid == 4:
9434 
        if ftype == TType.I64:
9435 
          self.category = iprot.readI64();
9436 
        else:
9437 
          iprot.skip(ftype)
9438 
      else:
9439 
        iprot.skip(ftype)
9440 
      iprot.readFieldEnd()
9441 
    iprot.readStructEnd()
9442 
 
9443 
  def write(self, oprot):
9444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9446 
      return
9447 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9448 
    if self.beginIndex is not None:
9449 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9450 
      oprot.writeI64(self.beginIndex)
9451 
      oprot.writeFieldEnd()
9452 
    if self.totalItems is not None:
9453 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9454 
      oprot.writeI64(self.totalItems)
9455 
      oprot.writeFieldEnd()
9456 
    if self.brand is not None:
9457 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9458 
      oprot.writeString(self.brand)
9459 
      oprot.writeFieldEnd()
9460 
    if self.category is not None:
9461 
      oprot.writeFieldBegin('category', TType.I64, 4)
9462 
      oprot.writeI64(self.category)
9463 
      oprot.writeFieldEnd()
9464 
    oprot.writeFieldStop()
9465 
    oprot.writeStructEnd()
9466 
 
9467 
  def validate(self):
9468 
    return
9469 
 
9470 
 
9471 
  def __repr__(self):
9472 
    L = ['%s=%r' % (key, value)
9473 
      for key, value in self.__dict__.iteritems()]
9474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9475 
 
9476 
  def __eq__(self, other):
9477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9478 
 
9479 
  def __ne__(self, other):
9480 
    return not (self == other)
9481 
 
9482 
class getComingSoonCatalogIds_result:
9483 
  """
9484 
  Attributes:
9485 
   - success
9486 
   - cex
9487 
  """
9488 
 
9489 
  thrift_spec = (
9490 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9491 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9492 
  )
9493 
 
9494 
  def __init__(self, success=None, cex=None,):
9495 
    self.success = success
9496 
    self.cex = cex
9497 
 
9498 
  def read(self, iprot):
9499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9501 
      return
9502 
    iprot.readStructBegin()
9503 
    while True:
9504 
      (fname, ftype, fid) = iprot.readFieldBegin()
9505 
      if ftype == TType.STOP:
9506 
        break
9507 
      if fid == 0:
9508 
        if ftype == TType.LIST:
9509 
          self.success = []
8590 kshitij.so 9510 
          (_etype126, _size123) = iprot.readListBegin()
9511 
          for _i127 in xrange(_size123):
9512 
            _elem128 = iprot.readI64();
9513 
            self.success.append(_elem128)
5944 mandeep.dh 9514 
          iprot.readListEnd()
9515 
        else:
9516 
          iprot.skip(ftype)
9517 
      elif fid == 1:
9518 
        if ftype == TType.STRUCT:
9519 
          self.cex = CatalogServiceException()
9520 
          self.cex.read(iprot)
9521 
        else:
9522 
          iprot.skip(ftype)
9523 
      else:
9524 
        iprot.skip(ftype)
9525 
      iprot.readFieldEnd()
9526 
    iprot.readStructEnd()
9527 
 
9528 
  def write(self, oprot):
9529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9531 
      return
9532 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9533 
    if self.success is not None:
9534 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9535 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9536 
      for iter129 in self.success:
9537 
        oprot.writeI64(iter129)
5944 mandeep.dh 9538 
      oprot.writeListEnd()
9539 
      oprot.writeFieldEnd()
9540 
    if self.cex is not None:
9541 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9542 
      self.cex.write(oprot)
9543 
      oprot.writeFieldEnd()
9544 
    oprot.writeFieldStop()
9545 
    oprot.writeStructEnd()
9546 
 
9547 
  def validate(self):
9548 
    return
9549 
 
9550 
 
9551 
  def __repr__(self):
9552 
    L = ['%s=%r' % (key, value)
9553 
      for key, value in self.__dict__.iteritems()]
9554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9555 
 
9556 
  def __eq__(self, other):
9557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9558 
 
9559 
  def __ne__(self, other):
9560 
    return not (self == other)
9561 
 
9562 
class getComingSoonCount_args:
9563 
 
9564 
  thrift_spec = (
9565 
  )
9566 
 
9567 
  def read(self, iprot):
9568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9570 
      return
9571 
    iprot.readStructBegin()
9572 
    while True:
9573 
      (fname, ftype, fid) = iprot.readFieldBegin()
9574 
      if ftype == TType.STOP:
9575 
        break
9576 
      else:
9577 
        iprot.skip(ftype)
9578 
      iprot.readFieldEnd()
9579 
    iprot.readStructEnd()
9580 
 
9581 
  def write(self, oprot):
9582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9584 
      return
9585 
    oprot.writeStructBegin('getComingSoonCount_args')
9586 
    oprot.writeFieldStop()
9587 
    oprot.writeStructEnd()
9588 
 
9589 
  def validate(self):
9590 
    return
9591 
 
9592 
 
9593 
  def __repr__(self):
9594 
    L = ['%s=%r' % (key, value)
9595 
      for key, value in self.__dict__.iteritems()]
9596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9597 
 
9598 
  def __eq__(self, other):
9599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9600 
 
9601 
  def __ne__(self, other):
9602 
    return not (self == other)
9603 
 
9604 
class getComingSoonCount_result:
9605 
  """
9606 
  Attributes:
9607 
   - success
9608 
   - cex
9609 
  """
9610 
 
9611 
  thrift_spec = (
9612 
    (0, TType.I64, 'success', None, None, ), # 0
9613 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9614 
  )
9615 
 
9616 
  def __init__(self, success=None, cex=None,):
9617 
    self.success = success
9618 
    self.cex = cex
9619 
 
9620 
  def read(self, iprot):
9621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9623 
      return
9624 
    iprot.readStructBegin()
9625 
    while True:
9626 
      (fname, ftype, fid) = iprot.readFieldBegin()
9627 
      if ftype == TType.STOP:
9628 
        break
9629 
      if fid == 0:
9630 
        if ftype == TType.I64:
9631 
          self.success = iprot.readI64();
9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      elif fid == 1:
9635 
        if ftype == TType.STRUCT:
9636 
          self.cex = CatalogServiceException()
9637 
          self.cex.read(iprot)
9638 
        else:
9639 
          iprot.skip(ftype)
9640 
      else:
9641 
        iprot.skip(ftype)
9642 
      iprot.readFieldEnd()
9643 
    iprot.readStructEnd()
9644 
 
9645 
  def write(self, oprot):
9646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9648 
      return
9649 
    oprot.writeStructBegin('getComingSoonCount_result')
9650 
    if self.success is not None:
9651 
      oprot.writeFieldBegin('success', TType.I64, 0)
9652 
      oprot.writeI64(self.success)
9653 
      oprot.writeFieldEnd()
9654 
    if self.cex is not None:
9655 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9656 
      self.cex.write(oprot)
9657 
      oprot.writeFieldEnd()
9658 
    oprot.writeFieldStop()
9659 
    oprot.writeStructEnd()
9660 
 
9661 
  def validate(self):
9662 
    return
9663 
 
9664 
 
9665 
  def __repr__(self):
9666 
    L = ['%s=%r' % (key, value)
9667 
      for key, value in self.__dict__.iteritems()]
9668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9669 
 
9670 
  def __eq__(self, other):
9671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9672 
 
9673 
  def __ne__(self, other):
9674 
    return not (self == other)
9675 
 
9676 
class getLatestArrivals_args:
9677 
 
9678 
  thrift_spec = (
9679 
  )
9680 
 
9681 
  def read(self, iprot):
9682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9684 
      return
9685 
    iprot.readStructBegin()
9686 
    while True:
9687 
      (fname, ftype, fid) = iprot.readFieldBegin()
9688 
      if ftype == TType.STOP:
9689 
        break
9690 
      else:
9691 
        iprot.skip(ftype)
9692 
      iprot.readFieldEnd()
9693 
    iprot.readStructEnd()
9694 
 
9695 
  def write(self, oprot):
9696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9698 
      return
9699 
    oprot.writeStructBegin('getLatestArrivals_args')
9700 
    oprot.writeFieldStop()
9701 
    oprot.writeStructEnd()
9702 
 
9703 
  def validate(self):
9704 
    return
9705 
 
9706 
 
9707 
  def __repr__(self):
9708 
    L = ['%s=%r' % (key, value)
9709 
      for key, value in self.__dict__.iteritems()]
9710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9711 
 
9712 
  def __eq__(self, other):
9713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9714 
 
9715 
  def __ne__(self, other):
9716 
    return not (self == other)
9717 
 
9718 
class getLatestArrivals_result:
9719 
  """
9720 
  Attributes:
9721 
   - success
9722 
   - isex
9723 
  """
9724 
 
9725 
  thrift_spec = (
9726 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9727 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9728 
  )
9729 
 
9730 
  def __init__(self, success=None, isex=None,):
9731 
    self.success = success
9732 
    self.isex = isex
9733 
 
9734 
  def read(self, iprot):
9735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9737 
      return
9738 
    iprot.readStructBegin()
9739 
    while True:
9740 
      (fname, ftype, fid) = iprot.readFieldBegin()
9741 
      if ftype == TType.STOP:
9742 
        break
9743 
      if fid == 0:
9744 
        if ftype == TType.LIST:
9745 
          self.success = []
8590 kshitij.so 9746 
          (_etype133, _size130) = iprot.readListBegin()
9747 
          for _i134 in xrange(_size130):
9748 
            _elem135 = Item()
9749 
            _elem135.read(iprot)
9750 
            self.success.append(_elem135)
5944 mandeep.dh 9751 
          iprot.readListEnd()
9752 
        else:
9753 
          iprot.skip(ftype)
9754 
      elif fid == 1:
9755 
        if ftype == TType.STRUCT:
9756 
          self.isex = CatalogServiceException()
9757 
          self.isex.read(iprot)
9758 
        else:
9759 
          iprot.skip(ftype)
9760 
      else:
9761 
        iprot.skip(ftype)
9762 
      iprot.readFieldEnd()
9763 
    iprot.readStructEnd()
9764 
 
9765 
  def write(self, oprot):
9766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9768 
      return
9769 
    oprot.writeStructBegin('getLatestArrivals_result')
9770 
    if self.success is not None:
9771 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9772 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9773 
      for iter136 in self.success:
9774 
        iter136.write(oprot)
5944 mandeep.dh 9775 
      oprot.writeListEnd()
9776 
      oprot.writeFieldEnd()
9777 
    if self.isex is not None:
9778 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9779 
      self.isex.write(oprot)
9780 
      oprot.writeFieldEnd()
9781 
    oprot.writeFieldStop()
9782 
    oprot.writeStructEnd()
9783 
 
9784 
  def validate(self):
9785 
    return
9786 
 
9787 
 
9788 
  def __repr__(self):
9789 
    L = ['%s=%r' % (key, value)
9790 
      for key, value in self.__dict__.iteritems()]
9791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9792 
 
9793 
  def __eq__(self, other):
9794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9795 
 
9796 
  def __ne__(self, other):
9797 
    return not (self == other)
9798 
 
9799 
class getLatestArrivalsCatalogIds_args:
9800 
  """
9801 
  Attributes:
9802 
   - beginIndex
9803 
   - totalItems
9804 
   - brand
9805 
   - categories
9806 
  """
9807 
 
9808 
  thrift_spec = (
9809 
    None, # 0
9810 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9811 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9812 
    (3, TType.STRING, 'brand', None, None, ), # 3
9813 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9814 
  )
9815 
 
9816 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9817 
    self.beginIndex = beginIndex
9818 
    self.totalItems = totalItems
9819 
    self.brand = brand
9820 
    self.categories = categories
9821 
 
9822 
  def read(self, iprot):
9823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9825 
      return
9826 
    iprot.readStructBegin()
9827 
    while True:
9828 
      (fname, ftype, fid) = iprot.readFieldBegin()
9829 
      if ftype == TType.STOP:
9830 
        break
9831 
      if fid == 1:
9832 
        if ftype == TType.I64:
9833 
          self.beginIndex = iprot.readI64();
9834 
        else:
9835 
          iprot.skip(ftype)
9836 
      elif fid == 2:
9837 
        if ftype == TType.I64:
9838 
          self.totalItems = iprot.readI64();
9839 
        else:
9840 
          iprot.skip(ftype)
9841 
      elif fid == 3:
9842 
        if ftype == TType.STRING:
9843 
          self.brand = iprot.readString();
9844 
        else:
9845 
          iprot.skip(ftype)
9846 
      elif fid == 4:
9847 
        if ftype == TType.LIST:
9848 
          self.categories = []
8590 kshitij.so 9849 
          (_etype140, _size137) = iprot.readListBegin()
9850 
          for _i141 in xrange(_size137):
9851 
            _elem142 = iprot.readI64();
9852 
            self.categories.append(_elem142)
5944 mandeep.dh 9853 
          iprot.readListEnd()
9854 
        else:
9855 
          iprot.skip(ftype)
9856 
      else:
9857 
        iprot.skip(ftype)
9858 
      iprot.readFieldEnd()
9859 
    iprot.readStructEnd()
9860 
 
9861 
  def write(self, oprot):
9862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9864 
      return
9865 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9866 
    if self.beginIndex is not None:
9867 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9868 
      oprot.writeI64(self.beginIndex)
9869 
      oprot.writeFieldEnd()
9870 
    if self.totalItems is not None:
9871 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9872 
      oprot.writeI64(self.totalItems)
9873 
      oprot.writeFieldEnd()
9874 
    if self.brand is not None:
9875 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9876 
      oprot.writeString(self.brand)
9877 
      oprot.writeFieldEnd()
9878 
    if self.categories is not None:
9879 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9880 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 9881 
      for iter143 in self.categories:
9882 
        oprot.writeI64(iter143)
5944 mandeep.dh 9883 
      oprot.writeListEnd()
9884 
      oprot.writeFieldEnd()
9885 
    oprot.writeFieldStop()
9886 
    oprot.writeStructEnd()
9887 
 
9888 
  def validate(self):
9889 
    return
9890 
 
9891 
 
9892 
  def __repr__(self):
9893 
    L = ['%s=%r' % (key, value)
9894 
      for key, value in self.__dict__.iteritems()]
9895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9896 
 
9897 
  def __eq__(self, other):
9898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9899 
 
9900 
  def __ne__(self, other):
9901 
    return not (self == other)
9902 
 
9903 
class getLatestArrivalsCatalogIds_result:
9904 
  """
9905 
  Attributes:
9906 
   - success
9907 
   - cex
9908 
  """
9909 
 
9910 
  thrift_spec = (
9911 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9912 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9913 
  )
9914 
 
9915 
  def __init__(self, success=None, cex=None,):
9916 
    self.success = success
9917 
    self.cex = cex
9918 
 
9919 
  def read(self, iprot):
9920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9922 
      return
9923 
    iprot.readStructBegin()
9924 
    while True:
9925 
      (fname, ftype, fid) = iprot.readFieldBegin()
9926 
      if ftype == TType.STOP:
9927 
        break
9928 
      if fid == 0:
9929 
        if ftype == TType.LIST:
9930 
          self.success = []
8590 kshitij.so 9931 
          (_etype147, _size144) = iprot.readListBegin()
9932 
          for _i148 in xrange(_size144):
9933 
            _elem149 = iprot.readI64();
9934 
            self.success.append(_elem149)
5944 mandeep.dh 9935 
          iprot.readListEnd()
9936 
        else:
9937 
          iprot.skip(ftype)
9938 
      elif fid == 1:
9939 
        if ftype == TType.STRUCT:
9940 
          self.cex = CatalogServiceException()
9941 
          self.cex.read(iprot)
9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      else:
9945 
        iprot.skip(ftype)
9946 
      iprot.readFieldEnd()
9947 
    iprot.readStructEnd()
9948 
 
9949 
  def write(self, oprot):
9950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9952 
      return
9953 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9954 
    if self.success is not None:
9955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9956 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9957 
      for iter150 in self.success:
9958 
        oprot.writeI64(iter150)
5944 mandeep.dh 9959 
      oprot.writeListEnd()
9960 
      oprot.writeFieldEnd()
9961 
    if self.cex is not None:
9962 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9963 
      self.cex.write(oprot)
9964 
      oprot.writeFieldEnd()
9965 
    oprot.writeFieldStop()
9966 
    oprot.writeStructEnd()
9967 
 
9968 
  def validate(self):
9969 
    return
9970 
 
9971 
 
9972 
  def __repr__(self):
9973 
    L = ['%s=%r' % (key, value)
9974 
      for key, value in self.__dict__.iteritems()]
9975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9976 
 
9977 
  def __eq__(self, other):
9978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9979 
 
9980 
  def __ne__(self, other):
9981 
    return not (self == other)
9982 
 
9983 
class getLatestArrivalsCount_args:
9984 
 
9985 
  thrift_spec = (
9986 
  )
9987 
 
9988 
  def read(self, iprot):
9989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9991 
      return
9992 
    iprot.readStructBegin()
9993 
    while True:
9994 
      (fname, ftype, fid) = iprot.readFieldBegin()
9995 
      if ftype == TType.STOP:
9996 
        break
9997 
      else:
9998 
        iprot.skip(ftype)
9999 
      iprot.readFieldEnd()
10000 
    iprot.readStructEnd()
10001 
 
10002 
  def write(self, oprot):
10003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10005 
      return
10006 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10007 
    oprot.writeFieldStop()
10008 
    oprot.writeStructEnd()
10009 
 
10010 
  def validate(self):
10011 
    return
10012 
 
10013 
 
10014 
  def __repr__(self):
10015 
    L = ['%s=%r' % (key, value)
10016 
      for key, value in self.__dict__.iteritems()]
10017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10018 
 
10019 
  def __eq__(self, other):
10020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10021 
 
10022 
  def __ne__(self, other):
10023 
    return not (self == other)
10024 
 
10025 
class getLatestArrivalsCount_result:
10026 
  """
10027 
  Attributes:
10028 
   - success
10029 
   - cex
10030 
  """
10031 
 
10032 
  thrift_spec = (
10033 
    (0, TType.I64, 'success', None, None, ), # 0
10034 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10035 
  )
10036 
 
10037 
  def __init__(self, success=None, cex=None,):
10038 
    self.success = success
10039 
    self.cex = cex
10040 
 
10041 
  def read(self, iprot):
10042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10044 
      return
10045 
    iprot.readStructBegin()
10046 
    while True:
10047 
      (fname, ftype, fid) = iprot.readFieldBegin()
10048 
      if ftype == TType.STOP:
10049 
        break
10050 
      if fid == 0:
10051 
        if ftype == TType.I64:
10052 
          self.success = iprot.readI64();
10053 
        else:
10054 
          iprot.skip(ftype)
10055 
      elif fid == 1:
10056 
        if ftype == TType.STRUCT:
10057 
          self.cex = CatalogServiceException()
10058 
          self.cex.read(iprot)
10059 
        else:
10060 
          iprot.skip(ftype)
10061 
      else:
10062 
        iprot.skip(ftype)
10063 
      iprot.readFieldEnd()
10064 
    iprot.readStructEnd()
10065 
 
10066 
  def write(self, oprot):
10067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10069 
      return
10070 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10071 
    if self.success is not None:
10072 
      oprot.writeFieldBegin('success', TType.I64, 0)
10073 
      oprot.writeI64(self.success)
10074 
      oprot.writeFieldEnd()
10075 
    if self.cex is not None:
10076 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10077 
      self.cex.write(oprot)
10078 
      oprot.writeFieldEnd()
10079 
    oprot.writeFieldStop()
10080 
    oprot.writeStructEnd()
10081 
 
10082 
  def validate(self):
10083 
    return
10084 
 
10085 
 
10086 
  def __repr__(self):
10087 
    L = ['%s=%r' % (key, value)
10088 
      for key, value in self.__dict__.iteritems()]
10089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10090 
 
10091 
  def __eq__(self, other):
10092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10093 
 
10094 
  def __ne__(self, other):
10095 
    return not (self == other)
10096 
 
10097 
class generateNewEntityID_args:
10098 
 
10099 
  thrift_spec = (
10100 
  )
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      else:
10112 
        iprot.skip(ftype)
10113 
      iprot.readFieldEnd()
10114 
    iprot.readStructEnd()
10115 
 
10116 
  def write(self, oprot):
10117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10119 
      return
10120 
    oprot.writeStructBegin('generateNewEntityID_args')
10121 
    oprot.writeFieldStop()
10122 
    oprot.writeStructEnd()
10123 
 
10124 
  def validate(self):
10125 
    return
10126 
 
10127 
 
10128 
  def __repr__(self):
10129 
    L = ['%s=%r' % (key, value)
10130 
      for key, value in self.__dict__.iteritems()]
10131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10132 
 
10133 
  def __eq__(self, other):
10134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10135 
 
10136 
  def __ne__(self, other):
10137 
    return not (self == other)
10138 
 
10139 
class generateNewEntityID_result:
10140 
  """
10141 
  Attributes:
10142 
   - success
10143 
  """
10144 
 
10145 
  thrift_spec = (
10146 
    (0, TType.I64, 'success', None, None, ), # 0
10147 
  )
10148 
 
10149 
  def __init__(self, success=None,):
10150 
    self.success = success
10151 
 
10152 
  def read(self, iprot):
10153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10155 
      return
10156 
    iprot.readStructBegin()
10157 
    while True:
10158 
      (fname, ftype, fid) = iprot.readFieldBegin()
10159 
      if ftype == TType.STOP:
10160 
        break
10161 
      if fid == 0:
10162 
        if ftype == TType.I64:
10163 
          self.success = iprot.readI64();
10164 
        else:
10165 
          iprot.skip(ftype)
10166 
      else:
10167 
        iprot.skip(ftype)
10168 
      iprot.readFieldEnd()
10169 
    iprot.readStructEnd()
10170 
 
10171 
  def write(self, oprot):
10172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10174 
      return
10175 
    oprot.writeStructBegin('generateNewEntityID_result')
10176 
    if self.success is not None:
10177 
      oprot.writeFieldBegin('success', TType.I64, 0)
10178 
      oprot.writeI64(self.success)
10179 
      oprot.writeFieldEnd()
10180 
    oprot.writeFieldStop()
10181 
    oprot.writeStructEnd()
10182 
 
10183 
  def validate(self):
10184 
    return
10185 
 
10186 
 
10187 
  def __repr__(self):
10188 
    L = ['%s=%r' % (key, value)
10189 
      for key, value in self.__dict__.iteritems()]
10190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10191 
 
10192 
  def __eq__(self, other):
10193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10194 
 
10195 
  def __ne__(self, other):
10196 
    return not (self == other)
10197 
 
10198 
class addCategory_args:
10199 
  """
10200 
  Attributes:
10201 
   - category
10202 
  """
10203 
 
10204 
  thrift_spec = (
10205 
    None, # 0
10206 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10207 
  )
10208 
 
10209 
  def __init__(self, category=None,):
10210 
    self.category = category
10211 
 
10212 
  def read(self, iprot):
10213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10215 
      return
10216 
    iprot.readStructBegin()
10217 
    while True:
10218 
      (fname, ftype, fid) = iprot.readFieldBegin()
10219 
      if ftype == TType.STOP:
10220 
        break
10221 
      if fid == 1:
10222 
        if ftype == TType.STRUCT:
10223 
          self.category = Category()
10224 
          self.category.read(iprot)
10225 
        else:
10226 
          iprot.skip(ftype)
10227 
      else:
10228 
        iprot.skip(ftype)
10229 
      iprot.readFieldEnd()
10230 
    iprot.readStructEnd()
10231 
 
10232 
  def write(self, oprot):
10233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10235 
      return
10236 
    oprot.writeStructBegin('addCategory_args')
10237 
    if self.category is not None:
10238 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10239 
      self.category.write(oprot)
10240 
      oprot.writeFieldEnd()
10241 
    oprot.writeFieldStop()
10242 
    oprot.writeStructEnd()
10243 
 
10244 
  def validate(self):
10245 
    return
10246 
 
10247 
 
10248 
  def __repr__(self):
10249 
    L = ['%s=%r' % (key, value)
10250 
      for key, value in self.__dict__.iteritems()]
10251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10252 
 
10253 
  def __eq__(self, other):
10254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10255 
 
10256 
  def __ne__(self, other):
10257 
    return not (self == other)
10258 
 
10259 
class addCategory_result:
10260 
  """
10261 
  Attributes:
10262 
   - success
10263 
  """
10264 
 
10265 
  thrift_spec = (
10266 
    (0, TType.BOOL, 'success', None, None, ), # 0
10267 
  )
10268 
 
10269 
  def __init__(self, success=None,):
10270 
    self.success = success
10271 
 
10272 
  def read(self, iprot):
10273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10275 
      return
10276 
    iprot.readStructBegin()
10277 
    while True:
10278 
      (fname, ftype, fid) = iprot.readFieldBegin()
10279 
      if ftype == TType.STOP:
10280 
        break
10281 
      if fid == 0:
10282 
        if ftype == TType.BOOL:
10283 
          self.success = iprot.readBool();
10284 
        else:
10285 
          iprot.skip(ftype)
10286 
      else:
10287 
        iprot.skip(ftype)
10288 
      iprot.readFieldEnd()
10289 
    iprot.readStructEnd()
10290 
 
10291 
  def write(self, oprot):
10292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10294 
      return
10295 
    oprot.writeStructBegin('addCategory_result')
10296 
    if self.success is not None:
10297 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10298 
      oprot.writeBool(self.success)
10299 
      oprot.writeFieldEnd()
10300 
    oprot.writeFieldStop()
10301 
    oprot.writeStructEnd()
10302 
 
10303 
  def validate(self):
10304 
    return
10305 
 
10306 
 
10307 
  def __repr__(self):
10308 
    L = ['%s=%r' % (key, value)
10309 
      for key, value in self.__dict__.iteritems()]
10310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10311 
 
10312 
  def __eq__(self, other):
10313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10314 
 
10315 
  def __ne__(self, other):
10316 
    return not (self == other)
10317 
 
10318 
class getCategory_args:
10319 
  """
10320 
  Attributes:
10321 
   - id
10322 
  """
10323 
 
10324 
  thrift_spec = (
10325 
    None, # 0
10326 
    (1, TType.I64, 'id', None, None, ), # 1
10327 
  )
10328 
 
10329 
  def __init__(self, id=None,):
10330 
    self.id = id
10331 
 
10332 
  def read(self, iprot):
10333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10335 
      return
10336 
    iprot.readStructBegin()
10337 
    while True:
10338 
      (fname, ftype, fid) = iprot.readFieldBegin()
10339 
      if ftype == TType.STOP:
10340 
        break
10341 
      if fid == 1:
10342 
        if ftype == TType.I64:
10343 
          self.id = iprot.readI64();
10344 
        else:
10345 
          iprot.skip(ftype)
10346 
      else:
10347 
        iprot.skip(ftype)
10348 
      iprot.readFieldEnd()
10349 
    iprot.readStructEnd()
10350 
 
10351 
  def write(self, oprot):
10352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10354 
      return
10355 
    oprot.writeStructBegin('getCategory_args')
10356 
    if self.id is not None:
10357 
      oprot.writeFieldBegin('id', TType.I64, 1)
10358 
      oprot.writeI64(self.id)
10359 
      oprot.writeFieldEnd()
10360 
    oprot.writeFieldStop()
10361 
    oprot.writeStructEnd()
10362 
 
10363 
  def validate(self):
10364 
    return
10365 
 
10366 
 
10367 
  def __repr__(self):
10368 
    L = ['%s=%r' % (key, value)
10369 
      for key, value in self.__dict__.iteritems()]
10370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10371 
 
10372 
  def __eq__(self, other):
10373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10374 
 
10375 
  def __ne__(self, other):
10376 
    return not (self == other)
10377 
 
10378 
class getCategory_result:
10379 
  """
10380 
  Attributes:
10381 
   - success
10382 
  """
10383 
 
10384 
  thrift_spec = (
10385 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
10386 
  )
10387 
 
10388 
  def __init__(self, success=None,):
10389 
    self.success = success
10390 
 
10391 
  def read(self, iprot):
10392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10394 
      return
10395 
    iprot.readStructBegin()
10396 
    while True:
10397 
      (fname, ftype, fid) = iprot.readFieldBegin()
10398 
      if ftype == TType.STOP:
10399 
        break
10400 
      if fid == 0:
10401 
        if ftype == TType.STRUCT:
10402 
          self.success = Category()
10403 
          self.success.read(iprot)
10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      else:
10407 
        iprot.skip(ftype)
10408 
      iprot.readFieldEnd()
10409 
    iprot.readStructEnd()
10410 
 
10411 
  def write(self, oprot):
10412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10414 
      return
10415 
    oprot.writeStructBegin('getCategory_result')
10416 
    if self.success is not None:
10417 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10418 
      self.success.write(oprot)
10419 
      oprot.writeFieldEnd()
10420 
    oprot.writeFieldStop()
10421 
    oprot.writeStructEnd()
10422 
 
10423 
  def validate(self):
10424 
    return
10425 
 
10426 
 
10427 
  def __repr__(self):
10428 
    L = ['%s=%r' % (key, value)
10429 
      for key, value in self.__dict__.iteritems()]
10430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10431 
 
10432 
  def __eq__(self, other):
10433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10434 
 
10435 
  def __ne__(self, other):
10436 
    return not (self == other)
10437 
 
10438 
class getAllCategories_args:
10439 
 
10440 
  thrift_spec = (
10441 
  )
10442 
 
10443 
  def read(self, iprot):
10444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10446 
      return
10447 
    iprot.readStructBegin()
10448 
    while True:
10449 
      (fname, ftype, fid) = iprot.readFieldBegin()
10450 
      if ftype == TType.STOP:
10451 
        break
10452 
      else:
10453 
        iprot.skip(ftype)
10454 
      iprot.readFieldEnd()
10455 
    iprot.readStructEnd()
10456 
 
10457 
  def write(self, oprot):
10458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10460 
      return
10461 
    oprot.writeStructBegin('getAllCategories_args')
10462 
    oprot.writeFieldStop()
10463 
    oprot.writeStructEnd()
10464 
 
10465 
  def validate(self):
10466 
    return
10467 
 
10468 
 
10469 
  def __repr__(self):
10470 
    L = ['%s=%r' % (key, value)
10471 
      for key, value in self.__dict__.iteritems()]
10472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10473 
 
10474 
  def __eq__(self, other):
10475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10476 
 
10477 
  def __ne__(self, other):
10478 
    return not (self == other)
10479 
 
10480 
class getAllCategories_result:
10481 
  """
10482 
  Attributes:
10483 
   - success
10484 
  """
10485 
 
10486 
  thrift_spec = (
10487 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10488 
  )
10489 
 
10490 
  def __init__(self, success=None,):
10491 
    self.success = success
10492 
 
10493 
  def read(self, iprot):
10494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10496 
      return
10497 
    iprot.readStructBegin()
10498 
    while True:
10499 
      (fname, ftype, fid) = iprot.readFieldBegin()
10500 
      if ftype == TType.STOP:
10501 
        break
10502 
      if fid == 0:
10503 
        if ftype == TType.LIST:
10504 
          self.success = []
8590 kshitij.so 10505 
          (_etype154, _size151) = iprot.readListBegin()
10506 
          for _i155 in xrange(_size151):
10507 
            _elem156 = Category()
10508 
            _elem156.read(iprot)
10509 
            self.success.append(_elem156)
5944 mandeep.dh 10510 
          iprot.readListEnd()
10511 
        else:
10512 
          iprot.skip(ftype)
10513 
      else:
10514 
        iprot.skip(ftype)
10515 
      iprot.readFieldEnd()
10516 
    iprot.readStructEnd()
10517 
 
10518 
  def write(self, oprot):
10519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10521 
      return
10522 
    oprot.writeStructBegin('getAllCategories_result')
10523 
    if self.success is not None:
10524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10526 
      for iter157 in self.success:
10527 
        iter157.write(oprot)
5944 mandeep.dh 10528 
      oprot.writeListEnd()
10529 
      oprot.writeFieldEnd()
10530 
    oprot.writeFieldStop()
10531 
    oprot.writeStructEnd()
10532 
 
10533 
  def validate(self):
10534 
    return
10535 
 
10536 
 
10537 
  def __repr__(self):
10538 
    L = ['%s=%r' % (key, value)
10539 
      for key, value in self.__dict__.iteritems()]
10540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10541 
 
10542 
  def __eq__(self, other):
10543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10544 
 
10545 
  def __ne__(self, other):
10546 
    return not (self == other)
10547 
 
10548 
class getAllSimilarItems_args:
10549 
  """
10550 
  Attributes:
10551 
   - itemId
10552 
  """
10553 
 
10554 
  thrift_spec = (
10555 
    None, # 0
10556 
    (1, TType.I64, 'itemId', None, None, ), # 1
10557 
  )
10558 
 
10559 
  def __init__(self, itemId=None,):
10560 
    self.itemId = itemId
10561 
 
10562 
  def read(self, iprot):
10563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10565 
      return
10566 
    iprot.readStructBegin()
10567 
    while True:
10568 
      (fname, ftype, fid) = iprot.readFieldBegin()
10569 
      if ftype == TType.STOP:
10570 
        break
10571 
      if fid == 1:
10572 
        if ftype == TType.I64:
10573 
          self.itemId = iprot.readI64();
10574 
        else:
10575 
          iprot.skip(ftype)
10576 
      else:
10577 
        iprot.skip(ftype)
10578 
      iprot.readFieldEnd()
10579 
    iprot.readStructEnd()
10580 
 
10581 
  def write(self, oprot):
10582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10584 
      return
10585 
    oprot.writeStructBegin('getAllSimilarItems_args')
10586 
    if self.itemId is not None:
10587 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10588 
      oprot.writeI64(self.itemId)
10589 
      oprot.writeFieldEnd()
10590 
    oprot.writeFieldStop()
10591 
    oprot.writeStructEnd()
10592 
 
10593 
  def validate(self):
10594 
    return
10595 
 
10596 
 
10597 
  def __repr__(self):
10598 
    L = ['%s=%r' % (key, value)
10599 
      for key, value in self.__dict__.iteritems()]
10600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10601 
 
10602 
  def __eq__(self, other):
10603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10604 
 
10605 
  def __ne__(self, other):
10606 
    return not (self == other)
10607 
 
10608 
class getAllSimilarItems_result:
10609 
  """
10610 
  Attributes:
10611 
   - success
10612 
  """
10613 
 
10614 
  thrift_spec = (
10615 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10616 
  )
10617 
 
10618 
  def __init__(self, success=None,):
10619 
    self.success = success
10620 
 
10621 
  def read(self, iprot):
10622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10624 
      return
10625 
    iprot.readStructBegin()
10626 
    while True:
10627 
      (fname, ftype, fid) = iprot.readFieldBegin()
10628 
      if ftype == TType.STOP:
10629 
        break
10630 
      if fid == 0:
10631 
        if ftype == TType.LIST:
10632 
          self.success = []
8590 kshitij.so 10633 
          (_etype161, _size158) = iprot.readListBegin()
10634 
          for _i162 in xrange(_size158):
10635 
            _elem163 = Item()
10636 
            _elem163.read(iprot)
10637 
            self.success.append(_elem163)
5944 mandeep.dh 10638 
          iprot.readListEnd()
10639 
        else:
10640 
          iprot.skip(ftype)
10641 
      else:
10642 
        iprot.skip(ftype)
10643 
      iprot.readFieldEnd()
10644 
    iprot.readStructEnd()
10645 
 
10646 
  def write(self, oprot):
10647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10649 
      return
10650 
    oprot.writeStructBegin('getAllSimilarItems_result')
10651 
    if self.success is not None:
10652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10653 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10654 
      for iter164 in self.success:
10655 
        iter164.write(oprot)
5944 mandeep.dh 10656 
      oprot.writeListEnd()
10657 
      oprot.writeFieldEnd()
10658 
    oprot.writeFieldStop()
10659 
    oprot.writeStructEnd()
10660 
 
10661 
  def validate(self):
10662 
    return
10663 
 
10664 
 
10665 
  def __repr__(self):
10666 
    L = ['%s=%r' % (key, value)
10667 
      for key, value in self.__dict__.iteritems()]
10668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10669 
 
10670 
  def __eq__(self, other):
10671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10672 
 
10673 
  def __ne__(self, other):
10674 
    return not (self == other)
10675 
 
10676 
class addSimilarItem_args:
10677 
  """
10678 
  Attributes:
10679 
   - itemId
10680 
   - catalogItemId
10681 
  """
10682 
 
10683 
  thrift_spec = (
10684 
    None, # 0
10685 
    (1, TType.I64, 'itemId', None, None, ), # 1
10686 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10687 
  )
10688 
 
10689 
  def __init__(self, itemId=None, catalogItemId=None,):
10690 
    self.itemId = itemId
10691 
    self.catalogItemId = catalogItemId
10692 
 
10693 
  def read(self, iprot):
10694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10696 
      return
10697 
    iprot.readStructBegin()
10698 
    while True:
10699 
      (fname, ftype, fid) = iprot.readFieldBegin()
10700 
      if ftype == TType.STOP:
10701 
        break
10702 
      if fid == 1:
10703 
        if ftype == TType.I64:
10704 
          self.itemId = iprot.readI64();
10705 
        else:
10706 
          iprot.skip(ftype)
10707 
      elif fid == 2:
10708 
        if ftype == TType.I64:
10709 
          self.catalogItemId = iprot.readI64();
10710 
        else:
10711 
          iprot.skip(ftype)
10712 
      else:
10713 
        iprot.skip(ftype)
10714 
      iprot.readFieldEnd()
10715 
    iprot.readStructEnd()
10716 
 
10717 
  def write(self, oprot):
10718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10720 
      return
10721 
    oprot.writeStructBegin('addSimilarItem_args')
10722 
    if self.itemId is not None:
10723 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10724 
      oprot.writeI64(self.itemId)
10725 
      oprot.writeFieldEnd()
10726 
    if self.catalogItemId is not None:
10727 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10728 
      oprot.writeI64(self.catalogItemId)
10729 
      oprot.writeFieldEnd()
10730 
    oprot.writeFieldStop()
10731 
    oprot.writeStructEnd()
10732 
 
10733 
  def validate(self):
10734 
    return
10735 
 
10736 
 
10737 
  def __repr__(self):
10738 
    L = ['%s=%r' % (key, value)
10739 
      for key, value in self.__dict__.iteritems()]
10740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10741 
 
10742 
  def __eq__(self, other):
10743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10744 
 
10745 
  def __ne__(self, other):
10746 
    return not (self == other)
10747 
 
10748 
class addSimilarItem_result:
10749 
  """
10750 
  Attributes:
10751 
   - success
10752 
   - cex
10753 
  """
10754 
 
10755 
  thrift_spec = (
10756 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10757 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10758 
  )
10759 
 
10760 
  def __init__(self, success=None, cex=None,):
10761 
    self.success = success
10762 
    self.cex = cex
10763 
 
10764 
  def read(self, iprot):
10765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10767 
      return
10768 
    iprot.readStructBegin()
10769 
    while True:
10770 
      (fname, ftype, fid) = iprot.readFieldBegin()
10771 
      if ftype == TType.STOP:
10772 
        break
10773 
      if fid == 0:
10774 
        if ftype == TType.STRUCT:
10775 
          self.success = Item()
10776 
          self.success.read(iprot)
10777 
        else:
10778 
          iprot.skip(ftype)
10779 
      elif fid == 1:
10780 
        if ftype == TType.STRUCT:
10781 
          self.cex = CatalogServiceException()
10782 
          self.cex.read(iprot)
10783 
        else:
10784 
          iprot.skip(ftype)
10785 
      else:
10786 
        iprot.skip(ftype)
10787 
      iprot.readFieldEnd()
10788 
    iprot.readStructEnd()
10789 
 
10790 
  def write(self, oprot):
10791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10793 
      return
10794 
    oprot.writeStructBegin('addSimilarItem_result')
10795 
    if self.success is not None:
10796 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10797 
      self.success.write(oprot)
10798 
      oprot.writeFieldEnd()
10799 
    if self.cex is not None:
10800 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10801 
      self.cex.write(oprot)
10802 
      oprot.writeFieldEnd()
10803 
    oprot.writeFieldStop()
10804 
    oprot.writeStructEnd()
10805 
 
10806 
  def validate(self):
10807 
    return
10808 
 
10809 
 
10810 
  def __repr__(self):
10811 
    L = ['%s=%r' % (key, value)
10812 
      for key, value in self.__dict__.iteritems()]
10813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10814 
 
10815 
  def __eq__(self, other):
10816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10817 
 
10818 
  def __ne__(self, other):
10819 
    return not (self == other)
10820 
 
6512 kshitij.so 10821 
class addTag_args:
10822 
  """
10823 
  Attributes:
10824 
   - displayName
10825 
   - itemId
10826 
  """
10827 
 
10828 
  thrift_spec = (
10829 
    None, # 0
10830 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10831 
    (2, TType.I64, 'itemId', None, None, ), # 2
10832 
  )
10833 
 
10834 
  def __init__(self, displayName=None, itemId=None,):
10835 
    self.displayName = displayName
10836 
    self.itemId = itemId
10837 
 
10838 
  def read(self, iprot):
10839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10841 
      return
10842 
    iprot.readStructBegin()
10843 
    while True:
10844 
      (fname, ftype, fid) = iprot.readFieldBegin()
10845 
      if ftype == TType.STOP:
10846 
        break
10847 
      if fid == 1:
10848 
        if ftype == TType.STRING:
10849 
          self.displayName = iprot.readString();
10850 
        else:
10851 
          iprot.skip(ftype)
10852 
      elif fid == 2:
10853 
        if ftype == TType.I64:
10854 
          self.itemId = iprot.readI64();
10855 
        else:
10856 
          iprot.skip(ftype)
10857 
      else:
10858 
        iprot.skip(ftype)
10859 
      iprot.readFieldEnd()
10860 
    iprot.readStructEnd()
10861 
 
10862 
  def write(self, oprot):
10863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10865 
      return
10866 
    oprot.writeStructBegin('addTag_args')
10867 
    if self.displayName is not None:
10868 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10869 
      oprot.writeString(self.displayName)
10870 
      oprot.writeFieldEnd()
10871 
    if self.itemId is not None:
10872 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10873 
      oprot.writeI64(self.itemId)
10874 
      oprot.writeFieldEnd()
10875 
    oprot.writeFieldStop()
10876 
    oprot.writeStructEnd()
10877 
 
10878 
  def validate(self):
10879 
    return
10880 
 
10881 
 
10882 
  def __repr__(self):
10883 
    L = ['%s=%r' % (key, value)
10884 
      for key, value in self.__dict__.iteritems()]
10885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10886 
 
10887 
  def __eq__(self, other):
10888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10889 
 
10890 
  def __ne__(self, other):
10891 
    return not (self == other)
10892 
 
10893 
class addTag_result:
10894 
  """
10895 
  Attributes:
10896 
   - success
10897 
  """
10898 
 
10899 
  thrift_spec = (
10900 
    (0, TType.BOOL, 'success', None, None, ), # 0
10901 
  )
10902 
 
10903 
  def __init__(self, success=None,):
10904 
    self.success = success
10905 
 
10906 
  def read(self, iprot):
10907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10909 
      return
10910 
    iprot.readStructBegin()
10911 
    while True:
10912 
      (fname, ftype, fid) = iprot.readFieldBegin()
10913 
      if ftype == TType.STOP:
10914 
        break
10915 
      if fid == 0:
10916 
        if ftype == TType.BOOL:
10917 
          self.success = iprot.readBool();
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
10929 
    oprot.writeStructBegin('addTag_result')
10930 
    if self.success is not None:
10931 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10932 
      oprot.writeBool(self.success)
10933 
      oprot.writeFieldEnd()
10934 
    oprot.writeFieldStop()
10935 
    oprot.writeStructEnd()
10936 
 
10937 
  def validate(self):
10938 
    return
10939 
 
10940 
 
10941 
  def __repr__(self):
10942 
    L = ['%s=%r' % (key, value)
10943 
      for key, value in self.__dict__.iteritems()]
10944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10945 
 
10946 
  def __eq__(self, other):
10947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10948 
 
10949 
  def __ne__(self, other):
10950 
    return not (self == other)
10951 
 
10952 
class deleteEntityTag_args:
10953 
  """
10954 
  Attributes:
10955 
   - displayName
10956 
   - itemId
10957 
  """
10958 
 
10959 
  thrift_spec = (
10960 
    None, # 0
10961 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10962 
    (2, TType.I64, 'itemId', None, None, ), # 2
10963 
  )
10964 
 
10965 
  def __init__(self, displayName=None, itemId=None,):
10966 
    self.displayName = displayName
10967 
    self.itemId = itemId
10968 
 
10969 
  def read(self, iprot):
10970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10972 
      return
10973 
    iprot.readStructBegin()
10974 
    while True:
10975 
      (fname, ftype, fid) = iprot.readFieldBegin()
10976 
      if ftype == TType.STOP:
10977 
        break
10978 
      if fid == 1:
10979 
        if ftype == TType.STRING:
10980 
          self.displayName = iprot.readString();
10981 
        else:
10982 
          iprot.skip(ftype)
10983 
      elif fid == 2:
10984 
        if ftype == TType.I64:
10985 
          self.itemId = iprot.readI64();
10986 
        else:
10987 
          iprot.skip(ftype)
10988 
      else:
10989 
        iprot.skip(ftype)
10990 
      iprot.readFieldEnd()
10991 
    iprot.readStructEnd()
10992 
 
10993 
  def write(self, oprot):
10994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10996 
      return
10997 
    oprot.writeStructBegin('deleteEntityTag_args')
10998 
    if self.displayName is not None:
10999 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11000 
      oprot.writeString(self.displayName)
11001 
      oprot.writeFieldEnd()
11002 
    if self.itemId is not None:
11003 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11004 
      oprot.writeI64(self.itemId)
11005 
      oprot.writeFieldEnd()
11006 
    oprot.writeFieldStop()
11007 
    oprot.writeStructEnd()
11008 
 
11009 
  def validate(self):
11010 
    return
11011 
 
11012 
 
11013 
  def __repr__(self):
11014 
    L = ['%s=%r' % (key, value)
11015 
      for key, value in self.__dict__.iteritems()]
11016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11017 
 
11018 
  def __eq__(self, other):
11019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11020 
 
11021 
  def __ne__(self, other):
11022 
    return not (self == other)
11023 
 
11024 
class deleteEntityTag_result:
11025 
  """
11026 
  Attributes:
11027 
   - success
11028 
  """
11029 
 
11030 
  thrift_spec = (
11031 
    (0, TType.BOOL, 'success', None, None, ), # 0
11032 
  )
11033 
 
11034 
  def __init__(self, success=None,):
11035 
    self.success = success
11036 
 
11037 
  def read(self, iprot):
11038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11040 
      return
11041 
    iprot.readStructBegin()
11042 
    while True:
11043 
      (fname, ftype, fid) = iprot.readFieldBegin()
11044 
      if ftype == TType.STOP:
11045 
        break
11046 
      if fid == 0:
11047 
        if ftype == TType.BOOL:
11048 
          self.success = iprot.readBool();
11049 
        else:
11050 
          iprot.skip(ftype)
11051 
      else:
11052 
        iprot.skip(ftype)
11053 
      iprot.readFieldEnd()
11054 
    iprot.readStructEnd()
11055 
 
11056 
  def write(self, oprot):
11057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11059 
      return
11060 
    oprot.writeStructBegin('deleteEntityTag_result')
11061 
    if self.success is not None:
11062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11063 
      oprot.writeBool(self.success)
11064 
      oprot.writeFieldEnd()
11065 
    oprot.writeFieldStop()
11066 
    oprot.writeStructEnd()
11067 
 
11068 
  def validate(self):
11069 
    return
11070 
 
11071 
 
11072 
  def __repr__(self):
11073 
    L = ['%s=%r' % (key, value)
11074 
      for key, value in self.__dict__.iteritems()]
11075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11076 
 
11077 
  def __eq__(self, other):
11078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11079 
 
11080 
  def __ne__(self, other):
11081 
    return not (self == other)
11082 
 
11083 
class deleteTag_args:
11084 
  """
11085 
  Attributes:
11086 
   - displayName
11087 
  """
11088 
 
11089 
  thrift_spec = (
11090 
    None, # 0
11091 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11092 
  )
11093 
 
11094 
  def __init__(self, displayName=None,):
11095 
    self.displayName = displayName
11096 
 
11097 
  def read(self, iprot):
11098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11100 
      return
11101 
    iprot.readStructBegin()
11102 
    while True:
11103 
      (fname, ftype, fid) = iprot.readFieldBegin()
11104 
      if ftype == TType.STOP:
11105 
        break
11106 
      if fid == 1:
11107 
        if ftype == TType.STRING:
11108 
          self.displayName = iprot.readString();
11109 
        else:
11110 
          iprot.skip(ftype)
11111 
      else:
11112 
        iprot.skip(ftype)
11113 
      iprot.readFieldEnd()
11114 
    iprot.readStructEnd()
11115 
 
11116 
  def write(self, oprot):
11117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11119 
      return
11120 
    oprot.writeStructBegin('deleteTag_args')
11121 
    if self.displayName is not None:
11122 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11123 
      oprot.writeString(self.displayName)
11124 
      oprot.writeFieldEnd()
11125 
    oprot.writeFieldStop()
11126 
    oprot.writeStructEnd()
11127 
 
11128 
  def validate(self):
11129 
    return
11130 
 
11131 
 
11132 
  def __repr__(self):
11133 
    L = ['%s=%r' % (key, value)
11134 
      for key, value in self.__dict__.iteritems()]
11135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11136 
 
11137 
  def __eq__(self, other):
11138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11139 
 
11140 
  def __ne__(self, other):
11141 
    return not (self == other)
11142 
 
11143 
class deleteTag_result:
11144 
  """
11145 
  Attributes:
11146 
   - success
11147 
  """
11148 
 
11149 
  thrift_spec = (
11150 
    (0, TType.BOOL, 'success', None, None, ), # 0
11151 
  )
11152 
 
11153 
  def __init__(self, success=None,):
11154 
    self.success = success
11155 
 
11156 
  def read(self, iprot):
11157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11159 
      return
11160 
    iprot.readStructBegin()
11161 
    while True:
11162 
      (fname, ftype, fid) = iprot.readFieldBegin()
11163 
      if ftype == TType.STOP:
11164 
        break
11165 
      if fid == 0:
11166 
        if ftype == TType.BOOL:
11167 
          self.success = iprot.readBool();
11168 
        else:
11169 
          iprot.skip(ftype)
11170 
      else:
11171 
        iprot.skip(ftype)
11172 
      iprot.readFieldEnd()
11173 
    iprot.readStructEnd()
11174 
 
11175 
  def write(self, oprot):
11176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11178 
      return
11179 
    oprot.writeStructBegin('deleteTag_result')
11180 
    if self.success is not None:
11181 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11182 
      oprot.writeBool(self.success)
11183 
      oprot.writeFieldEnd()
11184 
    oprot.writeFieldStop()
11185 
    oprot.writeStructEnd()
11186 
 
11187 
  def validate(self):
11188 
    return
11189 
 
11190 
 
11191 
  def __repr__(self):
11192 
    L = ['%s=%r' % (key, value)
11193 
      for key, value in self.__dict__.iteritems()]
11194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11195 
 
11196 
  def __eq__(self, other):
11197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11198 
 
11199 
  def __ne__(self, other):
11200 
    return not (self == other)
11201 
 
11202 
class getAllTags_args:
11203 
 
11204 
  thrift_spec = (
11205 
  )
11206 
 
11207 
  def read(self, iprot):
11208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11210 
      return
11211 
    iprot.readStructBegin()
11212 
    while True:
11213 
      (fname, ftype, fid) = iprot.readFieldBegin()
11214 
      if ftype == TType.STOP:
11215 
        break
11216 
      else:
11217 
        iprot.skip(ftype)
11218 
      iprot.readFieldEnd()
11219 
    iprot.readStructEnd()
11220 
 
11221 
  def write(self, oprot):
11222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11224 
      return
11225 
    oprot.writeStructBegin('getAllTags_args')
11226 
    oprot.writeFieldStop()
11227 
    oprot.writeStructEnd()
11228 
 
11229 
  def validate(self):
11230 
    return
11231 
 
11232 
 
11233 
  def __repr__(self):
11234 
    L = ['%s=%r' % (key, value)
11235 
      for key, value in self.__dict__.iteritems()]
11236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11237 
 
11238 
  def __eq__(self, other):
11239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11240 
 
11241 
  def __ne__(self, other):
11242 
    return not (self == other)
11243 
 
11244 
class getAllTags_result:
11245 
  """
11246 
  Attributes:
11247 
   - success
11248 
  """
11249 
 
11250 
  thrift_spec = (
11251 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11252 
  )
11253 
 
11254 
  def __init__(self, success=None,):
11255 
    self.success = success
11256 
 
11257 
  def read(self, iprot):
11258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11260 
      return
11261 
    iprot.readStructBegin()
11262 
    while True:
11263 
      (fname, ftype, fid) = iprot.readFieldBegin()
11264 
      if ftype == TType.STOP:
11265 
        break
11266 
      if fid == 0:
11267 
        if ftype == TType.LIST:
11268 
          self.success = []
8590 kshitij.so 11269 
          (_etype168, _size165) = iprot.readListBegin()
11270 
          for _i169 in xrange(_size165):
11271 
            _elem170 = iprot.readString();
11272 
            self.success.append(_elem170)
6512 kshitij.so 11273 
          iprot.readListEnd()
11274 
        else:
11275 
          iprot.skip(ftype)
11276 
      else:
11277 
        iprot.skip(ftype)
11278 
      iprot.readFieldEnd()
11279 
    iprot.readStructEnd()
11280 
 
11281 
  def write(self, oprot):
11282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11284 
      return
11285 
    oprot.writeStructBegin('getAllTags_result')
11286 
    if self.success is not None:
11287 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11288 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11289 
      for iter171 in self.success:
11290 
        oprot.writeString(iter171)
6512 kshitij.so 11291 
      oprot.writeListEnd()
11292 
      oprot.writeFieldEnd()
11293 
    oprot.writeFieldStop()
11294 
    oprot.writeStructEnd()
11295 
 
11296 
  def validate(self):
11297 
    return
11298 
 
11299 
 
11300 
  def __repr__(self):
11301 
    L = ['%s=%r' % (key, value)
11302 
      for key, value in self.__dict__.iteritems()]
11303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11304 
 
11305 
  def __eq__(self, other):
11306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11307 
 
11308 
  def __ne__(self, other):
11309 
    return not (self == other)
11310 
 
11311 
class getAllEntitiesByTagName_args:
11312 
  """
11313 
  Attributes:
11314 
   - displayName
11315 
  """
11316 
 
11317 
  thrift_spec = (
11318 
    None, # 0
11319 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11320 
  )
11321 
 
11322 
  def __init__(self, displayName=None,):
11323 
    self.displayName = displayName
11324 
 
11325 
  def read(self, iprot):
11326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11328 
      return
11329 
    iprot.readStructBegin()
11330 
    while True:
11331 
      (fname, ftype, fid) = iprot.readFieldBegin()
11332 
      if ftype == TType.STOP:
11333 
        break
11334 
      if fid == 1:
11335 
        if ftype == TType.STRING:
11336 
          self.displayName = iprot.readString();
11337 
        else:
11338 
          iprot.skip(ftype)
11339 
      else:
11340 
        iprot.skip(ftype)
11341 
      iprot.readFieldEnd()
11342 
    iprot.readStructEnd()
11343 
 
11344 
  def write(self, oprot):
11345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11347 
      return
11348 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11349 
    if self.displayName is not None:
11350 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11351 
      oprot.writeString(self.displayName)
11352 
      oprot.writeFieldEnd()
11353 
    oprot.writeFieldStop()
11354 
    oprot.writeStructEnd()
11355 
 
11356 
  def validate(self):
11357 
    return
11358 
 
11359 
 
11360 
  def __repr__(self):
11361 
    L = ['%s=%r' % (key, value)
11362 
      for key, value in self.__dict__.iteritems()]
11363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11364 
 
11365 
  def __eq__(self, other):
11366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11367 
 
11368 
  def __ne__(self, other):
11369 
    return not (self == other)
11370 
 
11371 
class getAllEntitiesByTagName_result:
11372 
  """
11373 
  Attributes:
11374 
   - success
11375 
  """
11376 
 
11377 
  thrift_spec = (
11378 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11379 
  )
11380 
 
11381 
  def __init__(self, success=None,):
11382 
    self.success = success
11383 
 
11384 
  def read(self, iprot):
11385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11387 
      return
11388 
    iprot.readStructBegin()
11389 
    while True:
11390 
      (fname, ftype, fid) = iprot.readFieldBegin()
11391 
      if ftype == TType.STOP:
11392 
        break
11393 
      if fid == 0:
11394 
        if ftype == TType.LIST:
11395 
          self.success = []
8590 kshitij.so 11396 
          (_etype175, _size172) = iprot.readListBegin()
11397 
          for _i176 in xrange(_size172):
11398 
            _elem177 = iprot.readI64();
11399 
            self.success.append(_elem177)
6512 kshitij.so 11400 
          iprot.readListEnd()
11401 
        else:
11402 
          iprot.skip(ftype)
11403 
      else:
11404 
        iprot.skip(ftype)
11405 
      iprot.readFieldEnd()
11406 
    iprot.readStructEnd()
11407 
 
11408 
  def write(self, oprot):
11409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11411 
      return
11412 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
11413 
    if self.success is not None:
11414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11415 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11416 
      for iter178 in self.success:
11417 
        oprot.writeI64(iter178)
6512 kshitij.so 11418 
      oprot.writeListEnd()
11419 
      oprot.writeFieldEnd()
11420 
    oprot.writeFieldStop()
11421 
    oprot.writeStructEnd()
11422 
 
11423 
  def validate(self):
11424 
    return
11425 
 
11426 
 
11427 
  def __repr__(self):
11428 
    L = ['%s=%r' % (key, value)
11429 
      for key, value in self.__dict__.iteritems()]
11430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11431 
 
11432 
  def __eq__(self, other):
11433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11434 
 
11435 
  def __ne__(self, other):
11436 
    return not (self == other)
11437 
 
6845 amit.gupta 11438 
class getAllEntityTags_args:
11439 
 
11440 
  thrift_spec = (
11441 
  )
11442 
 
11443 
  def read(self, iprot):
11444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11446 
      return
11447 
    iprot.readStructBegin()
11448 
    while True:
11449 
      (fname, ftype, fid) = iprot.readFieldBegin()
11450 
      if ftype == TType.STOP:
11451 
        break
11452 
      else:
11453 
        iprot.skip(ftype)
11454 
      iprot.readFieldEnd()
11455 
    iprot.readStructEnd()
11456 
 
11457 
  def write(self, oprot):
11458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11460 
      return
11461 
    oprot.writeStructBegin('getAllEntityTags_args')
11462 
    oprot.writeFieldStop()
11463 
    oprot.writeStructEnd()
11464 
 
11465 
  def validate(self):
11466 
    return
11467 
 
11468 
 
11469 
  def __repr__(self):
11470 
    L = ['%s=%r' % (key, value)
11471 
      for key, value in self.__dict__.iteritems()]
11472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11473 
 
11474 
  def __eq__(self, other):
11475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11476 
 
11477 
  def __ne__(self, other):
11478 
    return not (self == other)
11479 
 
11480 
class getAllEntityTags_result:
11481 
  """
11482 
  Attributes:
11483 
   - success
11484 
  """
11485 
 
11486 
  thrift_spec = (
11487 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11488 
  )
11489 
 
11490 
  def __init__(self, success=None,):
11491 
    self.success = success
11492 
 
11493 
  def read(self, iprot):
11494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11496 
      return
11497 
    iprot.readStructBegin()
11498 
    while True:
11499 
      (fname, ftype, fid) = iprot.readFieldBegin()
11500 
      if ftype == TType.STOP:
11501 
        break
11502 
      if fid == 0:
11503 
        if ftype == TType.MAP:
11504 
          self.success = {}
8590 kshitij.so 11505 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
11506 
          for _i183 in xrange(_size179):
11507 
            _key184 = iprot.readI64();
11508 
            _val185 = []
11509 
            (_etype189, _size186) = iprot.readListBegin()
11510 
            for _i190 in xrange(_size186):
11511 
              _elem191 = iprot.readString();
11512 
              _val185.append(_elem191)
6845 amit.gupta 11513 
            iprot.readListEnd()
8590 kshitij.so 11514 
            self.success[_key184] = _val185
6845 amit.gupta 11515 
          iprot.readMapEnd()
11516 
        else:
11517 
          iprot.skip(ftype)
11518 
      else:
11519 
        iprot.skip(ftype)
11520 
      iprot.readFieldEnd()
11521 
    iprot.readStructEnd()
11522 
 
11523 
  def write(self, oprot):
11524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11526 
      return
11527 
    oprot.writeStructBegin('getAllEntityTags_result')
11528 
    if self.success is not None:
11529 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11530 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 11531 
      for kiter192,viter193 in self.success.items():
11532 
        oprot.writeI64(kiter192)
11533 
        oprot.writeListBegin(TType.STRING, len(viter193))
11534 
        for iter194 in viter193:
11535 
          oprot.writeString(iter194)
6845 amit.gupta 11536 
        oprot.writeListEnd()
11537 
      oprot.writeMapEnd()
11538 
      oprot.writeFieldEnd()
11539 
    oprot.writeFieldStop()
11540 
    oprot.writeStructEnd()
11541 
 
11542 
  def validate(self):
11543 
    return
11544 
 
11545 
 
11546 
  def __repr__(self):
11547 
    L = ['%s=%r' % (key, value)
11548 
      for key, value in self.__dict__.iteritems()]
11549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11550 
 
11551 
  def __eq__(self, other):
11552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11553 
 
11554 
  def __ne__(self, other):
11555 
    return not (self == other)
11556 
 
6850 kshitij.so 11557 
class addBanner_args:
11558 
  """
11559 
  Attributes:
8590 kshitij.so 11560 
   - bannerCongregate
6850 kshitij.so 11561 
  """
11562 
 
11563 
  thrift_spec = (
11564 
    None, # 0
8590 kshitij.so 11565 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 11566 
  )
11567 
 
8590 kshitij.so 11568 
  def __init__(self, bannerCongregate=None,):
11569 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 11570 
 
11571 
  def read(self, iprot):
11572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11574 
      return
11575 
    iprot.readStructBegin()
11576 
    while True:
11577 
      (fname, ftype, fid) = iprot.readFieldBegin()
11578 
      if ftype == TType.STOP:
11579 
        break
11580 
      if fid == 1:
8579 kshitij.so 11581 
        if ftype == TType.STRUCT:
8590 kshitij.so 11582 
          self.bannerCongregate = BannerCongregate()
11583 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 11584 
        else:
11585 
          iprot.skip(ftype)
8579 kshitij.so 11586 
      else:
11587 
        iprot.skip(ftype)
11588 
      iprot.readFieldEnd()
11589 
    iprot.readStructEnd()
11590 
 
11591 
  def write(self, oprot):
11592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11594 
      return
11595 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 11596 
    if self.bannerCongregate is not None:
11597 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
11598 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 11599 
      oprot.writeFieldEnd()
11600 
    oprot.writeFieldStop()
11601 
    oprot.writeStructEnd()
11602 
 
11603 
  def validate(self):
11604 
    return
11605 
 
11606 
 
11607 
  def __repr__(self):
11608 
    L = ['%s=%r' % (key, value)
11609 
      for key, value in self.__dict__.iteritems()]
11610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11611 
 
11612 
  def __eq__(self, other):
11613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11614 
 
11615 
  def __ne__(self, other):
11616 
    return not (self == other)
11617 
 
11618 
class addBanner_result:
11619 
 
11620 
  thrift_spec = (
11621 
  )
11622 
 
11623 
  def read(self, iprot):
11624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11626 
      return
11627 
    iprot.readStructBegin()
11628 
    while True:
11629 
      (fname, ftype, fid) = iprot.readFieldBegin()
11630 
      if ftype == TType.STOP:
11631 
        break
11632 
      else:
11633 
        iprot.skip(ftype)
11634 
      iprot.readFieldEnd()
11635 
    iprot.readStructEnd()
11636 
 
11637 
  def write(self, oprot):
11638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11640 
      return
11641 
    oprot.writeStructBegin('addBanner_result')
11642 
    oprot.writeFieldStop()
11643 
    oprot.writeStructEnd()
11644 
 
11645 
  def validate(self):
11646 
    return
11647 
 
11648 
 
11649 
  def __repr__(self):
11650 
    L = ['%s=%r' % (key, value)
11651 
      for key, value in self.__dict__.iteritems()]
11652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11653 
 
11654 
  def __eq__(self, other):
11655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11656 
 
11657 
  def __ne__(self, other):
11658 
    return not (self == other)
11659 
 
11660 
class updateBanner_args:
11661 
  """
11662 
  Attributes:
11663 
   - banner
11664 
  """
11665 
 
11666 
  thrift_spec = (
11667 
    None, # 0
11668 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
11669 
  )
11670 
 
11671 
  def __init__(self, banner=None,):
11672 
    self.banner = banner
11673 
 
11674 
  def read(self, iprot):
11675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11677 
      return
11678 
    iprot.readStructBegin()
11679 
    while True:
11680 
      (fname, ftype, fid) = iprot.readFieldBegin()
11681 
      if ftype == TType.STOP:
11682 
        break
11683 
      if fid == 1:
11684 
        if ftype == TType.STRUCT:
11685 
          self.banner = Banner()
11686 
          self.banner.read(iprot)
6850 kshitij.so 11687 
        else:
11688 
          iprot.skip(ftype)
11689 
      else:
11690 
        iprot.skip(ftype)
11691 
      iprot.readFieldEnd()
11692 
    iprot.readStructEnd()
11693 
 
11694 
  def write(self, oprot):
11695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11697 
      return
8579 kshitij.so 11698 
    oprot.writeStructBegin('updateBanner_args')
11699 
    if self.banner is not None:
11700 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
11701 
      self.banner.write(oprot)
6850 kshitij.so 11702 
      oprot.writeFieldEnd()
11703 
    oprot.writeFieldStop()
11704 
    oprot.writeStructEnd()
11705 
 
11706 
  def validate(self):
11707 
    return
11708 
 
11709 
 
11710 
  def __repr__(self):
11711 
    L = ['%s=%r' % (key, value)
11712 
      for key, value in self.__dict__.iteritems()]
11713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11714 
 
11715 
  def __eq__(self, other):
11716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11717 
 
11718 
  def __ne__(self, other):
11719 
    return not (self == other)
11720 
 
8579 kshitij.so 11721 
class updateBanner_result:
6850 kshitij.so 11722 
  """
11723 
  Attributes:
11724 
   - success
11725 
  """
11726 
 
11727 
  thrift_spec = (
11728 
    (0, TType.BOOL, 'success', None, None, ), # 0
11729 
  )
11730 
 
11731 
  def __init__(self, success=None,):
11732 
    self.success = success
11733 
 
11734 
  def read(self, iprot):
11735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11737 
      return
11738 
    iprot.readStructBegin()
11739 
    while True:
11740 
      (fname, ftype, fid) = iprot.readFieldBegin()
11741 
      if ftype == TType.STOP:
11742 
        break
11743 
      if fid == 0:
11744 
        if ftype == TType.BOOL:
11745 
          self.success = iprot.readBool();
11746 
        else:
11747 
          iprot.skip(ftype)
11748 
      else:
11749 
        iprot.skip(ftype)
11750 
      iprot.readFieldEnd()
11751 
    iprot.readStructEnd()
11752 
 
11753 
  def write(self, oprot):
11754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11756 
      return
8579 kshitij.so 11757 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 11758 
    if self.success is not None:
11759 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11760 
      oprot.writeBool(self.success)
11761 
      oprot.writeFieldEnd()
11762 
    oprot.writeFieldStop()
11763 
    oprot.writeStructEnd()
11764 
 
11765 
  def validate(self):
11766 
    return
11767 
 
11768 
 
11769 
  def __repr__(self):
11770 
    L = ['%s=%r' % (key, value)
11771 
      for key, value in self.__dict__.iteritems()]
11772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11773 
 
11774 
  def __eq__(self, other):
11775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11776 
 
11777 
  def __ne__(self, other):
11778 
    return not (self == other)
11779 
 
11780 
class getAllBanners_args:
11781 
 
11782 
  thrift_spec = (
11783 
  )
11784 
 
11785 
  def read(self, iprot):
11786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11788 
      return
11789 
    iprot.readStructBegin()
11790 
    while True:
11791 
      (fname, ftype, fid) = iprot.readFieldBegin()
11792 
      if ftype == TType.STOP:
11793 
        break
11794 
      else:
11795 
        iprot.skip(ftype)
11796 
      iprot.readFieldEnd()
11797 
    iprot.readStructEnd()
11798 
 
11799 
  def write(self, oprot):
11800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11802 
      return
11803 
    oprot.writeStructBegin('getAllBanners_args')
11804 
    oprot.writeFieldStop()
11805 
    oprot.writeStructEnd()
11806 
 
11807 
  def validate(self):
11808 
    return
11809 
 
11810 
 
11811 
  def __repr__(self):
11812 
    L = ['%s=%r' % (key, value)
11813 
      for key, value in self.__dict__.iteritems()]
11814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11815 
 
11816 
  def __eq__(self, other):
11817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11818 
 
11819 
  def __ne__(self, other):
11820 
    return not (self == other)
11821 
 
11822 
class getAllBanners_result:
11823 
  """
11824 
  Attributes:
11825 
   - success
11826 
  """
11827 
 
11828 
  thrift_spec = (
8579 kshitij.so 11829 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 11830 
  )
11831 
 
11832 
  def __init__(self, success=None,):
11833 
    self.success = success
11834 
 
11835 
  def read(self, iprot):
11836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11838 
      return
11839 
    iprot.readStructBegin()
11840 
    while True:
11841 
      (fname, ftype, fid) = iprot.readFieldBegin()
11842 
      if ftype == TType.STOP:
11843 
        break
11844 
      if fid == 0:
11845 
        if ftype == TType.LIST:
11846 
          self.success = []
8590 kshitij.so 11847 
          (_etype198, _size195) = iprot.readListBegin()
11848 
          for _i199 in xrange(_size195):
11849 
            _elem200 = Banner()
11850 
            _elem200.read(iprot)
11851 
            self.success.append(_elem200)
6850 kshitij.so 11852 
          iprot.readListEnd()
11853 
        else:
11854 
          iprot.skip(ftype)
11855 
      else:
11856 
        iprot.skip(ftype)
11857 
      iprot.readFieldEnd()
11858 
    iprot.readStructEnd()
11859 
 
11860 
  def write(self, oprot):
11861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11863 
      return
11864 
    oprot.writeStructBegin('getAllBanners_result')
11865 
    if self.success is not None:
11866 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 11867 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11868 
      for iter201 in self.success:
11869 
        iter201.write(oprot)
6850 kshitij.so 11870 
      oprot.writeListEnd()
11871 
      oprot.writeFieldEnd()
11872 
    oprot.writeFieldStop()
11873 
    oprot.writeStructEnd()
11874 
 
11875 
  def validate(self):
11876 
    return
11877 
 
11878 
 
11879 
  def __repr__(self):
11880 
    L = ['%s=%r' % (key, value)
11881 
      for key, value in self.__dict__.iteritems()]
11882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11883 
 
11884 
  def __eq__(self, other):
11885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11886 
 
11887 
  def __ne__(self, other):
11888 
    return not (self == other)
11889 
 
11890 
class deleteBanner_args:
11891 
  """
11892 
  Attributes:
11893 
   - bannerName
11894 
  """
11895 
 
11896 
  thrift_spec = (
11897 
    None, # 0
11898 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11899 
  )
11900 
 
11901 
  def __init__(self, bannerName=None,):
11902 
    self.bannerName = bannerName
11903 
 
11904 
  def read(self, iprot):
11905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11907 
      return
11908 
    iprot.readStructBegin()
11909 
    while True:
11910 
      (fname, ftype, fid) = iprot.readFieldBegin()
11911 
      if ftype == TType.STOP:
11912 
        break
11913 
      if fid == 1:
11914 
        if ftype == TType.STRING:
11915 
          self.bannerName = iprot.readString();
11916 
        else:
11917 
          iprot.skip(ftype)
11918 
      else:
11919 
        iprot.skip(ftype)
11920 
      iprot.readFieldEnd()
11921 
    iprot.readStructEnd()
11922 
 
11923 
  def write(self, oprot):
11924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11926 
      return
11927 
    oprot.writeStructBegin('deleteBanner_args')
11928 
    if self.bannerName is not None:
11929 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11930 
      oprot.writeString(self.bannerName)
11931 
      oprot.writeFieldEnd()
11932 
    oprot.writeFieldStop()
11933 
    oprot.writeStructEnd()
11934 
 
11935 
  def validate(self):
11936 
    return
11937 
 
11938 
 
11939 
  def __repr__(self):
11940 
    L = ['%s=%r' % (key, value)
11941 
      for key, value in self.__dict__.iteritems()]
11942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11943 
 
11944 
  def __eq__(self, other):
11945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11946 
 
11947 
  def __ne__(self, other):
11948 
    return not (self == other)
11949 
 
11950 
class deleteBanner_result:
11951 
  """
11952 
  Attributes:
11953 
   - success
11954 
  """
11955 
 
11956 
  thrift_spec = (
11957 
    (0, TType.BOOL, 'success', None, None, ), # 0
11958 
  )
11959 
 
11960 
  def __init__(self, success=None,):
11961 
    self.success = success
11962 
 
11963 
  def read(self, iprot):
11964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11966 
      return
11967 
    iprot.readStructBegin()
11968 
    while True:
11969 
      (fname, ftype, fid) = iprot.readFieldBegin()
11970 
      if ftype == TType.STOP:
11971 
        break
11972 
      if fid == 0:
11973 
        if ftype == TType.BOOL:
11974 
          self.success = iprot.readBool();
11975 
        else:
11976 
          iprot.skip(ftype)
11977 
      else:
11978 
        iprot.skip(ftype)
11979 
      iprot.readFieldEnd()
11980 
    iprot.readStructEnd()
11981 
 
11982 
  def write(self, oprot):
11983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11985 
      return
11986 
    oprot.writeStructBegin('deleteBanner_result')
11987 
    if self.success is not None:
11988 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11989 
      oprot.writeBool(self.success)
11990 
      oprot.writeFieldEnd()
11991 
    oprot.writeFieldStop()
11992 
    oprot.writeStructEnd()
11993 
 
11994 
  def validate(self):
11995 
    return
11996 
 
11997 
 
11998 
  def __repr__(self):
11999 
    L = ['%s=%r' % (key, value)
12000 
      for key, value in self.__dict__.iteritems()]
12001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12002 
 
12003 
  def __eq__(self, other):
12004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12005 
 
12006 
  def __ne__(self, other):
12007 
    return not (self == other)
12008 
 
12009 
class getBannerDetails_args:
12010 
  """
12011 
  Attributes:
12012 
   - bannerName
12013 
  """
12014 
 
12015 
  thrift_spec = (
12016 
    None, # 0
12017 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12018 
  )
12019 
 
12020 
  def __init__(self, bannerName=None,):
12021 
    self.bannerName = bannerName
12022 
 
12023 
  def read(self, iprot):
12024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12026 
      return
12027 
    iprot.readStructBegin()
12028 
    while True:
12029 
      (fname, ftype, fid) = iprot.readFieldBegin()
12030 
      if ftype == TType.STOP:
12031 
        break
12032 
      if fid == 1:
12033 
        if ftype == TType.STRING:
12034 
          self.bannerName = iprot.readString();
12035 
        else:
12036 
          iprot.skip(ftype)
12037 
      else:
12038 
        iprot.skip(ftype)
12039 
      iprot.readFieldEnd()
12040 
    iprot.readStructEnd()
12041 
 
12042 
  def write(self, oprot):
12043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12045 
      return
12046 
    oprot.writeStructBegin('getBannerDetails_args')
12047 
    if self.bannerName is not None:
12048 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12049 
      oprot.writeString(self.bannerName)
12050 
      oprot.writeFieldEnd()
12051 
    oprot.writeFieldStop()
12052 
    oprot.writeStructEnd()
12053 
 
12054 
  def validate(self):
12055 
    return
12056 
 
12057 
 
12058 
  def __repr__(self):
12059 
    L = ['%s=%r' % (key, value)
12060 
      for key, value in self.__dict__.iteritems()]
12061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12062 
 
12063 
  def __eq__(self, other):
12064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12065 
 
12066 
  def __ne__(self, other):
12067 
    return not (self == other)
12068 
 
12069 
class getBannerDetails_result:
12070 
  """
12071 
  Attributes:
12072 
   - success
12073 
  """
12074 
 
12075 
  thrift_spec = (
12076 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12077 
  )
12078 
 
12079 
  def __init__(self, success=None,):
12080 
    self.success = success
12081 
 
12082 
  def read(self, iprot):
12083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12085 
      return
12086 
    iprot.readStructBegin()
12087 
    while True:
12088 
      (fname, ftype, fid) = iprot.readFieldBegin()
12089 
      if ftype == TType.STOP:
12090 
        break
12091 
      if fid == 0:
12092 
        if ftype == TType.STRUCT:
12093 
          self.success = Banner()
12094 
          self.success.read(iprot)
12095 
        else:
12096 
          iprot.skip(ftype)
12097 
      else:
12098 
        iprot.skip(ftype)
12099 
      iprot.readFieldEnd()
12100 
    iprot.readStructEnd()
12101 
 
12102 
  def write(self, oprot):
12103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12105 
      return
12106 
    oprot.writeStructBegin('getBannerDetails_result')
12107 
    if self.success is not None:
12108 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12109 
      self.success.write(oprot)
12110 
      oprot.writeFieldEnd()
12111 
    oprot.writeFieldStop()
12112 
    oprot.writeStructEnd()
12113 
 
12114 
  def validate(self):
12115 
    return
12116 
 
12117 
 
12118 
  def __repr__(self):
12119 
    L = ['%s=%r' % (key, value)
12120 
      for key, value in self.__dict__.iteritems()]
12121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12122 
 
12123 
  def __eq__(self, other):
12124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12125 
 
12126 
  def __ne__(self, other):
12127 
    return not (self == other)
12128 
 
12129 
class getActiveBanners_args:
12130 
 
12131 
  thrift_spec = (
12132 
  )
12133 
 
12134 
  def read(self, iprot):
12135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12137 
      return
12138 
    iprot.readStructBegin()
12139 
    while True:
12140 
      (fname, ftype, fid) = iprot.readFieldBegin()
12141 
      if ftype == TType.STOP:
12142 
        break
12143 
      else:
12144 
        iprot.skip(ftype)
12145 
      iprot.readFieldEnd()
12146 
    iprot.readStructEnd()
12147 
 
12148 
  def write(self, oprot):
12149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12151 
      return
12152 
    oprot.writeStructBegin('getActiveBanners_args')
12153 
    oprot.writeFieldStop()
12154 
    oprot.writeStructEnd()
12155 
 
12156 
  def validate(self):
12157 
    return
12158 
 
12159 
 
12160 
  def __repr__(self):
12161 
    L = ['%s=%r' % (key, value)
12162 
      for key, value in self.__dict__.iteritems()]
12163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12164 
 
12165 
  def __eq__(self, other):
12166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12167 
 
12168 
  def __ne__(self, other):
12169 
    return not (self == other)
12170 
 
12171 
class getActiveBanners_result:
12172 
  """
12173 
  Attributes:
12174 
   - success
12175 
  """
12176 
 
12177 
  thrift_spec = (
8579 kshitij.so 12178 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12179 
  )
12180 
 
12181 
  def __init__(self, success=None,):
12182 
    self.success = success
12183 
 
12184 
  def read(self, iprot):
12185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12187 
      return
12188 
    iprot.readStructBegin()
12189 
    while True:
12190 
      (fname, ftype, fid) = iprot.readFieldBegin()
12191 
      if ftype == TType.STOP:
12192 
        break
12193 
      if fid == 0:
8579 kshitij.so 12194 
        if ftype == TType.MAP:
12195 
          self.success = {}
8590 kshitij.so 12196 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12197 
          for _i206 in xrange(_size202):
12198 
            _key207 = iprot.readString();
12199 
            _val208 = []
12200 
            (_etype212, _size209) = iprot.readListBegin()
12201 
            for _i213 in xrange(_size209):
12202 
              _elem214 = Banner()
12203 
              _elem214.read(iprot)
12204 
              _val208.append(_elem214)
8579 kshitij.so 12205 
            iprot.readListEnd()
8590 kshitij.so 12206 
            self.success[_key207] = _val208
8579 kshitij.so 12207 
          iprot.readMapEnd()
6850 kshitij.so 12208 
        else:
12209 
          iprot.skip(ftype)
12210 
      else:
12211 
        iprot.skip(ftype)
12212 
      iprot.readFieldEnd()
12213 
    iprot.readStructEnd()
12214 
 
12215 
  def write(self, oprot):
12216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12218 
      return
12219 
    oprot.writeStructBegin('getActiveBanners_result')
12220 
    if self.success is not None:
8579 kshitij.so 12221 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12222 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12223 
      for kiter215,viter216 in self.success.items():
12224 
        oprot.writeString(kiter215)
12225 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12226 
        for iter217 in viter216:
12227 
          iter217.write(oprot)
8579 kshitij.so 12228 
        oprot.writeListEnd()
12229 
      oprot.writeMapEnd()
6850 kshitij.so 12230 
      oprot.writeFieldEnd()
12231 
    oprot.writeFieldStop()
12232 
    oprot.writeStructEnd()
12233 
 
12234 
  def validate(self):
12235 
    return
12236 
 
12237 
 
12238 
  def __repr__(self):
12239 
    L = ['%s=%r' % (key, value)
12240 
      for key, value in self.__dict__.iteritems()]
12241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12242 
 
12243 
  def __eq__(self, other):
12244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12245 
 
12246 
  def __ne__(self, other):
12247 
    return not (self == other)
12248 
 
6849 kshitij.so 12249 
class addBannerMap_args:
12250 
  """
12251 
  Attributes:
8579 kshitij.so 12252 
   - bannerMaps
6849 kshitij.so 12253 
  """
12254 
 
12255 
  thrift_spec = (
12256 
    None, # 0
8579 kshitij.so 12257 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12258 
  )
12259 
 
8579 kshitij.so 12260 
  def __init__(self, bannerMaps=None,):
12261 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12262 
 
12263 
  def read(self, iprot):
12264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12266 
      return
12267 
    iprot.readStructBegin()
12268 
    while True:
12269 
      (fname, ftype, fid) = iprot.readFieldBegin()
12270 
      if ftype == TType.STOP:
12271 
        break
12272 
      if fid == 1:
8579 kshitij.so 12273 
        if ftype == TType.LIST:
12274 
          self.bannerMaps = []
8590 kshitij.so 12275 
          (_etype221, _size218) = iprot.readListBegin()
12276 
          for _i222 in xrange(_size218):
12277 
            _elem223 = BannerMap()
12278 
            _elem223.read(iprot)
12279 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12280 
          iprot.readListEnd()
6849 kshitij.so 12281 
        else:
12282 
          iprot.skip(ftype)
8579 kshitij.so 12283 
      else:
12284 
        iprot.skip(ftype)
12285 
      iprot.readFieldEnd()
12286 
    iprot.readStructEnd()
12287 
 
12288 
  def write(self, oprot):
12289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12291 
      return
12292 
    oprot.writeStructBegin('addBannerMap_args')
12293 
    if self.bannerMaps is not None:
12294 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12295 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 12296 
      for iter224 in self.bannerMaps:
12297 
        iter224.write(oprot)
8579 kshitij.so 12298 
      oprot.writeListEnd()
12299 
      oprot.writeFieldEnd()
12300 
    oprot.writeFieldStop()
12301 
    oprot.writeStructEnd()
12302 
 
12303 
  def validate(self):
12304 
    return
12305 
 
12306 
 
12307 
  def __repr__(self):
12308 
    L = ['%s=%r' % (key, value)
12309 
      for key, value in self.__dict__.iteritems()]
12310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12311 
 
12312 
  def __eq__(self, other):
12313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12314 
 
12315 
  def __ne__(self, other):
12316 
    return not (self == other)
12317 
 
12318 
class addBannerMap_result:
12319 
  """
12320 
  Attributes:
12321 
   - success
12322 
  """
12323 
 
12324 
  thrift_spec = (
12325 
    (0, TType.BOOL, 'success', None, None, ), # 0
12326 
  )
12327 
 
12328 
  def __init__(self, success=None,):
12329 
    self.success = success
12330 
 
12331 
  def read(self, iprot):
12332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12334 
      return
12335 
    iprot.readStructBegin()
12336 
    while True:
12337 
      (fname, ftype, fid) = iprot.readFieldBegin()
12338 
      if ftype == TType.STOP:
12339 
        break
12340 
      if fid == 0:
12341 
        if ftype == TType.BOOL:
12342 
          self.success = iprot.readBool();
6849 kshitij.so 12343 
        else:
12344 
          iprot.skip(ftype)
8579 kshitij.so 12345 
      else:
12346 
        iprot.skip(ftype)
12347 
      iprot.readFieldEnd()
12348 
    iprot.readStructEnd()
12349 
 
12350 
  def write(self, oprot):
12351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12353 
      return
12354 
    oprot.writeStructBegin('addBannerMap_result')
12355 
    if self.success is not None:
12356 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12357 
      oprot.writeBool(self.success)
12358 
      oprot.writeFieldEnd()
12359 
    oprot.writeFieldStop()
12360 
    oprot.writeStructEnd()
12361 
 
12362 
  def validate(self):
12363 
    return
12364 
 
12365 
 
12366 
  def __repr__(self):
12367 
    L = ['%s=%r' % (key, value)
12368 
      for key, value in self.__dict__.iteritems()]
12369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12370 
 
12371 
  def __eq__(self, other):
12372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12373 
 
12374 
  def __ne__(self, other):
12375 
    return not (self == other)
12376 
 
12377 
class updateBannerMap_args:
12378 
  """
12379 
  Attributes:
12380 
   - bannerMap
12381 
  """
12382 
 
12383 
  thrift_spec = (
12384 
    None, # 0
12385 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
12386 
  )
12387 
 
12388 
  def __init__(self, bannerMap=None,):
12389 
    self.bannerMap = bannerMap
12390 
 
12391 
  def read(self, iprot):
12392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12394 
      return
12395 
    iprot.readStructBegin()
12396 
    while True:
12397 
      (fname, ftype, fid) = iprot.readFieldBegin()
12398 
      if ftype == TType.STOP:
12399 
        break
12400 
      if fid == 1:
12401 
        if ftype == TType.STRUCT:
12402 
          self.bannerMap = BannerMap()
12403 
          self.bannerMap.read(iprot)
6849 kshitij.so 12404 
        else:
12405 
          iprot.skip(ftype)
12406 
      else:
12407 
        iprot.skip(ftype)
12408 
      iprot.readFieldEnd()
12409 
    iprot.readStructEnd()
12410 
 
12411 
  def write(self, oprot):
12412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12414 
      return
8579 kshitij.so 12415 
    oprot.writeStructBegin('updateBannerMap_args')
12416 
    if self.bannerMap is not None:
12417 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
12418 
      self.bannerMap.write(oprot)
6849 kshitij.so 12419 
      oprot.writeFieldEnd()
12420 
    oprot.writeFieldStop()
12421 
    oprot.writeStructEnd()
12422 
 
12423 
  def validate(self):
12424 
    return
12425 
 
12426 
 
12427 
  def __repr__(self):
12428 
    L = ['%s=%r' % (key, value)
12429 
      for key, value in self.__dict__.iteritems()]
12430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12431 
 
12432 
  def __eq__(self, other):
12433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12434 
 
12435 
  def __ne__(self, other):
12436 
    return not (self == other)
12437 
 
8579 kshitij.so 12438 
class updateBannerMap_result:
6849 kshitij.so 12439 
  """
12440 
  Attributes:
12441 
   - success
12442 
  """
12443 
 
12444 
  thrift_spec = (
12445 
    (0, TType.BOOL, 'success', None, None, ), # 0
12446 
  )
12447 
 
12448 
  def __init__(self, success=None,):
12449 
    self.success = success
12450 
 
12451 
  def read(self, iprot):
12452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12454 
      return
12455 
    iprot.readStructBegin()
12456 
    while True:
12457 
      (fname, ftype, fid) = iprot.readFieldBegin()
12458 
      if ftype == TType.STOP:
12459 
        break
12460 
      if fid == 0:
12461 
        if ftype == TType.BOOL:
12462 
          self.success = iprot.readBool();
12463 
        else:
12464 
          iprot.skip(ftype)
12465 
      else:
12466 
        iprot.skip(ftype)
12467 
      iprot.readFieldEnd()
12468 
    iprot.readStructEnd()
12469 
 
12470 
  def write(self, oprot):
12471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12473 
      return
8579 kshitij.so 12474 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 12475 
    if self.success is not None:
12476 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12477 
      oprot.writeBool(self.success)
12478 
      oprot.writeFieldEnd()
12479 
    oprot.writeFieldStop()
12480 
    oprot.writeStructEnd()
12481 
 
12482 
  def validate(self):
12483 
    return
12484 
 
12485 
 
12486 
  def __repr__(self):
12487 
    L = ['%s=%r' % (key, value)
12488 
      for key, value in self.__dict__.iteritems()]
12489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12490 
 
12491 
  def __eq__(self, other):
12492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12493 
 
12494 
  def __ne__(self, other):
12495 
    return not (self == other)
12496 
 
12497 
class deleteBannerMap_args:
12498 
  """
12499 
  Attributes:
12500 
   - bannerName
12501 
  """
12502 
 
12503 
  thrift_spec = (
12504 
    None, # 0
12505 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12506 
  )
12507 
 
12508 
  def __init__(self, bannerName=None,):
12509 
    self.bannerName = bannerName
12510 
 
12511 
  def read(self, iprot):
12512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12514 
      return
12515 
    iprot.readStructBegin()
12516 
    while True:
12517 
      (fname, ftype, fid) = iprot.readFieldBegin()
12518 
      if ftype == TType.STOP:
12519 
        break
12520 
      if fid == 1:
12521 
        if ftype == TType.STRING:
12522 
          self.bannerName = iprot.readString();
12523 
        else:
12524 
          iprot.skip(ftype)
12525 
      else:
12526 
        iprot.skip(ftype)
12527 
      iprot.readFieldEnd()
12528 
    iprot.readStructEnd()
12529 
 
12530 
  def write(self, oprot):
12531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12533 
      return
12534 
    oprot.writeStructBegin('deleteBannerMap_args')
12535 
    if self.bannerName is not None:
12536 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12537 
      oprot.writeString(self.bannerName)
12538 
      oprot.writeFieldEnd()
12539 
    oprot.writeFieldStop()
12540 
    oprot.writeStructEnd()
12541 
 
12542 
  def validate(self):
12543 
    return
12544 
 
12545 
 
12546 
  def __repr__(self):
12547 
    L = ['%s=%r' % (key, value)
12548 
      for key, value in self.__dict__.iteritems()]
12549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12550 
 
12551 
  def __eq__(self, other):
12552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12553 
 
12554 
  def __ne__(self, other):
12555 
    return not (self == other)
12556 
 
12557 
class deleteBannerMap_result:
12558 
  """
12559 
  Attributes:
12560 
   - success
12561 
  """
12562 
 
12563 
  thrift_spec = (
12564 
    (0, TType.BOOL, 'success', None, None, ), # 0
12565 
  )
12566 
 
12567 
  def __init__(self, success=None,):
12568 
    self.success = success
12569 
 
12570 
  def read(self, iprot):
12571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12573 
      return
12574 
    iprot.readStructBegin()
12575 
    while True:
12576 
      (fname, ftype, fid) = iprot.readFieldBegin()
12577 
      if ftype == TType.STOP:
12578 
        break
12579 
      if fid == 0:
12580 
        if ftype == TType.BOOL:
12581 
          self.success = iprot.readBool();
12582 
        else:
12583 
          iprot.skip(ftype)
12584 
      else:
12585 
        iprot.skip(ftype)
12586 
      iprot.readFieldEnd()
12587 
    iprot.readStructEnd()
12588 
 
12589 
  def write(self, oprot):
12590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12592 
      return
12593 
    oprot.writeStructBegin('deleteBannerMap_result')
12594 
    if self.success is not None:
12595 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12596 
      oprot.writeBool(self.success)
12597 
      oprot.writeFieldEnd()
12598 
    oprot.writeFieldStop()
12599 
    oprot.writeStructEnd()
12600 
 
12601 
  def validate(self):
12602 
    return
12603 
 
12604 
 
12605 
  def __repr__(self):
12606 
    L = ['%s=%r' % (key, value)
12607 
      for key, value in self.__dict__.iteritems()]
12608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12609 
 
12610 
  def __eq__(self, other):
12611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12612 
 
12613 
  def __ne__(self, other):
12614 
    return not (self == other)
12615 
 
12616 
class getBannerMapDetails_args:
12617 
  """
12618 
  Attributes:
12619 
   - bannerName
12620 
  """
12621 
 
12622 
  thrift_spec = (
12623 
    None, # 0
12624 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12625 
  )
12626 
 
12627 
  def __init__(self, bannerName=None,):
12628 
    self.bannerName = bannerName
12629 
 
12630 
  def read(self, iprot):
12631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12633 
      return
12634 
    iprot.readStructBegin()
12635 
    while True:
12636 
      (fname, ftype, fid) = iprot.readFieldBegin()
12637 
      if ftype == TType.STOP:
12638 
        break
12639 
      if fid == 1:
12640 
        if ftype == TType.STRING:
12641 
          self.bannerName = iprot.readString();
12642 
        else:
12643 
          iprot.skip(ftype)
12644 
      else:
12645 
        iprot.skip(ftype)
12646 
      iprot.readFieldEnd()
12647 
    iprot.readStructEnd()
12648 
 
12649 
  def write(self, oprot):
12650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12652 
      return
12653 
    oprot.writeStructBegin('getBannerMapDetails_args')
12654 
    if self.bannerName is not None:
12655 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12656 
      oprot.writeString(self.bannerName)
12657 
      oprot.writeFieldEnd()
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
12675 
 
12676 
class getBannerMapDetails_result:
12677 
  """
12678 
  Attributes:
12679 
   - success
12680 
  """
12681 
 
12682 
  thrift_spec = (
12683 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
12684 
  )
12685 
 
12686 
  def __init__(self, success=None,):
12687 
    self.success = success
12688 
 
12689 
  def read(self, iprot):
12690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12692 
      return
12693 
    iprot.readStructBegin()
12694 
    while True:
12695 
      (fname, ftype, fid) = iprot.readFieldBegin()
12696 
      if ftype == TType.STOP:
12697 
        break
12698 
      if fid == 0:
12699 
        if ftype == TType.LIST:
12700 
          self.success = []
8590 kshitij.so 12701 
          (_etype228, _size225) = iprot.readListBegin()
12702 
          for _i229 in xrange(_size225):
12703 
            _elem230 = BannerMap()
12704 
            _elem230.read(iprot)
12705 
            self.success.append(_elem230)
6849 kshitij.so 12706 
          iprot.readListEnd()
12707 
        else:
12708 
          iprot.skip(ftype)
12709 
      else:
12710 
        iprot.skip(ftype)
12711 
      iprot.readFieldEnd()
12712 
    iprot.readStructEnd()
12713 
 
12714 
  def write(self, oprot):
12715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12717 
      return
12718 
    oprot.writeStructBegin('getBannerMapDetails_result')
12719 
    if self.success is not None:
12720 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12721 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12722 
      for iter231 in self.success:
12723 
        iter231.write(oprot)
6849 kshitij.so 12724 
      oprot.writeListEnd()
12725 
      oprot.writeFieldEnd()
12726 
    oprot.writeFieldStop()
12727 
    oprot.writeStructEnd()
12728 
 
12729 
  def validate(self):
12730 
    return
12731 
 
12732 
 
12733 
  def __repr__(self):
12734 
    L = ['%s=%r' % (key, value)
12735 
      for key, value in self.__dict__.iteritems()]
12736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12737 
 
12738 
  def __eq__(self, other):
12739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12740 
 
12741 
  def __ne__(self, other):
12742 
    return not (self == other)
12743 
 
8579 kshitij.so 12744 
class addBannerUri_args:
12745 
  """
12746 
  Attributes:
12747 
   - bannerUriMappings
12748 
  """
12749 
 
12750 
  thrift_spec = (
12751 
    None, # 0
12752 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
12753 
  )
12754 
 
12755 
  def __init__(self, bannerUriMappings=None,):
12756 
    self.bannerUriMappings = bannerUriMappings
12757 
 
12758 
  def read(self, iprot):
12759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12761 
      return
12762 
    iprot.readStructBegin()
12763 
    while True:
12764 
      (fname, ftype, fid) = iprot.readFieldBegin()
12765 
      if ftype == TType.STOP:
12766 
        break
12767 
      if fid == 1:
12768 
        if ftype == TType.LIST:
12769 
          self.bannerUriMappings = []
8590 kshitij.so 12770 
          (_etype235, _size232) = iprot.readListBegin()
12771 
          for _i236 in xrange(_size232):
12772 
            _elem237 = BannerUriMapping()
12773 
            _elem237.read(iprot)
12774 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 12775 
          iprot.readListEnd()
12776 
        else:
12777 
          iprot.skip(ftype)
12778 
      else:
12779 
        iprot.skip(ftype)
12780 
      iprot.readFieldEnd()
12781 
    iprot.readStructEnd()
12782 
 
12783 
  def write(self, oprot):
12784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12786 
      return
12787 
    oprot.writeStructBegin('addBannerUri_args')
12788 
    if self.bannerUriMappings is not None:
12789 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
12790 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 12791 
      for iter238 in self.bannerUriMappings:
12792 
        iter238.write(oprot)
8579 kshitij.so 12793 
      oprot.writeListEnd()
12794 
      oprot.writeFieldEnd()
12795 
    oprot.writeFieldStop()
12796 
    oprot.writeStructEnd()
12797 
 
12798 
  def validate(self):
12799 
    return
12800 
 
12801 
 
12802 
  def __repr__(self):
12803 
    L = ['%s=%r' % (key, value)
12804 
      for key, value in self.__dict__.iteritems()]
12805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12806 
 
12807 
  def __eq__(self, other):
12808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12809 
 
12810 
  def __ne__(self, other):
12811 
    return not (self == other)
12812 
 
12813 
class addBannerUri_result:
12814 
 
12815 
  thrift_spec = (
12816 
  )
12817 
 
12818 
  def read(self, iprot):
12819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12821 
      return
12822 
    iprot.readStructBegin()
12823 
    while True:
12824 
      (fname, ftype, fid) = iprot.readFieldBegin()
12825 
      if ftype == TType.STOP:
12826 
        break
12827 
      else:
12828 
        iprot.skip(ftype)
12829 
      iprot.readFieldEnd()
12830 
    iprot.readStructEnd()
12831 
 
12832 
  def write(self, oprot):
12833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12835 
      return
12836 
    oprot.writeStructBegin('addBannerUri_result')
12837 
    oprot.writeFieldStop()
12838 
    oprot.writeStructEnd()
12839 
 
12840 
  def validate(self):
12841 
    return
12842 
 
12843 
 
12844 
  def __repr__(self):
12845 
    L = ['%s=%r' % (key, value)
12846 
      for key, value in self.__dict__.iteritems()]
12847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12848 
 
12849 
  def __eq__(self, other):
12850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12851 
 
12852 
  def __ne__(self, other):
12853 
    return not (self == other)
12854 
 
12855 
class getUriMapping_args:
12856 
  """
12857 
  Attributes:
12858 
   - bannerName
12859 
  """
12860 
 
12861 
  thrift_spec = (
12862 
    None, # 0
12863 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12864 
  )
12865 
 
12866 
  def __init__(self, bannerName=None,):
12867 
    self.bannerName = bannerName
12868 
 
12869 
  def read(self, iprot):
12870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12872 
      return
12873 
    iprot.readStructBegin()
12874 
    while True:
12875 
      (fname, ftype, fid) = iprot.readFieldBegin()
12876 
      if ftype == TType.STOP:
12877 
        break
12878 
      if fid == 1:
12879 
        if ftype == TType.STRING:
12880 
          self.bannerName = iprot.readString();
12881 
        else:
12882 
          iprot.skip(ftype)
12883 
      else:
12884 
        iprot.skip(ftype)
12885 
      iprot.readFieldEnd()
12886 
    iprot.readStructEnd()
12887 
 
12888 
  def write(self, oprot):
12889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12891 
      return
12892 
    oprot.writeStructBegin('getUriMapping_args')
12893 
    if self.bannerName is not None:
12894 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12895 
      oprot.writeString(self.bannerName)
12896 
      oprot.writeFieldEnd()
12897 
    oprot.writeFieldStop()
12898 
    oprot.writeStructEnd()
12899 
 
12900 
  def validate(self):
12901 
    return
12902 
 
12903 
 
12904 
  def __repr__(self):
12905 
    L = ['%s=%r' % (key, value)
12906 
      for key, value in self.__dict__.iteritems()]
12907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12908 
 
12909 
  def __eq__(self, other):
12910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12911 
 
12912 
  def __ne__(self, other):
12913 
    return not (self == other)
12914 
 
12915 
class getUriMapping_result:
12916 
  """
12917 
  Attributes:
12918 
   - success
12919 
  """
12920 
 
12921 
  thrift_spec = (
12922 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
12923 
  )
12924 
 
12925 
  def __init__(self, success=None,):
12926 
    self.success = success
12927 
 
12928 
  def read(self, iprot):
12929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12931 
      return
12932 
    iprot.readStructBegin()
12933 
    while True:
12934 
      (fname, ftype, fid) = iprot.readFieldBegin()
12935 
      if ftype == TType.STOP:
12936 
        break
12937 
      if fid == 0:
12938 
        if ftype == TType.LIST:
12939 
          self.success = []
8590 kshitij.so 12940 
          (_etype242, _size239) = iprot.readListBegin()
12941 
          for _i243 in xrange(_size239):
12942 
            _elem244 = BannerUriMapping()
12943 
            _elem244.read(iprot)
12944 
            self.success.append(_elem244)
8579 kshitij.so 12945 
          iprot.readListEnd()
12946 
        else:
12947 
          iprot.skip(ftype)
12948 
      else:
12949 
        iprot.skip(ftype)
12950 
      iprot.readFieldEnd()
12951 
    iprot.readStructEnd()
12952 
 
12953 
  def write(self, oprot):
12954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12956 
      return
12957 
    oprot.writeStructBegin('getUriMapping_result')
12958 
    if self.success is not None:
12959 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12960 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12961 
      for iter245 in self.success:
12962 
        iter245.write(oprot)
8579 kshitij.so 12963 
      oprot.writeListEnd()
12964 
      oprot.writeFieldEnd()
12965 
    oprot.writeFieldStop()
12966 
    oprot.writeStructEnd()
12967 
 
12968 
  def validate(self):
12969 
    return
12970 
 
12971 
 
12972 
  def __repr__(self):
12973 
    L = ['%s=%r' % (key, value)
12974 
      for key, value in self.__dict__.iteritems()]
12975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12976 
 
12977 
  def __eq__(self, other):
12978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12979 
 
12980 
  def __ne__(self, other):
12981 
    return not (self == other)
12982 
 
12983 
class addCampaign_args:
12984 
  """
12985 
  Attributes:
12986 
   - campaign
12987 
  """
12988 
 
12989 
  thrift_spec = (
12990 
    None, # 0
12991 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
12992 
  )
12993 
 
12994 
  def __init__(self, campaign=None,):
12995 
    self.campaign = campaign
12996 
 
12997 
  def read(self, iprot):
12998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13000 
      return
13001 
    iprot.readStructBegin()
13002 
    while True:
13003 
      (fname, ftype, fid) = iprot.readFieldBegin()
13004 
      if ftype == TType.STOP:
13005 
        break
13006 
      if fid == 1:
13007 
        if ftype == TType.STRUCT:
13008 
          self.campaign = Campaign()
13009 
          self.campaign.read(iprot)
13010 
        else:
13011 
          iprot.skip(ftype)
13012 
      else:
13013 
        iprot.skip(ftype)
13014 
      iprot.readFieldEnd()
13015 
    iprot.readStructEnd()
13016 
 
13017 
  def write(self, oprot):
13018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13020 
      return
13021 
    oprot.writeStructBegin('addCampaign_args')
13022 
    if self.campaign is not None:
13023 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13024 
      self.campaign.write(oprot)
13025 
      oprot.writeFieldEnd()
13026 
    oprot.writeFieldStop()
13027 
    oprot.writeStructEnd()
13028 
 
13029 
  def validate(self):
13030 
    return
13031 
 
13032 
 
13033 
  def __repr__(self):
13034 
    L = ['%s=%r' % (key, value)
13035 
      for key, value in self.__dict__.iteritems()]
13036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13037 
 
13038 
  def __eq__(self, other):
13039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13040 
 
13041 
  def __ne__(self, other):
13042 
    return not (self == other)
13043 
 
13044 
class addCampaign_result:
13045 
 
13046 
  thrift_spec = (
13047 
  )
13048 
 
13049 
  def read(self, iprot):
13050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13052 
      return
13053 
    iprot.readStructBegin()
13054 
    while True:
13055 
      (fname, ftype, fid) = iprot.readFieldBegin()
13056 
      if ftype == TType.STOP:
13057 
        break
13058 
      else:
13059 
        iprot.skip(ftype)
13060 
      iprot.readFieldEnd()
13061 
    iprot.readStructEnd()
13062 
 
13063 
  def write(self, oprot):
13064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13066 
      return
13067 
    oprot.writeStructBegin('addCampaign_result')
13068 
    oprot.writeFieldStop()
13069 
    oprot.writeStructEnd()
13070 
 
13071 
  def validate(self):
13072 
    return
13073 
 
13074 
 
13075 
  def __repr__(self):
13076 
    L = ['%s=%r' % (key, value)
13077 
      for key, value in self.__dict__.iteritems()]
13078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13079 
 
13080 
  def __eq__(self, other):
13081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13082 
 
13083 
  def __ne__(self, other):
13084 
    return not (self == other)
13085 
 
13086 
class getCampaigns_args:
13087 
  """
13088 
  Attributes:
13089 
   - campaignName
13090 
  """
13091 
 
13092 
  thrift_spec = (
13093 
    None, # 0
13094 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13095 
  )
13096 
 
13097 
  def __init__(self, campaignName=None,):
13098 
    self.campaignName = campaignName
13099 
 
13100 
  def read(self, iprot):
13101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13103 
      return
13104 
    iprot.readStructBegin()
13105 
    while True:
13106 
      (fname, ftype, fid) = iprot.readFieldBegin()
13107 
      if ftype == TType.STOP:
13108 
        break
13109 
      if fid == 1:
13110 
        if ftype == TType.STRING:
13111 
          self.campaignName = iprot.readString();
13112 
        else:
13113 
          iprot.skip(ftype)
13114 
      else:
13115 
        iprot.skip(ftype)
13116 
      iprot.readFieldEnd()
13117 
    iprot.readStructEnd()
13118 
 
13119 
  def write(self, oprot):
13120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13122 
      return
13123 
    oprot.writeStructBegin('getCampaigns_args')
13124 
    if self.campaignName is not None:
13125 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13126 
      oprot.writeString(self.campaignName)
13127 
      oprot.writeFieldEnd()
13128 
    oprot.writeFieldStop()
13129 
    oprot.writeStructEnd()
13130 
 
13131 
  def validate(self):
13132 
    return
13133 
 
13134 
 
13135 
  def __repr__(self):
13136 
    L = ['%s=%r' % (key, value)
13137 
      for key, value in self.__dict__.iteritems()]
13138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13139 
 
13140 
  def __eq__(self, other):
13141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13142 
 
13143 
  def __ne__(self, other):
13144 
    return not (self == other)
13145 
 
13146 
class getCampaigns_result:
13147 
  """
13148 
  Attributes:
13149 
   - success
13150 
  """
13151 
 
13152 
  thrift_spec = (
13153 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13154 
  )
13155 
 
13156 
  def __init__(self, success=None,):
13157 
    self.success = success
13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
13168 
      if fid == 0:
13169 
        if ftype == TType.LIST:
13170 
          self.success = []
8590 kshitij.so 13171 
          (_etype249, _size246) = iprot.readListBegin()
13172 
          for _i250 in xrange(_size246):
13173 
            _elem251 = Campaign()
13174 
            _elem251.read(iprot)
13175 
            self.success.append(_elem251)
8579 kshitij.so 13176 
          iprot.readListEnd()
13177 
        else:
13178 
          iprot.skip(ftype)
13179 
      else:
13180 
        iprot.skip(ftype)
13181 
      iprot.readFieldEnd()
13182 
    iprot.readStructEnd()
13183 
 
13184 
  def write(self, oprot):
13185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13187 
      return
13188 
    oprot.writeStructBegin('getCampaigns_result')
13189 
    if self.success is not None:
13190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13192 
      for iter252 in self.success:
13193 
        iter252.write(oprot)
8579 kshitij.so 13194 
      oprot.writeListEnd()
13195 
      oprot.writeFieldEnd()
13196 
    oprot.writeFieldStop()
13197 
    oprot.writeStructEnd()
13198 
 
13199 
  def validate(self):
13200 
    return
13201 
 
13202 
 
13203 
  def __repr__(self):
13204 
    L = ['%s=%r' % (key, value)
13205 
      for key, value in self.__dict__.iteritems()]
13206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13207 
 
13208 
  def __eq__(self, other):
13209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13210 
 
13211 
  def __ne__(self, other):
13212 
    return not (self == other)
13213 
 
13214 
class deleteCampaign_args:
13215 
  """
13216 
  Attributes:
13217 
   - campaignId
13218 
  """
13219 
 
13220 
  thrift_spec = (
13221 
    None, # 0
13222 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13223 
  )
13224 
 
13225 
  def __init__(self, campaignId=None,):
13226 
    self.campaignId = campaignId
13227 
 
13228 
  def read(self, iprot):
13229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13231 
      return
13232 
    iprot.readStructBegin()
13233 
    while True:
13234 
      (fname, ftype, fid) = iprot.readFieldBegin()
13235 
      if ftype == TType.STOP:
13236 
        break
13237 
      if fid == 1:
13238 
        if ftype == TType.I64:
13239 
          self.campaignId = iprot.readI64();
13240 
        else:
13241 
          iprot.skip(ftype)
13242 
      else:
13243 
        iprot.skip(ftype)
13244 
      iprot.readFieldEnd()
13245 
    iprot.readStructEnd()
13246 
 
13247 
  def write(self, oprot):
13248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13250 
      return
13251 
    oprot.writeStructBegin('deleteCampaign_args')
13252 
    if self.campaignId is not None:
13253 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13254 
      oprot.writeI64(self.campaignId)
13255 
      oprot.writeFieldEnd()
13256 
    oprot.writeFieldStop()
13257 
    oprot.writeStructEnd()
13258 
 
13259 
  def validate(self):
13260 
    return
13261 
 
13262 
 
13263 
  def __repr__(self):
13264 
    L = ['%s=%r' % (key, value)
13265 
      for key, value in self.__dict__.iteritems()]
13266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13267 
 
13268 
  def __eq__(self, other):
13269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13270 
 
13271 
  def __ne__(self, other):
13272 
    return not (self == other)
13273 
 
13274 
class deleteCampaign_result:
13275 
 
13276 
  thrift_spec = (
13277 
  )
13278 
 
13279 
  def read(self, iprot):
13280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13282 
      return
13283 
    iprot.readStructBegin()
13284 
    while True:
13285 
      (fname, ftype, fid) = iprot.readFieldBegin()
13286 
      if ftype == TType.STOP:
13287 
        break
13288 
      else:
13289 
        iprot.skip(ftype)
13290 
      iprot.readFieldEnd()
13291 
    iprot.readStructEnd()
13292 
 
13293 
  def write(self, oprot):
13294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13296 
      return
13297 
    oprot.writeStructBegin('deleteCampaign_result')
13298 
    oprot.writeFieldStop()
13299 
    oprot.writeStructEnd()
13300 
 
13301 
  def validate(self):
13302 
    return
13303 
 
13304 
 
13305 
  def __repr__(self):
13306 
    L = ['%s=%r' % (key, value)
13307 
      for key, value in self.__dict__.iteritems()]
13308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13309 
 
13310 
  def __eq__(self, other):
13311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13312 
 
13313 
  def __ne__(self, other):
13314 
    return not (self == other)
13315 
 
13316 
class getAllCampaigns_args:
13317 
 
13318 
  thrift_spec = (
13319 
  )
13320 
 
13321 
  def read(self, iprot):
13322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13324 
      return
13325 
    iprot.readStructBegin()
13326 
    while True:
13327 
      (fname, ftype, fid) = iprot.readFieldBegin()
13328 
      if ftype == TType.STOP:
13329 
        break
13330 
      else:
13331 
        iprot.skip(ftype)
13332 
      iprot.readFieldEnd()
13333 
    iprot.readStructEnd()
13334 
 
13335 
  def write(self, oprot):
13336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13338 
      return
13339 
    oprot.writeStructBegin('getAllCampaigns_args')
13340 
    oprot.writeFieldStop()
13341 
    oprot.writeStructEnd()
13342 
 
13343 
  def validate(self):
13344 
    return
13345 
 
13346 
 
13347 
  def __repr__(self):
13348 
    L = ['%s=%r' % (key, value)
13349 
      for key, value in self.__dict__.iteritems()]
13350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13351 
 
13352 
  def __eq__(self, other):
13353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13354 
 
13355 
  def __ne__(self, other):
13356 
    return not (self == other)
13357 
 
13358 
class getAllCampaigns_result:
13359 
  """
13360 
  Attributes:
13361 
   - success
13362 
  """
13363 
 
13364 
  thrift_spec = (
13365 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13366 
  )
13367 
 
13368 
  def __init__(self, success=None,):
13369 
    self.success = success
13370 
 
13371 
  def read(self, iprot):
13372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13374 
      return
13375 
    iprot.readStructBegin()
13376 
    while True:
13377 
      (fname, ftype, fid) = iprot.readFieldBegin()
13378 
      if ftype == TType.STOP:
13379 
        break
13380 
      if fid == 0:
13381 
        if ftype == TType.LIST:
13382 
          self.success = []
8590 kshitij.so 13383 
          (_etype256, _size253) = iprot.readListBegin()
13384 
          for _i257 in xrange(_size253):
13385 
            _elem258 = iprot.readString();
13386 
            self.success.append(_elem258)
8579 kshitij.so 13387 
          iprot.readListEnd()
13388 
        else:
13389 
          iprot.skip(ftype)
13390 
      else:
13391 
        iprot.skip(ftype)
13392 
      iprot.readFieldEnd()
13393 
    iprot.readStructEnd()
13394 
 
13395 
  def write(self, oprot):
13396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13398 
      return
13399 
    oprot.writeStructBegin('getAllCampaigns_result')
13400 
    if self.success is not None:
13401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13402 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13403 
      for iter259 in self.success:
13404 
        oprot.writeString(iter259)
8579 kshitij.so 13405 
      oprot.writeListEnd()
13406 
      oprot.writeFieldEnd()
13407 
    oprot.writeFieldStop()
13408 
    oprot.writeStructEnd()
13409 
 
13410 
  def validate(self):
13411 
    return
13412 
 
13413 
 
13414 
  def __repr__(self):
13415 
    L = ['%s=%r' % (key, value)
13416 
      for key, value in self.__dict__.iteritems()]
13417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13418 
 
13419 
  def __eq__(self, other):
13420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13421 
 
13422 
  def __ne__(self, other):
13423 
    return not (self == other)
13424 
 
5944 mandeep.dh 13425 
class deleteSimilarItem_args:
13426 
  """
13427 
  Attributes:
13428 
   - itemId
13429 
   - catalogItemId
13430 
  """
13431 
 
13432 
  thrift_spec = (
13433 
    None, # 0
13434 
    (1, TType.I64, 'itemId', None, None, ), # 1
13435 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
13436 
  )
13437 
 
13438 
  def __init__(self, itemId=None, catalogItemId=None,):
13439 
    self.itemId = itemId
13440 
    self.catalogItemId = catalogItemId
13441 
 
13442 
  def read(self, iprot):
13443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13445 
      return
13446 
    iprot.readStructBegin()
13447 
    while True:
13448 
      (fname, ftype, fid) = iprot.readFieldBegin()
13449 
      if ftype == TType.STOP:
13450 
        break
13451 
      if fid == 1:
13452 
        if ftype == TType.I64:
13453 
          self.itemId = iprot.readI64();
13454 
        else:
13455 
          iprot.skip(ftype)
13456 
      elif fid == 2:
13457 
        if ftype == TType.I64:
13458 
          self.catalogItemId = iprot.readI64();
13459 
        else:
13460 
          iprot.skip(ftype)
13461 
      else:
13462 
        iprot.skip(ftype)
13463 
      iprot.readFieldEnd()
13464 
    iprot.readStructEnd()
13465 
 
13466 
  def write(self, oprot):
13467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13469 
      return
13470 
    oprot.writeStructBegin('deleteSimilarItem_args')
13471 
    if self.itemId is not None:
13472 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13473 
      oprot.writeI64(self.itemId)
13474 
      oprot.writeFieldEnd()
13475 
    if self.catalogItemId is not None:
13476 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
13477 
      oprot.writeI64(self.catalogItemId)
13478 
      oprot.writeFieldEnd()
13479 
    oprot.writeFieldStop()
13480 
    oprot.writeStructEnd()
13481 
 
13482 
  def validate(self):
13483 
    return
13484 
 
13485 
 
13486 
  def __repr__(self):
13487 
    L = ['%s=%r' % (key, value)
13488 
      for key, value in self.__dict__.iteritems()]
13489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13490 
 
13491 
  def __eq__(self, other):
13492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13493 
 
13494 
  def __ne__(self, other):
13495 
    return not (self == other)
13496 
 
13497 
class deleteSimilarItem_result:
13498 
  """
13499 
  Attributes:
13500 
   - success
13501 
   - cex
13502 
  """
13503 
 
13504 
  thrift_spec = (
13505 
    (0, TType.BOOL, 'success', None, None, ), # 0
13506 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13507 
  )
13508 
 
13509 
  def __init__(self, success=None, cex=None,):
13510 
    self.success = success
13511 
    self.cex = cex
13512 
 
13513 
  def read(self, iprot):
13514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13516 
      return
13517 
    iprot.readStructBegin()
13518 
    while True:
13519 
      (fname, ftype, fid) = iprot.readFieldBegin()
13520 
      if ftype == TType.STOP:
13521 
        break
13522 
      if fid == 0:
13523 
        if ftype == TType.BOOL:
13524 
          self.success = iprot.readBool();
13525 
        else:
13526 
          iprot.skip(ftype)
13527 
      elif fid == 1:
13528 
        if ftype == TType.STRUCT:
13529 
          self.cex = CatalogServiceException()
13530 
          self.cex.read(iprot)
13531 
        else:
13532 
          iprot.skip(ftype)
13533 
      else:
13534 
        iprot.skip(ftype)
13535 
      iprot.readFieldEnd()
13536 
    iprot.readStructEnd()
13537 
 
13538 
  def write(self, oprot):
13539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13541 
      return
13542 
    oprot.writeStructBegin('deleteSimilarItem_result')
13543 
    if self.success is not None:
13544 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13545 
      oprot.writeBool(self.success)
13546 
      oprot.writeFieldEnd()
13547 
    if self.cex is not None:
13548 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13549 
      self.cex.write(oprot)
13550 
      oprot.writeFieldEnd()
13551 
    oprot.writeFieldStop()
13552 
    oprot.writeStructEnd()
13553 
 
13554 
  def validate(self):
13555 
    return
13556 
 
13557 
 
13558 
  def __repr__(self):
13559 
    L = ['%s=%r' % (key, value)
13560 
      for key, value in self.__dict__.iteritems()]
13561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13562 
 
13563 
  def __eq__(self, other):
13564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13565 
 
13566 
  def __ne__(self, other):
13567 
    return not (self == other)
13568 
 
13569 
class checkSimilarItem_args:
13570 
  """
13571 
  Attributes:
13572 
   - brand
13573 
   - modelNumber
13574 
   - modelName
13575 
   - color
13576 
  """
13577 
 
13578 
  thrift_spec = (
13579 
    None, # 0
13580 
    (1, TType.STRING, 'brand', None, None, ), # 1
13581 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
13582 
    (3, TType.STRING, 'modelName', None, None, ), # 3
13583 
    (4, TType.STRING, 'color', None, None, ), # 4
13584 
  )
13585 
 
13586 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
13587 
    self.brand = brand
13588 
    self.modelNumber = modelNumber
13589 
    self.modelName = modelName
13590 
    self.color = color
13591 
 
13592 
  def read(self, iprot):
13593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13595 
      return
13596 
    iprot.readStructBegin()
13597 
    while True:
13598 
      (fname, ftype, fid) = iprot.readFieldBegin()
13599 
      if ftype == TType.STOP:
13600 
        break
13601 
      if fid == 1:
13602 
        if ftype == TType.STRING:
13603 
          self.brand = iprot.readString();
13604 
        else:
13605 
          iprot.skip(ftype)
13606 
      elif fid == 2:
13607 
        if ftype == TType.STRING:
13608 
          self.modelNumber = iprot.readString();
13609 
        else:
13610 
          iprot.skip(ftype)
13611 
      elif fid == 3:
13612 
        if ftype == TType.STRING:
13613 
          self.modelName = iprot.readString();
13614 
        else:
13615 
          iprot.skip(ftype)
13616 
      elif fid == 4:
13617 
        if ftype == TType.STRING:
13618 
          self.color = iprot.readString();
13619 
        else:
13620 
          iprot.skip(ftype)
13621 
      else:
13622 
        iprot.skip(ftype)
13623 
      iprot.readFieldEnd()
13624 
    iprot.readStructEnd()
13625 
 
13626 
  def write(self, oprot):
13627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13629 
      return
13630 
    oprot.writeStructBegin('checkSimilarItem_args')
13631 
    if self.brand is not None:
13632 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
13633 
      oprot.writeString(self.brand)
13634 
      oprot.writeFieldEnd()
13635 
    if self.modelNumber is not None:
13636 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
13637 
      oprot.writeString(self.modelNumber)
13638 
      oprot.writeFieldEnd()
13639 
    if self.modelName is not None:
13640 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
13641 
      oprot.writeString(self.modelName)
13642 
      oprot.writeFieldEnd()
13643 
    if self.color is not None:
13644 
      oprot.writeFieldBegin('color', TType.STRING, 4)
13645 
      oprot.writeString(self.color)
13646 
      oprot.writeFieldEnd()
13647 
    oprot.writeFieldStop()
13648 
    oprot.writeStructEnd()
13649 
 
13650 
  def validate(self):
13651 
    return
13652 
 
13653 
 
13654 
  def __repr__(self):
13655 
    L = ['%s=%r' % (key, value)
13656 
      for key, value in self.__dict__.iteritems()]
13657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13658 
 
13659 
  def __eq__(self, other):
13660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13661 
 
13662 
  def __ne__(self, other):
13663 
    return not (self == other)
13664 
 
13665 
class checkSimilarItem_result:
13666 
  """
13667 
  Attributes:
13668 
   - success
13669 
  """
13670 
 
13671 
  thrift_spec = (
13672 
    (0, TType.I64, 'success', None, None, ), # 0
13673 
  )
13674 
 
13675 
  def __init__(self, success=None,):
13676 
    self.success = success
13677 
 
13678 
  def read(self, iprot):
13679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13681 
      return
13682 
    iprot.readStructBegin()
13683 
    while True:
13684 
      (fname, ftype, fid) = iprot.readFieldBegin()
13685 
      if ftype == TType.STOP:
13686 
        break
13687 
      if fid == 0:
13688 
        if ftype == TType.I64:
13689 
          self.success = iprot.readI64();
13690 
        else:
13691 
          iprot.skip(ftype)
13692 
      else:
13693 
        iprot.skip(ftype)
13694 
      iprot.readFieldEnd()
13695 
    iprot.readStructEnd()
13696 
 
13697 
  def write(self, oprot):
13698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13700 
      return
13701 
    oprot.writeStructBegin('checkSimilarItem_result')
13702 
    if self.success is not None:
13703 
      oprot.writeFieldBegin('success', TType.I64, 0)
13704 
      oprot.writeI64(self.success)
13705 
      oprot.writeFieldEnd()
13706 
    oprot.writeFieldStop()
13707 
    oprot.writeStructEnd()
13708 
 
13709 
  def validate(self):
13710 
    return
13711 
 
13712 
 
13713 
  def __repr__(self):
13714 
    L = ['%s=%r' % (key, value)
13715 
      for key, value in self.__dict__.iteritems()]
13716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13717 
 
13718 
  def __eq__(self, other):
13719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13720 
 
13721 
  def __ne__(self, other):
13722 
    return not (self == other)
13723 
 
13724 
class validateRiskyStatus_args:
13725 
  """
13726 
  Attributes:
13727 
   - itemId
13728 
  """
13729 
 
13730 
  thrift_spec = (
13731 
    None, # 0
13732 
    (1, TType.I64, 'itemId', None, None, ), # 1
13733 
  )
13734 
 
13735 
  def __init__(self, itemId=None,):
13736 
    self.itemId = itemId
13737 
 
13738 
  def read(self, iprot):
13739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13741 
      return
13742 
    iprot.readStructBegin()
13743 
    while True:
13744 
      (fname, ftype, fid) = iprot.readFieldBegin()
13745 
      if ftype == TType.STOP:
13746 
        break
13747 
      if fid == 1:
13748 
        if ftype == TType.I64:
13749 
          self.itemId = iprot.readI64();
13750 
        else:
13751 
          iprot.skip(ftype)
13752 
      else:
13753 
        iprot.skip(ftype)
13754 
      iprot.readFieldEnd()
13755 
    iprot.readStructEnd()
13756 
 
13757 
  def write(self, oprot):
13758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13760 
      return
13761 
    oprot.writeStructBegin('validateRiskyStatus_args')
13762 
    if self.itemId is not None:
13763 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13764 
      oprot.writeI64(self.itemId)
13765 
      oprot.writeFieldEnd()
13766 
    oprot.writeFieldStop()
13767 
    oprot.writeStructEnd()
13768 
 
13769 
  def validate(self):
13770 
    return
13771 
 
13772 
 
13773 
  def __repr__(self):
13774 
    L = ['%s=%r' % (key, value)
13775 
      for key, value in self.__dict__.iteritems()]
13776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13777 
 
13778 
  def __eq__(self, other):
13779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13780 
 
13781 
  def __ne__(self, other):
13782 
    return not (self == other)
13783 
 
13784 
class validateRiskyStatus_result:
13785 
 
13786 
  thrift_spec = (
13787 
  )
13788 
 
13789 
  def read(self, iprot):
13790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13792 
      return
13793 
    iprot.readStructBegin()
13794 
    while True:
13795 
      (fname, ftype, fid) = iprot.readFieldBegin()
13796 
      if ftype == TType.STOP:
13797 
        break
13798 
      else:
13799 
        iprot.skip(ftype)
13800 
      iprot.readFieldEnd()
13801 
    iprot.readStructEnd()
13802 
 
13803 
  def write(self, oprot):
13804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13806 
      return
13807 
    oprot.writeStructBegin('validateRiskyStatus_result')
13808 
    oprot.writeFieldStop()
13809 
    oprot.writeStructEnd()
13810 
 
13811 
  def validate(self):
13812 
    return
13813 
 
13814 
 
13815 
  def __repr__(self):
13816 
    L = ['%s=%r' % (key, value)
13817 
      for key, value in self.__dict__.iteritems()]
13818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13819 
 
13820 
  def __eq__(self, other):
13821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13822 
 
13823 
  def __ne__(self, other):
13824 
    return not (self == other)
13825 
 
13826 
class changeItemRiskyFlag_args:
13827 
  """
13828 
  Attributes:
13829 
   - itemId
13830 
   - risky
13831 
  """
13832 
 
13833 
  thrift_spec = (
13834 
    None, # 0
13835 
    (1, TType.I64, 'itemId', None, None, ), # 1
13836 
    (2, TType.BOOL, 'risky', None, None, ), # 2
13837 
  )
13838 
 
13839 
  def __init__(self, itemId=None, risky=None,):
13840 
    self.itemId = itemId
13841 
    self.risky = risky
13842 
 
13843 
  def read(self, iprot):
13844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13846 
      return
13847 
    iprot.readStructBegin()
13848 
    while True:
13849 
      (fname, ftype, fid) = iprot.readFieldBegin()
13850 
      if ftype == TType.STOP:
13851 
        break
13852 
      if fid == 1:
13853 
        if ftype == TType.I64:
13854 
          self.itemId = iprot.readI64();
13855 
        else:
13856 
          iprot.skip(ftype)
13857 
      elif fid == 2:
13858 
        if ftype == TType.BOOL:
13859 
          self.risky = iprot.readBool();
13860 
        else:
13861 
          iprot.skip(ftype)
13862 
      else:
13863 
        iprot.skip(ftype)
13864 
      iprot.readFieldEnd()
13865 
    iprot.readStructEnd()
13866 
 
13867 
  def write(self, oprot):
13868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13870 
      return
13871 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
13872 
    if self.itemId is not None:
13873 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13874 
      oprot.writeI64(self.itemId)
13875 
      oprot.writeFieldEnd()
13876 
    if self.risky is not None:
13877 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
13878 
      oprot.writeBool(self.risky)
13879 
      oprot.writeFieldEnd()
13880 
    oprot.writeFieldStop()
13881 
    oprot.writeStructEnd()
13882 
 
13883 
  def validate(self):
13884 
    return
13885 
 
13886 
 
13887 
  def __repr__(self):
13888 
    L = ['%s=%r' % (key, value)
13889 
      for key, value in self.__dict__.iteritems()]
13890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13891 
 
13892 
  def __eq__(self, other):
13893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13894 
 
13895 
  def __ne__(self, other):
13896 
    return not (self == other)
13897 
 
13898 
class changeItemRiskyFlag_result:
13899 
 
13900 
  thrift_spec = (
13901 
  )
13902 
 
13903 
  def read(self, iprot):
13904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13906 
      return
13907 
    iprot.readStructBegin()
13908 
    while True:
13909 
      (fname, ftype, fid) = iprot.readFieldBegin()
13910 
      if ftype == TType.STOP:
13911 
        break
13912 
      else:
13913 
        iprot.skip(ftype)
13914 
      iprot.readFieldEnd()
13915 
    iprot.readStructEnd()
13916 
 
13917 
  def write(self, oprot):
13918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13920 
      return
13921 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
13922 
    oprot.writeFieldStop()
13923 
    oprot.writeStructEnd()
13924 
 
13925 
  def validate(self):
13926 
    return
13927 
 
13928 
 
13929 
  def __repr__(self):
13930 
    L = ['%s=%r' % (key, value)
13931 
      for key, value in self.__dict__.iteritems()]
13932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13933 
 
13934 
  def __eq__(self, other):
13935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13936 
 
13937 
  def __ne__(self, other):
13938 
    return not (self == other)
13939 
 
13940 
class getItemsByRiskyFlag_args:
13941 
 
13942 
  thrift_spec = (
13943 
  )
13944 
 
13945 
  def read(self, iprot):
13946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13948 
      return
13949 
    iprot.readStructBegin()
13950 
    while True:
13951 
      (fname, ftype, fid) = iprot.readFieldBegin()
13952 
      if ftype == TType.STOP:
13953 
        break
13954 
      else:
13955 
        iprot.skip(ftype)
13956 
      iprot.readFieldEnd()
13957 
    iprot.readStructEnd()
13958 
 
13959 
  def write(self, oprot):
13960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13962 
      return
13963 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
13964 
    oprot.writeFieldStop()
13965 
    oprot.writeStructEnd()
13966 
 
13967 
  def validate(self):
13968 
    return
13969 
 
13970 
 
13971 
  def __repr__(self):
13972 
    L = ['%s=%r' % (key, value)
13973 
      for key, value in self.__dict__.iteritems()]
13974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13975 
 
13976 
  def __eq__(self, other):
13977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13978 
 
13979 
  def __ne__(self, other):
13980 
    return not (self == other)
13981 
 
13982 
class getItemsByRiskyFlag_result:
13983 
  """
13984 
  Attributes:
13985 
   - success
13986 
  """
13987 
 
13988 
  thrift_spec = (
13989 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13990 
  )
13991 
 
13992 
  def __init__(self, success=None,):
13993 
    self.success = success
13994 
 
13995 
  def read(self, iprot):
13996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13998 
      return
13999 
    iprot.readStructBegin()
14000 
    while True:
14001 
      (fname, ftype, fid) = iprot.readFieldBegin()
14002 
      if ftype == TType.STOP:
14003 
        break
14004 
      if fid == 0:
14005 
        if ftype == TType.LIST:
14006 
          self.success = []
8590 kshitij.so 14007 
          (_etype263, _size260) = iprot.readListBegin()
14008 
          for _i264 in xrange(_size260):
14009 
            _elem265 = Item()
14010 
            _elem265.read(iprot)
14011 
            self.success.append(_elem265)
5944 mandeep.dh 14012 
          iprot.readListEnd()
14013 
        else:
14014 
          iprot.skip(ftype)
14015 
      else:
14016 
        iprot.skip(ftype)
14017 
      iprot.readFieldEnd()
14018 
    iprot.readStructEnd()
14019 
 
14020 
  def write(self, oprot):
14021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14023 
      return
14024 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14025 
    if self.success is not None:
14026 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14027 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14028 
      for iter266 in self.success:
14029 
        iter266.write(oprot)
5944 mandeep.dh 14030 
      oprot.writeListEnd()
14031 
      oprot.writeFieldEnd()
14032 
    oprot.writeFieldStop()
14033 
    oprot.writeStructEnd()
14034 
 
14035 
  def validate(self):
14036 
    return
14037 
 
14038 
 
14039 
  def __repr__(self):
14040 
    L = ['%s=%r' % (key, value)
14041 
      for key, value in self.__dict__.iteritems()]
14042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14043 
 
14044 
  def __eq__(self, other):
14045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14046 
 
14047 
  def __ne__(self, other):
14048 
    return not (self == other)
14049 
 
14050 
class getItemsForMasterSheet_args:
14051 
  """
14052 
  Attributes:
14053 
   - category
14054 
   - brand
14055 
  """
14056 
 
14057 
  thrift_spec = (
14058 
    None, # 0
14059 
    (1, TType.STRING, 'category', None, None, ), # 1
14060 
    (2, TType.STRING, 'brand', None, None, ), # 2
14061 
  )
14062 
 
14063 
  def __init__(self, category=None, brand=None,):
14064 
    self.category = category
14065 
    self.brand = brand
14066 
 
14067 
  def read(self, iprot):
14068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14070 
      return
14071 
    iprot.readStructBegin()
14072 
    while True:
14073 
      (fname, ftype, fid) = iprot.readFieldBegin()
14074 
      if ftype == TType.STOP:
14075 
        break
14076 
      if fid == 1:
14077 
        if ftype == TType.STRING:
14078 
          self.category = iprot.readString();
14079 
        else:
14080 
          iprot.skip(ftype)
14081 
      elif fid == 2:
14082 
        if ftype == TType.STRING:
14083 
          self.brand = iprot.readString();
14084 
        else:
14085 
          iprot.skip(ftype)
14086 
      else:
14087 
        iprot.skip(ftype)
14088 
      iprot.readFieldEnd()
14089 
    iprot.readStructEnd()
14090 
 
14091 
  def write(self, oprot):
14092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14094 
      return
14095 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14096 
    if self.category is not None:
14097 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14098 
      oprot.writeString(self.category)
14099 
      oprot.writeFieldEnd()
14100 
    if self.brand is not None:
14101 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14102 
      oprot.writeString(self.brand)
14103 
      oprot.writeFieldEnd()
14104 
    oprot.writeFieldStop()
14105 
    oprot.writeStructEnd()
14106 
 
14107 
  def validate(self):
14108 
    return
14109 
 
14110 
 
14111 
  def __repr__(self):
14112 
    L = ['%s=%r' % (key, value)
14113 
      for key, value in self.__dict__.iteritems()]
14114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14115 
 
14116 
  def __eq__(self, other):
14117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14118 
 
14119 
  def __ne__(self, other):
14120 
    return not (self == other)
14121 
 
14122 
class getItemsForMasterSheet_result:
14123 
  """
14124 
  Attributes:
14125 
   - success
14126 
  """
14127 
 
14128 
  thrift_spec = (
14129 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14130 
  )
14131 
 
14132 
  def __init__(self, success=None,):
14133 
    self.success = success
14134 
 
14135 
  def read(self, iprot):
14136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14138 
      return
14139 
    iprot.readStructBegin()
14140 
    while True:
14141 
      (fname, ftype, fid) = iprot.readFieldBegin()
14142 
      if ftype == TType.STOP:
14143 
        break
14144 
      if fid == 0:
14145 
        if ftype == TType.LIST:
14146 
          self.success = []
8590 kshitij.so 14147 
          (_etype270, _size267) = iprot.readListBegin()
14148 
          for _i271 in xrange(_size267):
14149 
            _elem272 = Item()
14150 
            _elem272.read(iprot)
14151 
            self.success.append(_elem272)
5944 mandeep.dh 14152 
          iprot.readListEnd()
14153 
        else:
14154 
          iprot.skip(ftype)
14155 
      else:
14156 
        iprot.skip(ftype)
14157 
      iprot.readFieldEnd()
14158 
    iprot.readStructEnd()
14159 
 
14160 
  def write(self, oprot):
14161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14163 
      return
14164 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14165 
    if self.success is not None:
14166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14168 
      for iter273 in self.success:
14169 
        iter273.write(oprot)
5944 mandeep.dh 14170 
      oprot.writeListEnd()
14171 
      oprot.writeFieldEnd()
14172 
    oprot.writeFieldStop()
14173 
    oprot.writeStructEnd()
14174 
 
14175 
  def validate(self):
14176 
    return
14177 
 
14178 
 
14179 
  def __repr__(self):
14180 
    L = ['%s=%r' % (key, value)
14181 
      for key, value in self.__dict__.iteritems()]
14182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14183 
 
14184 
  def __eq__(self, other):
14185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14186 
 
14187 
  def __ne__(self, other):
14188 
    return not (self == other)
14189 
 
14190 
class getSimilarItemsCatalogIds_args:
14191 
  """
14192 
  Attributes:
14193 
   - beginIndex
14194 
   - totalItems
14195 
   - itemId
14196 
  """
14197 
 
14198 
  thrift_spec = (
14199 
    None, # 0
14200 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
14201 
    (2, TType.I64, 'totalItems', None, None, ), # 2
14202 
    (3, TType.I64, 'itemId', None, None, ), # 3
14203 
  )
14204 
 
14205 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
14206 
    self.beginIndex = beginIndex
14207 
    self.totalItems = totalItems
14208 
    self.itemId = itemId
14209 
 
14210 
  def read(self, iprot):
14211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14213 
      return
14214 
    iprot.readStructBegin()
14215 
    while True:
14216 
      (fname, ftype, fid) = iprot.readFieldBegin()
14217 
      if ftype == TType.STOP:
14218 
        break
14219 
      if fid == 1:
14220 
        if ftype == TType.I64:
14221 
          self.beginIndex = iprot.readI64();
14222 
        else:
14223 
          iprot.skip(ftype)
14224 
      elif fid == 2:
14225 
        if ftype == TType.I64:
14226 
          self.totalItems = iprot.readI64();
14227 
        else:
14228 
          iprot.skip(ftype)
14229 
      elif fid == 3:
14230 
        if ftype == TType.I64:
14231 
          self.itemId = iprot.readI64();
14232 
        else:
14233 
          iprot.skip(ftype)
14234 
      else:
14235 
        iprot.skip(ftype)
14236 
      iprot.readFieldEnd()
14237 
    iprot.readStructEnd()
14238 
 
14239 
  def write(self, oprot):
14240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14242 
      return
14243 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
14244 
    if self.beginIndex is not None:
14245 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
14246 
      oprot.writeI64(self.beginIndex)
14247 
      oprot.writeFieldEnd()
14248 
    if self.totalItems is not None:
14249 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
14250 
      oprot.writeI64(self.totalItems)
14251 
      oprot.writeFieldEnd()
14252 
    if self.itemId is not None:
14253 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
14254 
      oprot.writeI64(self.itemId)
14255 
      oprot.writeFieldEnd()
14256 
    oprot.writeFieldStop()
14257 
    oprot.writeStructEnd()
14258 
 
14259 
  def validate(self):
14260 
    return
14261 
 
14262 
 
14263 
  def __repr__(self):
14264 
    L = ['%s=%r' % (key, value)
14265 
      for key, value in self.__dict__.iteritems()]
14266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14267 
 
14268 
  def __eq__(self, other):
14269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14270 
 
14271 
  def __ne__(self, other):
14272 
    return not (self == other)
14273 
 
14274 
class getSimilarItemsCatalogIds_result:
14275 
  """
14276 
  Attributes:
14277 
   - success
14278 
  """
14279 
 
14280 
  thrift_spec = (
14281 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14282 
  )
14283 
 
14284 
  def __init__(self, success=None,):
14285 
    self.success = success
14286 
 
14287 
  def read(self, iprot):
14288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14290 
      return
14291 
    iprot.readStructBegin()
14292 
    while True:
14293 
      (fname, ftype, fid) = iprot.readFieldBegin()
14294 
      if ftype == TType.STOP:
14295 
        break
14296 
      if fid == 0:
14297 
        if ftype == TType.LIST:
14298 
          self.success = []
8590 kshitij.so 14299 
          (_etype277, _size274) = iprot.readListBegin()
14300 
          for _i278 in xrange(_size274):
14301 
            _elem279 = iprot.readI64();
14302 
            self.success.append(_elem279)
5944 mandeep.dh 14303 
          iprot.readListEnd()
14304 
        else:
14305 
          iprot.skip(ftype)
14306 
      else:
14307 
        iprot.skip(ftype)
14308 
      iprot.readFieldEnd()
14309 
    iprot.readStructEnd()
14310 
 
14311 
  def write(self, oprot):
14312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14314 
      return
14315 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
14316 
    if self.success is not None:
14317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14318 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 14319 
      for iter280 in self.success:
14320 
        oprot.writeI64(iter280)
5944 mandeep.dh 14321 
      oprot.writeListEnd()
14322 
      oprot.writeFieldEnd()
14323 
    oprot.writeFieldStop()
14324 
    oprot.writeStructEnd()
14325 
 
14326 
  def validate(self):
14327 
    return
14328 
 
14329 
 
14330 
  def __repr__(self):
14331 
    L = ['%s=%r' % (key, value)
14332 
      for key, value in self.__dict__.iteritems()]
14333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14334 
 
14335 
  def __eq__(self, other):
14336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14337 
 
14338 
  def __ne__(self, other):
14339 
    return not (self == other)
14340 
 
14341 
class addProductNotification_args:
14342 
  """
14343 
  Attributes:
14344 
   - itemId
14345 
   - email
14346 
  """
14347 
 
14348 
  thrift_spec = None
14349 
  def __init__(self, itemId=None, email=None,):
14350 
    self.itemId = itemId
14351 
    self.email = email
14352 
 
14353 
  def read(self, iprot):
14354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14356 
      return
14357 
    iprot.readStructBegin()
14358 
    while True:
14359 
      (fname, ftype, fid) = iprot.readFieldBegin()
14360 
      if ftype == TType.STOP:
14361 
        break
14362 
      if fid == -1:
14363 
        if ftype == TType.I64:
14364 
          self.itemId = iprot.readI64();
14365 
        else:
14366 
          iprot.skip(ftype)
14367 
      elif fid == -2:
14368 
        if ftype == TType.STRING:
14369 
          self.email = iprot.readString();
14370 
        else:
14371 
          iprot.skip(ftype)
14372 
      else:
14373 
        iprot.skip(ftype)
14374 
      iprot.readFieldEnd()
14375 
    iprot.readStructEnd()
14376 
 
14377 
  def write(self, oprot):
14378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14380 
      return
14381 
    oprot.writeStructBegin('addProductNotification_args')
14382 
    if self.email is not None:
14383 
      oprot.writeFieldBegin('email', TType.STRING, -2)
14384 
      oprot.writeString(self.email)
14385 
      oprot.writeFieldEnd()
14386 
    if self.itemId is not None:
14387 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
14388 
      oprot.writeI64(self.itemId)
14389 
      oprot.writeFieldEnd()
14390 
    oprot.writeFieldStop()
14391 
    oprot.writeStructEnd()
14392 
 
14393 
  def validate(self):
14394 
    return
14395 
 
14396 
 
14397 
  def __repr__(self):
14398 
    L = ['%s=%r' % (key, value)
14399 
      for key, value in self.__dict__.iteritems()]
14400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14401 
 
14402 
  def __eq__(self, other):
14403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14404 
 
14405 
  def __ne__(self, other):
14406 
    return not (self == other)
14407 
 
14408 
class addProductNotification_result:
14409 
  """
14410 
  Attributes:
14411 
   - success
14412 
  """
14413 
 
14414 
  thrift_spec = (
14415 
    (0, TType.BOOL, 'success', None, None, ), # 0
14416 
  )
14417 
 
14418 
  def __init__(self, success=None,):
14419 
    self.success = success
14420 
 
14421 
  def read(self, iprot):
14422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14424 
      return
14425 
    iprot.readStructBegin()
14426 
    while True:
14427 
      (fname, ftype, fid) = iprot.readFieldBegin()
14428 
      if ftype == TType.STOP:
14429 
        break
14430 
      if fid == 0:
14431 
        if ftype == TType.BOOL:
14432 
          self.success = iprot.readBool();
14433 
        else:
14434 
          iprot.skip(ftype)
14435 
      else:
14436 
        iprot.skip(ftype)
14437 
      iprot.readFieldEnd()
14438 
    iprot.readStructEnd()
14439 
 
14440 
  def write(self, oprot):
14441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14443 
      return
14444 
    oprot.writeStructBegin('addProductNotification_result')
14445 
    if self.success is not None:
14446 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14447 
      oprot.writeBool(self.success)
14448 
      oprot.writeFieldEnd()
14449 
    oprot.writeFieldStop()
14450 
    oprot.writeStructEnd()
14451 
 
14452 
  def validate(self):
14453 
    return
14454 
 
14455 
 
14456 
  def __repr__(self):
14457 
    L = ['%s=%r' % (key, value)
14458 
      for key, value in self.__dict__.iteritems()]
14459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14460 
 
14461 
  def __eq__(self, other):
14462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14463 
 
14464 
  def __ne__(self, other):
14465 
    return not (self == other)
14466 
 
14467 
class sendProductNotifications_args:
14468 
 
14469 
  thrift_spec = (
14470 
  )
14471 
 
14472 
  def read(self, iprot):
14473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14475 
      return
14476 
    iprot.readStructBegin()
14477 
    while True:
14478 
      (fname, ftype, fid) = iprot.readFieldBegin()
14479 
      if ftype == TType.STOP:
14480 
        break
14481 
      else:
14482 
        iprot.skip(ftype)
14483 
      iprot.readFieldEnd()
14484 
    iprot.readStructEnd()
14485 
 
14486 
  def write(self, oprot):
14487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14489 
      return
14490 
    oprot.writeStructBegin('sendProductNotifications_args')
14491 
    oprot.writeFieldStop()
14492 
    oprot.writeStructEnd()
14493 
 
14494 
  def validate(self):
14495 
    return
14496 
 
14497 
 
14498 
  def __repr__(self):
14499 
    L = ['%s=%r' % (key, value)
14500 
      for key, value in self.__dict__.iteritems()]
14501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14502 
 
14503 
  def __eq__(self, other):
14504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14505 
 
14506 
  def __ne__(self, other):
14507 
    return not (self == other)
14508 
 
14509 
class sendProductNotifications_result:
14510 
  """
14511 
  Attributes:
14512 
   - success
14513 
  """
14514 
 
14515 
  thrift_spec = (
14516 
    (0, TType.BOOL, 'success', None, None, ), # 0
14517 
  )
14518 
 
14519 
  def __init__(self, success=None,):
14520 
    self.success = success
14521 
 
14522 
  def read(self, iprot):
14523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14525 
      return
14526 
    iprot.readStructBegin()
14527 
    while True:
14528 
      (fname, ftype, fid) = iprot.readFieldBegin()
14529 
      if ftype == TType.STOP:
14530 
        break
14531 
      if fid == 0:
14532 
        if ftype == TType.BOOL:
14533 
          self.success = iprot.readBool();
14534 
        else:
14535 
          iprot.skip(ftype)
14536 
      else:
14537 
        iprot.skip(ftype)
14538 
      iprot.readFieldEnd()
14539 
    iprot.readStructEnd()
14540 
 
14541 
  def write(self, oprot):
14542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14544 
      return
14545 
    oprot.writeStructBegin('sendProductNotifications_result')
14546 
    if self.success is not None:
14547 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14548 
      oprot.writeBool(self.success)
14549 
      oprot.writeFieldEnd()
14550 
    oprot.writeFieldStop()
14551 
    oprot.writeStructEnd()
14552 
 
14553 
  def validate(self):
14554 
    return
14555 
 
14556 
 
14557 
  def __repr__(self):
14558 
    L = ['%s=%r' % (key, value)
14559 
      for key, value in self.__dict__.iteritems()]
14560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14561 
 
14562 
  def __eq__(self, other):
14563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14564 
 
14565 
  def __ne__(self, other):
14566 
    return not (self == other)
14567 
 
14568 
class getAllBrandsByCategory_args:
14569 
  """
14570 
  Attributes:
14571 
   - categoryId
14572 
  """
14573 
 
14574 
  thrift_spec = (
14575 
    None, # 0
14576 
    (1, TType.I64, 'categoryId', None, None, ), # 1
14577 
  )
14578 
 
14579 
  def __init__(self, categoryId=None,):
14580 
    self.categoryId = categoryId
14581 
 
14582 
  def read(self, iprot):
14583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14585 
      return
14586 
    iprot.readStructBegin()
14587 
    while True:
14588 
      (fname, ftype, fid) = iprot.readFieldBegin()
14589 
      if ftype == TType.STOP:
14590 
        break
14591 
      if fid == 1:
14592 
        if ftype == TType.I64:
14593 
          self.categoryId = iprot.readI64();
14594 
        else:
14595 
          iprot.skip(ftype)
14596 
      else:
14597 
        iprot.skip(ftype)
14598 
      iprot.readFieldEnd()
14599 
    iprot.readStructEnd()
14600 
 
14601 
  def write(self, oprot):
14602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14604 
      return
14605 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
14606 
    if self.categoryId is not None:
14607 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
14608 
      oprot.writeI64(self.categoryId)
14609 
      oprot.writeFieldEnd()
14610 
    oprot.writeFieldStop()
14611 
    oprot.writeStructEnd()
14612 
 
14613 
  def validate(self):
14614 
    return
14615 
 
14616 
 
14617 
  def __repr__(self):
14618 
    L = ['%s=%r' % (key, value)
14619 
      for key, value in self.__dict__.iteritems()]
14620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14621 
 
14622 
  def __eq__(self, other):
14623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14624 
 
14625 
  def __ne__(self, other):
14626 
    return not (self == other)
14627 
 
14628 
class getAllBrandsByCategory_result:
14629 
  """
14630 
  Attributes:
14631 
   - success
14632 
  """
14633 
 
14634 
  thrift_spec = (
14635 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14636 
  )
14637 
 
14638 
  def __init__(self, success=None,):
14639 
    self.success = success
14640 
 
14641 
  def read(self, iprot):
14642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14644 
      return
14645 
    iprot.readStructBegin()
14646 
    while True:
14647 
      (fname, ftype, fid) = iprot.readFieldBegin()
14648 
      if ftype == TType.STOP:
14649 
        break
14650 
      if fid == 0:
14651 
        if ftype == TType.LIST:
14652 
          self.success = []
8590 kshitij.so 14653 
          (_etype284, _size281) = iprot.readListBegin()
14654 
          for _i285 in xrange(_size281):
14655 
            _elem286 = iprot.readString();
14656 
            self.success.append(_elem286)
5944 mandeep.dh 14657 
          iprot.readListEnd()
14658 
        else:
14659 
          iprot.skip(ftype)
14660 
      else:
14661 
        iprot.skip(ftype)
14662 
      iprot.readFieldEnd()
14663 
    iprot.readStructEnd()
14664 
 
14665 
  def write(self, oprot):
14666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14668 
      return
14669 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
14670 
    if self.success is not None:
14671 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14672 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14673 
      for iter287 in self.success:
14674 
        oprot.writeString(iter287)
5944 mandeep.dh 14675 
      oprot.writeListEnd()
14676 
      oprot.writeFieldEnd()
14677 
    oprot.writeFieldStop()
14678 
    oprot.writeStructEnd()
14679 
 
14680 
  def validate(self):
14681 
    return
14682 
 
14683 
 
14684 
  def __repr__(self):
14685 
    L = ['%s=%r' % (key, value)
14686 
      for key, value in self.__dict__.iteritems()]
14687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14688 
 
14689 
  def __eq__(self, other):
14690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14691 
 
14692 
  def __ne__(self, other):
14693 
    return not (self == other)
14694 
 
14695 
class getAllBrands_args:
14696 
 
14697 
  thrift_spec = (
14698 
  )
14699 
 
14700 
  def read(self, iprot):
14701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14703 
      return
14704 
    iprot.readStructBegin()
14705 
    while True:
14706 
      (fname, ftype, fid) = iprot.readFieldBegin()
14707 
      if ftype == TType.STOP:
14708 
        break
14709 
      else:
14710 
        iprot.skip(ftype)
14711 
      iprot.readFieldEnd()
14712 
    iprot.readStructEnd()
14713 
 
14714 
  def write(self, oprot):
14715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14717 
      return
14718 
    oprot.writeStructBegin('getAllBrands_args')
14719 
    oprot.writeFieldStop()
14720 
    oprot.writeStructEnd()
14721 
 
14722 
  def validate(self):
14723 
    return
14724 
 
14725 
 
14726 
  def __repr__(self):
14727 
    L = ['%s=%r' % (key, value)
14728 
      for key, value in self.__dict__.iteritems()]
14729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14730 
 
14731 
  def __eq__(self, other):
14732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14733 
 
14734 
  def __ne__(self, other):
14735 
    return not (self == other)
14736 
 
14737 
class getAllBrands_result:
14738 
  """
14739 
  Attributes:
14740 
   - success
14741 
  """
14742 
 
14743 
  thrift_spec = (
14744 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
14745 
  )
14746 
 
14747 
  def __init__(self, success=None,):
14748 
    self.success = success
14749 
 
14750 
  def read(self, iprot):
14751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14753 
      return
14754 
    iprot.readStructBegin()
14755 
    while True:
14756 
      (fname, ftype, fid) = iprot.readFieldBegin()
14757 
      if ftype == TType.STOP:
14758 
        break
14759 
      if fid == 0:
14760 
        if ftype == TType.LIST:
14761 
          self.success = []
8590 kshitij.so 14762 
          (_etype291, _size288) = iprot.readListBegin()
14763 
          for _i292 in xrange(_size288):
14764 
            _elem293 = iprot.readString();
14765 
            self.success.append(_elem293)
5944 mandeep.dh 14766 
          iprot.readListEnd()
14767 
        else:
14768 
          iprot.skip(ftype)
14769 
      else:
14770 
        iprot.skip(ftype)
14771 
      iprot.readFieldEnd()
14772 
    iprot.readStructEnd()
14773 
 
14774 
  def write(self, oprot):
14775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14777 
      return
14778 
    oprot.writeStructBegin('getAllBrands_result')
14779 
    if self.success is not None:
14780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14781 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 14782 
      for iter294 in self.success:
14783 
        oprot.writeString(iter294)
5944 mandeep.dh 14784 
      oprot.writeListEnd()
14785 
      oprot.writeFieldEnd()
14786 
    oprot.writeFieldStop()
14787 
    oprot.writeStructEnd()
14788 
 
14789 
  def validate(self):
14790 
    return
14791 
 
14792 
 
14793 
  def __repr__(self):
14794 
    L = ['%s=%r' % (key, value)
14795 
      for key, value in self.__dict__.iteritems()]
14796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14797 
 
14798 
  def __eq__(self, other):
14799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14800 
 
14801 
  def __ne__(self, other):
14802 
    return not (self == other)
14803 
 
14804 
class getAllSources_args:
14805 
 
14806 
  thrift_spec = (
14807 
  )
14808 
 
14809 
  def read(self, iprot):
14810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14812 
      return
14813 
    iprot.readStructBegin()
14814 
    while True:
14815 
      (fname, ftype, fid) = iprot.readFieldBegin()
14816 
      if ftype == TType.STOP:
14817 
        break
14818 
      else:
14819 
        iprot.skip(ftype)
14820 
      iprot.readFieldEnd()
14821 
    iprot.readStructEnd()
14822 
 
14823 
  def write(self, oprot):
14824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14826 
      return
14827 
    oprot.writeStructBegin('getAllSources_args')
14828 
    oprot.writeFieldStop()
14829 
    oprot.writeStructEnd()
14830 
 
14831 
  def validate(self):
14832 
    return
14833 
 
14834 
 
14835 
  def __repr__(self):
14836 
    L = ['%s=%r' % (key, value)
14837 
      for key, value in self.__dict__.iteritems()]
14838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14839 
 
14840 
  def __eq__(self, other):
14841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14842 
 
14843 
  def __ne__(self, other):
14844 
    return not (self == other)
14845 
 
14846 
class getAllSources_result:
14847 
  """
14848 
  Attributes:
14849 
   - success
14850 
  """
14851 
 
14852 
  thrift_spec = (
14853 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
14854 
  )
14855 
 
14856 
  def __init__(self, success=None,):
14857 
    self.success = success
14858 
 
14859 
  def read(self, iprot):
14860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14862 
      return
14863 
    iprot.readStructBegin()
14864 
    while True:
14865 
      (fname, ftype, fid) = iprot.readFieldBegin()
14866 
      if ftype == TType.STOP:
14867 
        break
14868 
      if fid == 0:
14869 
        if ftype == TType.LIST:
14870 
          self.success = []
8590 kshitij.so 14871 
          (_etype298, _size295) = iprot.readListBegin()
14872 
          for _i299 in xrange(_size295):
14873 
            _elem300 = Source()
14874 
            _elem300.read(iprot)
14875 
            self.success.append(_elem300)
5944 mandeep.dh 14876 
          iprot.readListEnd()
14877 
        else:
14878 
          iprot.skip(ftype)
14879 
      else:
14880 
        iprot.skip(ftype)
14881 
      iprot.readFieldEnd()
14882 
    iprot.readStructEnd()
14883 
 
14884 
  def write(self, oprot):
14885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14887 
      return
14888 
    oprot.writeStructBegin('getAllSources_result')
14889 
    if self.success is not None:
14890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14892 
      for iter301 in self.success:
14893 
        iter301.write(oprot)
5944 mandeep.dh 14894 
      oprot.writeListEnd()
14895 
      oprot.writeFieldEnd()
14896 
    oprot.writeFieldStop()
14897 
    oprot.writeStructEnd()
14898 
 
14899 
  def validate(self):
14900 
    return
14901 
 
14902 
 
14903 
  def __repr__(self):
14904 
    L = ['%s=%r' % (key, value)
14905 
      for key, value in self.__dict__.iteritems()]
14906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14907 
 
14908 
  def __eq__(self, other):
14909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14910 
 
14911 
  def __ne__(self, other):
14912 
    return not (self == other)
14913 
 
14914 
class getItemPricingBySource_args:
14915 
  """
14916 
  Attributes:
14917 
   - itemId
14918 
   - sourceId
14919 
  """
14920 
 
14921 
  thrift_spec = (
14922 
    None, # 0
14923 
    (1, TType.I64, 'itemId', None, None, ), # 1
14924 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14925 
  )
14926 
 
14927 
  def __init__(self, itemId=None, sourceId=None,):
14928 
    self.itemId = itemId
14929 
    self.sourceId = sourceId
14930 
 
14931 
  def read(self, iprot):
14932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14934 
      return
14935 
    iprot.readStructBegin()
14936 
    while True:
14937 
      (fname, ftype, fid) = iprot.readFieldBegin()
14938 
      if ftype == TType.STOP:
14939 
        break
14940 
      if fid == 1:
14941 
        if ftype == TType.I64:
14942 
          self.itemId = iprot.readI64();
14943 
        else:
14944 
          iprot.skip(ftype)
14945 
      elif fid == 2:
14946 
        if ftype == TType.I64:
14947 
          self.sourceId = iprot.readI64();
14948 
        else:
14949 
          iprot.skip(ftype)
14950 
      else:
14951 
        iprot.skip(ftype)
14952 
      iprot.readFieldEnd()
14953 
    iprot.readStructEnd()
14954 
 
14955 
  def write(self, oprot):
14956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14958 
      return
14959 
    oprot.writeStructBegin('getItemPricingBySource_args')
14960 
    if self.itemId is not None:
14961 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14962 
      oprot.writeI64(self.itemId)
14963 
      oprot.writeFieldEnd()
14964 
    if self.sourceId is not None:
14965 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14966 
      oprot.writeI64(self.sourceId)
14967 
      oprot.writeFieldEnd()
14968 
    oprot.writeFieldStop()
14969 
    oprot.writeStructEnd()
14970 
 
14971 
  def validate(self):
14972 
    return
14973 
 
14974 
 
14975 
  def __repr__(self):
14976 
    L = ['%s=%r' % (key, value)
14977 
      for key, value in self.__dict__.iteritems()]
14978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14979 
 
14980 
  def __eq__(self, other):
14981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14982 
 
14983 
  def __ne__(self, other):
14984 
    return not (self == other)
14985 
 
14986 
class getItemPricingBySource_result:
14987 
  """
14988 
  Attributes:
14989 
   - success
14990 
   - cex
14991 
  """
14992 
 
14993 
  thrift_spec = (
14994 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
14995 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14996 
  )
14997 
 
14998 
  def __init__(self, success=None, cex=None,):
14999 
    self.success = success
15000 
    self.cex = cex
15001 
 
15002 
  def read(self, iprot):
15003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15005 
      return
15006 
    iprot.readStructBegin()
15007 
    while True:
15008 
      (fname, ftype, fid) = iprot.readFieldBegin()
15009 
      if ftype == TType.STOP:
15010 
        break
15011 
      if fid == 0:
15012 
        if ftype == TType.STRUCT:
15013 
          self.success = SourceItemPricing()
15014 
          self.success.read(iprot)
15015 
        else:
15016 
          iprot.skip(ftype)
15017 
      elif fid == 1:
15018 
        if ftype == TType.STRUCT:
15019 
          self.cex = CatalogServiceException()
15020 
          self.cex.read(iprot)
15021 
        else:
15022 
          iprot.skip(ftype)
15023 
      else:
15024 
        iprot.skip(ftype)
15025 
      iprot.readFieldEnd()
15026 
    iprot.readStructEnd()
15027 
 
15028 
  def write(self, oprot):
15029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15031 
      return
15032 
    oprot.writeStructBegin('getItemPricingBySource_result')
15033 
    if self.success is not None:
15034 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15035 
      self.success.write(oprot)
15036 
      oprot.writeFieldEnd()
15037 
    if self.cex is not None:
15038 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15039 
      self.cex.write(oprot)
15040 
      oprot.writeFieldEnd()
15041 
    oprot.writeFieldStop()
15042 
    oprot.writeStructEnd()
15043 
 
15044 
  def validate(self):
15045 
    return
15046 
 
15047 
 
15048 
  def __repr__(self):
15049 
    L = ['%s=%r' % (key, value)
15050 
      for key, value in self.__dict__.iteritems()]
15051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15052 
 
15053 
  def __eq__(self, other):
15054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15055 
 
15056 
  def __ne__(self, other):
15057 
    return not (self == other)
15058 
 
15059 
class addSourceItemPricing_args:
15060 
  """
15061 
  Attributes:
15062 
   - sourceItemPricing
15063 
  """
15064 
 
15065 
  thrift_spec = (
15066 
    None, # 0
15067 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15068 
  )
15069 
 
15070 
  def __init__(self, sourceItemPricing=None,):
15071 
    self.sourceItemPricing = sourceItemPricing
15072 
 
15073 
  def read(self, iprot):
15074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15076 
      return
15077 
    iprot.readStructBegin()
15078 
    while True:
15079 
      (fname, ftype, fid) = iprot.readFieldBegin()
15080 
      if ftype == TType.STOP:
15081 
        break
15082 
      if fid == 1:
15083 
        if ftype == TType.STRUCT:
15084 
          self.sourceItemPricing = SourceItemPricing()
15085 
          self.sourceItemPricing.read(iprot)
15086 
        else:
15087 
          iprot.skip(ftype)
15088 
      else:
15089 
        iprot.skip(ftype)
15090 
      iprot.readFieldEnd()
15091 
    iprot.readStructEnd()
15092 
 
15093 
  def write(self, oprot):
15094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15096 
      return
15097 
    oprot.writeStructBegin('addSourceItemPricing_args')
15098 
    if self.sourceItemPricing is not None:
15099 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15100 
      self.sourceItemPricing.write(oprot)
15101 
      oprot.writeFieldEnd()
15102 
    oprot.writeFieldStop()
15103 
    oprot.writeStructEnd()
15104 
 
15105 
  def validate(self):
15106 
    return
15107 
 
15108 
 
15109 
  def __repr__(self):
15110 
    L = ['%s=%r' % (key, value)
15111 
      for key, value in self.__dict__.iteritems()]
15112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15113 
 
15114 
  def __eq__(self, other):
15115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15116 
 
15117 
  def __ne__(self, other):
15118 
    return not (self == other)
15119 
 
15120 
class addSourceItemPricing_result:
15121 
  """
15122 
  Attributes:
15123 
   - cex
15124 
  """
15125 
 
15126 
  thrift_spec = (
15127 
    None, # 0
15128 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15129 
  )
15130 
 
15131 
  def __init__(self, cex=None,):
15132 
    self.cex = cex
15133 
 
15134 
  def read(self, iprot):
15135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15137 
      return
15138 
    iprot.readStructBegin()
15139 
    while True:
15140 
      (fname, ftype, fid) = iprot.readFieldBegin()
15141 
      if ftype == TType.STOP:
15142 
        break
15143 
      if fid == 1:
15144 
        if ftype == TType.STRUCT:
15145 
          self.cex = CatalogServiceException()
15146 
          self.cex.read(iprot)
15147 
        else:
15148 
          iprot.skip(ftype)
15149 
      else:
15150 
        iprot.skip(ftype)
15151 
      iprot.readFieldEnd()
15152 
    iprot.readStructEnd()
15153 
 
15154 
  def write(self, oprot):
15155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15157 
      return
15158 
    oprot.writeStructBegin('addSourceItemPricing_result')
15159 
    if self.cex is not None:
15160 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15161 
      self.cex.write(oprot)
15162 
      oprot.writeFieldEnd()
15163 
    oprot.writeFieldStop()
15164 
    oprot.writeStructEnd()
15165 
 
15166 
  def validate(self):
15167 
    return
15168 
 
15169 
 
15170 
  def __repr__(self):
15171 
    L = ['%s=%r' % (key, value)
15172 
      for key, value in self.__dict__.iteritems()]
15173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15174 
 
15175 
  def __eq__(self, other):
15176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15177 
 
15178 
  def __ne__(self, other):
15179 
    return not (self == other)
15180 
 
15181 
class getAllSourcePricing_args:
15182 
  """
15183 
  Attributes:
15184 
   - itemId
15185 
  """
15186 
 
15187 
  thrift_spec = (
15188 
    None, # 0
15189 
    (1, TType.I64, 'itemId', None, None, ), # 1
15190 
  )
15191 
 
15192 
  def __init__(self, itemId=None,):
15193 
    self.itemId = itemId
15194 
 
15195 
  def read(self, iprot):
15196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15198 
      return
15199 
    iprot.readStructBegin()
15200 
    while True:
15201 
      (fname, ftype, fid) = iprot.readFieldBegin()
15202 
      if ftype == TType.STOP:
15203 
        break
15204 
      if fid == 1:
15205 
        if ftype == TType.I64:
15206 
          self.itemId = iprot.readI64();
15207 
        else:
15208 
          iprot.skip(ftype)
15209 
      else:
15210 
        iprot.skip(ftype)
15211 
      iprot.readFieldEnd()
15212 
    iprot.readStructEnd()
15213 
 
15214 
  def write(self, oprot):
15215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15217 
      return
15218 
    oprot.writeStructBegin('getAllSourcePricing_args')
15219 
    if self.itemId is not None:
15220 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15221 
      oprot.writeI64(self.itemId)
15222 
      oprot.writeFieldEnd()
15223 
    oprot.writeFieldStop()
15224 
    oprot.writeStructEnd()
15225 
 
15226 
  def validate(self):
15227 
    return
15228 
 
15229 
 
15230 
  def __repr__(self):
15231 
    L = ['%s=%r' % (key, value)
15232 
      for key, value in self.__dict__.iteritems()]
15233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15234 
 
15235 
  def __eq__(self, other):
15236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15237 
 
15238 
  def __ne__(self, other):
15239 
    return not (self == other)
15240 
 
15241 
class getAllSourcePricing_result:
15242 
  """
15243 
  Attributes:
15244 
   - success
15245 
   - cex
15246 
  """
15247 
 
15248 
  thrift_spec = (
15249 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
15250 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15251 
  )
15252 
 
15253 
  def __init__(self, success=None, cex=None,):
15254 
    self.success = success
15255 
    self.cex = cex
15256 
 
15257 
  def read(self, iprot):
15258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15260 
      return
15261 
    iprot.readStructBegin()
15262 
    while True:
15263 
      (fname, ftype, fid) = iprot.readFieldBegin()
15264 
      if ftype == TType.STOP:
15265 
        break
15266 
      if fid == 0:
15267 
        if ftype == TType.LIST:
15268 
          self.success = []
8590 kshitij.so 15269 
          (_etype305, _size302) = iprot.readListBegin()
15270 
          for _i306 in xrange(_size302):
15271 
            _elem307 = SourceItemPricing()
15272 
            _elem307.read(iprot)
15273 
            self.success.append(_elem307)
5944 mandeep.dh 15274 
          iprot.readListEnd()
15275 
        else:
15276 
          iprot.skip(ftype)
15277 
      elif fid == 1:
15278 
        if ftype == TType.STRUCT:
15279 
          self.cex = CatalogServiceException()
15280 
          self.cex.read(iprot)
15281 
        else:
15282 
          iprot.skip(ftype)
15283 
      else:
15284 
        iprot.skip(ftype)
15285 
      iprot.readFieldEnd()
15286 
    iprot.readStructEnd()
15287 
 
15288 
  def write(self, oprot):
15289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15291 
      return
15292 
    oprot.writeStructBegin('getAllSourcePricing_result')
15293 
    if self.success is not None:
15294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15296 
      for iter308 in self.success:
15297 
        iter308.write(oprot)
5944 mandeep.dh 15298 
      oprot.writeListEnd()
15299 
      oprot.writeFieldEnd()
15300 
    if self.cex is not None:
15301 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15302 
      self.cex.write(oprot)
15303 
      oprot.writeFieldEnd()
15304 
    oprot.writeFieldStop()
15305 
    oprot.writeStructEnd()
15306 
 
15307 
  def validate(self):
15308 
    return
15309 
 
15310 
 
15311 
  def __repr__(self):
15312 
    L = ['%s=%r' % (key, value)
15313 
      for key, value in self.__dict__.iteritems()]
15314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15315 
 
15316 
  def __eq__(self, other):
15317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15318 
 
15319 
  def __ne__(self, other):
15320 
    return not (self == other)
15321 
 
15322 
class getItemForSource_args:
15323 
  """
15324 
  Attributes:
15325 
   - item_id
15326 
   - sourceId
15327 
  """
15328 
 
15329 
  thrift_spec = (
15330 
    None, # 0
15331 
    (1, TType.I64, 'item_id', None, None, ), # 1
15332 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15333 
  )
15334 
 
15335 
  def __init__(self, item_id=None, sourceId=None,):
15336 
    self.item_id = item_id
15337 
    self.sourceId = sourceId
15338 
 
15339 
  def read(self, iprot):
15340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15342 
      return
15343 
    iprot.readStructBegin()
15344 
    while True:
15345 
      (fname, ftype, fid) = iprot.readFieldBegin()
15346 
      if ftype == TType.STOP:
15347 
        break
15348 
      if fid == 1:
15349 
        if ftype == TType.I64:
15350 
          self.item_id = iprot.readI64();
15351 
        else:
15352 
          iprot.skip(ftype)
15353 
      elif fid == 2:
15354 
        if ftype == TType.I64:
15355 
          self.sourceId = iprot.readI64();
15356 
        else:
15357 
          iprot.skip(ftype)
15358 
      else:
15359 
        iprot.skip(ftype)
15360 
      iprot.readFieldEnd()
15361 
    iprot.readStructEnd()
15362 
 
15363 
  def write(self, oprot):
15364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15366 
      return
15367 
    oprot.writeStructBegin('getItemForSource_args')
15368 
    if self.item_id is not None:
15369 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
15370 
      oprot.writeI64(self.item_id)
15371 
      oprot.writeFieldEnd()
15372 
    if self.sourceId is not None:
15373 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15374 
      oprot.writeI64(self.sourceId)
15375 
      oprot.writeFieldEnd()
15376 
    oprot.writeFieldStop()
15377 
    oprot.writeStructEnd()
15378 
 
15379 
  def validate(self):
15380 
    return
15381 
 
15382 
 
15383 
  def __repr__(self):
15384 
    L = ['%s=%r' % (key, value)
15385 
      for key, value in self.__dict__.iteritems()]
15386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15387 
 
15388 
  def __eq__(self, other):
15389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15390 
 
15391 
  def __ne__(self, other):
15392 
    return not (self == other)
15393 
 
15394 
class getItemForSource_result:
15395 
  """
15396 
  Attributes:
15397 
   - success
15398 
   - cex
15399 
  """
15400 
 
15401 
  thrift_spec = (
15402 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
15403 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15404 
  )
15405 
 
15406 
  def __init__(self, success=None, cex=None,):
15407 
    self.success = success
15408 
    self.cex = cex
15409 
 
15410 
  def read(self, iprot):
15411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15413 
      return
15414 
    iprot.readStructBegin()
15415 
    while True:
15416 
      (fname, ftype, fid) = iprot.readFieldBegin()
15417 
      if ftype == TType.STOP:
15418 
        break
15419 
      if fid == 0:
15420 
        if ftype == TType.STRUCT:
15421 
          self.success = Item()
15422 
          self.success.read(iprot)
15423 
        else:
15424 
          iprot.skip(ftype)
15425 
      elif fid == 1:
15426 
        if ftype == TType.STRUCT:
15427 
          self.cex = CatalogServiceException()
15428 
          self.cex.read(iprot)
15429 
        else:
15430 
          iprot.skip(ftype)
15431 
      else:
15432 
        iprot.skip(ftype)
15433 
      iprot.readFieldEnd()
15434 
    iprot.readStructEnd()
15435 
 
15436 
  def write(self, oprot):
15437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15439 
      return
15440 
    oprot.writeStructBegin('getItemForSource_result')
15441 
    if self.success is not None:
15442 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15443 
      self.success.write(oprot)
15444 
      oprot.writeFieldEnd()
15445 
    if self.cex is not None:
15446 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15447 
      self.cex.write(oprot)
15448 
      oprot.writeFieldEnd()
15449 
    oprot.writeFieldStop()
15450 
    oprot.writeStructEnd()
15451 
 
15452 
  def validate(self):
15453 
    return
15454 
 
15455 
 
15456 
  def __repr__(self):
15457 
    L = ['%s=%r' % (key, value)
15458 
      for key, value in self.__dict__.iteritems()]
15459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15460 
 
15461 
  def __eq__(self, other):
15462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15463 
 
15464 
  def __ne__(self, other):
15465 
    return not (self == other)
15466 
 
15467 
class searchItemsInRange_args:
15468 
  """
15469 
  Attributes:
15470 
   - searchTerms
15471 
   - offset
15472 
   - limit
15473 
  """
15474 
 
15475 
  thrift_spec = (
15476 
    None, # 0
15477 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15478 
    (2, TType.I64, 'offset', None, None, ), # 2
15479 
    (3, TType.I64, 'limit', None, None, ), # 3
15480 
  )
15481 
 
15482 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
15483 
    self.searchTerms = searchTerms
15484 
    self.offset = offset
15485 
    self.limit = limit
15486 
 
15487 
  def read(self, iprot):
15488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15490 
      return
15491 
    iprot.readStructBegin()
15492 
    while True:
15493 
      (fname, ftype, fid) = iprot.readFieldBegin()
15494 
      if ftype == TType.STOP:
15495 
        break
15496 
      if fid == 1:
15497 
        if ftype == TType.LIST:
15498 
          self.searchTerms = []
8590 kshitij.so 15499 
          (_etype312, _size309) = iprot.readListBegin()
15500 
          for _i313 in xrange(_size309):
15501 
            _elem314 = iprot.readString();
15502 
            self.searchTerms.append(_elem314)
5944 mandeep.dh 15503 
          iprot.readListEnd()
15504 
        else:
15505 
          iprot.skip(ftype)
15506 
      elif fid == 2:
15507 
        if ftype == TType.I64:
15508 
          self.offset = iprot.readI64();
15509 
        else:
15510 
          iprot.skip(ftype)
15511 
      elif fid == 3:
15512 
        if ftype == TType.I64:
15513 
          self.limit = iprot.readI64();
15514 
        else:
15515 
          iprot.skip(ftype)
15516 
      else:
15517 
        iprot.skip(ftype)
15518 
      iprot.readFieldEnd()
15519 
    iprot.readStructEnd()
15520 
 
15521 
  def write(self, oprot):
15522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15524 
      return
15525 
    oprot.writeStructBegin('searchItemsInRange_args')
15526 
    if self.searchTerms is not None:
15527 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15528 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 15529 
      for iter315 in self.searchTerms:
15530 
        oprot.writeString(iter315)
5944 mandeep.dh 15531 
      oprot.writeListEnd()
15532 
      oprot.writeFieldEnd()
15533 
    if self.offset is not None:
15534 
      oprot.writeFieldBegin('offset', TType.I64, 2)
15535 
      oprot.writeI64(self.offset)
15536 
      oprot.writeFieldEnd()
15537 
    if self.limit is not None:
15538 
      oprot.writeFieldBegin('limit', TType.I64, 3)
15539 
      oprot.writeI64(self.limit)
15540 
      oprot.writeFieldEnd()
15541 
    oprot.writeFieldStop()
15542 
    oprot.writeStructEnd()
15543 
 
15544 
  def validate(self):
15545 
    return
15546 
 
15547 
 
15548 
  def __repr__(self):
15549 
    L = ['%s=%r' % (key, value)
15550 
      for key, value in self.__dict__.iteritems()]
15551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15552 
 
15553 
  def __eq__(self, other):
15554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15555 
 
15556 
  def __ne__(self, other):
15557 
    return not (self == other)
15558 
 
15559 
class searchItemsInRange_result:
15560 
  """
15561 
  Attributes:
15562 
   - success
15563 
  """
15564 
 
15565 
  thrift_spec = (
15566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15567 
  )
15568 
 
15569 
  def __init__(self, success=None,):
15570 
    self.success = success
15571 
 
15572 
  def read(self, iprot):
15573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15575 
      return
15576 
    iprot.readStructBegin()
15577 
    while True:
15578 
      (fname, ftype, fid) = iprot.readFieldBegin()
15579 
      if ftype == TType.STOP:
15580 
        break
15581 
      if fid == 0:
15582 
        if ftype == TType.LIST:
15583 
          self.success = []
8590 kshitij.so 15584 
          (_etype319, _size316) = iprot.readListBegin()
15585 
          for _i320 in xrange(_size316):
15586 
            _elem321 = Item()
15587 
            _elem321.read(iprot)
15588 
            self.success.append(_elem321)
5944 mandeep.dh 15589 
          iprot.readListEnd()
15590 
        else:
15591 
          iprot.skip(ftype)
15592 
      else:
15593 
        iprot.skip(ftype)
15594 
      iprot.readFieldEnd()
15595 
    iprot.readStructEnd()
15596 
 
15597 
  def write(self, oprot):
15598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15600 
      return
15601 
    oprot.writeStructBegin('searchItemsInRange_result')
15602 
    if self.success is not None:
15603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15605 
      for iter322 in self.success:
15606 
        iter322.write(oprot)
5944 mandeep.dh 15607 
      oprot.writeListEnd()
15608 
      oprot.writeFieldEnd()
15609 
    oprot.writeFieldStop()
15610 
    oprot.writeStructEnd()
15611 
 
15612 
  def validate(self):
15613 
    return
15614 
 
15615 
 
15616 
  def __repr__(self):
15617 
    L = ['%s=%r' % (key, value)
15618 
      for key, value in self.__dict__.iteritems()]
15619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15620 
 
15621 
  def __eq__(self, other):
15622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15623 
 
15624 
  def __ne__(self, other):
15625 
    return not (self == other)
15626 
 
15627 
class getSearchResultCount_args:
15628 
  """
15629 
  Attributes:
15630 
   - searchTerms
15631 
  """
15632 
 
15633 
  thrift_spec = (
15634 
    None, # 0
15635 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15636 
  )
15637 
 
15638 
  def __init__(self, searchTerms=None,):
15639 
    self.searchTerms = searchTerms
15640 
 
15641 
  def read(self, iprot):
15642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15644 
      return
15645 
    iprot.readStructBegin()
15646 
    while True:
15647 
      (fname, ftype, fid) = iprot.readFieldBegin()
15648 
      if ftype == TType.STOP:
15649 
        break
15650 
      if fid == 1:
15651 
        if ftype == TType.LIST:
15652 
          self.searchTerms = []
8590 kshitij.so 15653 
          (_etype326, _size323) = iprot.readListBegin()
15654 
          for _i327 in xrange(_size323):
15655 
            _elem328 = iprot.readString();
15656 
            self.searchTerms.append(_elem328)
5944 mandeep.dh 15657 
          iprot.readListEnd()
15658 
        else:
15659 
          iprot.skip(ftype)
15660 
      else:
15661 
        iprot.skip(ftype)
15662 
      iprot.readFieldEnd()
15663 
    iprot.readStructEnd()
15664 
 
15665 
  def write(self, oprot):
15666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15668 
      return
15669 
    oprot.writeStructBegin('getSearchResultCount_args')
15670 
    if self.searchTerms is not None:
15671 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15672 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 15673 
      for iter329 in self.searchTerms:
15674 
        oprot.writeString(iter329)
5944 mandeep.dh 15675 
      oprot.writeListEnd()
15676 
      oprot.writeFieldEnd()
15677 
    oprot.writeFieldStop()
15678 
    oprot.writeStructEnd()
15679 
 
15680 
  def validate(self):
15681 
    return
15682 
 
15683 
 
15684 
  def __repr__(self):
15685 
    L = ['%s=%r' % (key, value)
15686 
      for key, value in self.__dict__.iteritems()]
15687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15688 
 
15689 
  def __eq__(self, other):
15690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15691 
 
15692 
  def __ne__(self, other):
15693 
    return not (self == other)
15694 
 
15695 
class getSearchResultCount_result:
15696 
  """
15697 
  Attributes:
15698 
   - success
15699 
  """
15700 
 
15701 
  thrift_spec = (
15702 
    (0, TType.I32, 'success', None, None, ), # 0
15703 
  )
15704 
 
15705 
  def __init__(self, success=None,):
15706 
    self.success = success
15707 
 
15708 
  def read(self, iprot):
15709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15711 
      return
15712 
    iprot.readStructBegin()
15713 
    while True:
15714 
      (fname, ftype, fid) = iprot.readFieldBegin()
15715 
      if ftype == TType.STOP:
15716 
        break
15717 
      if fid == 0:
15718 
        if ftype == TType.I32:
15719 
          self.success = iprot.readI32();
15720 
        else:
15721 
          iprot.skip(ftype)
15722 
      else:
15723 
        iprot.skip(ftype)
15724 
      iprot.readFieldEnd()
15725 
    iprot.readStructEnd()
15726 
 
15727 
  def write(self, oprot):
15728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15730 
      return
15731 
    oprot.writeStructBegin('getSearchResultCount_result')
15732 
    if self.success is not None:
15733 
      oprot.writeFieldBegin('success', TType.I32, 0)
15734 
      oprot.writeI32(self.success)
15735 
      oprot.writeFieldEnd()
15736 
    oprot.writeFieldStop()
15737 
    oprot.writeStructEnd()
15738 
 
15739 
  def validate(self):
15740 
    return
15741 
 
15742 
 
15743 
  def __repr__(self):
15744 
    L = ['%s=%r' % (key, value)
15745 
      for key, value in self.__dict__.iteritems()]
15746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15747 
 
15748 
  def __eq__(self, other):
15749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15750 
 
15751 
  def __ne__(self, other):
15752 
    return not (self == other)
15753 
 
15754 
class getProductNotifications_args:
15755 
  """
15756 
  Attributes:
15757 
   - startDateTime
15758 
  """
15759 
 
15760 
  thrift_spec = (
15761 
    None, # 0
15762 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
15763 
  )
15764 
 
15765 
  def __init__(self, startDateTime=None,):
15766 
    self.startDateTime = startDateTime
15767 
 
15768 
  def read(self, iprot):
15769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15771 
      return
15772 
    iprot.readStructBegin()
15773 
    while True:
15774 
      (fname, ftype, fid) = iprot.readFieldBegin()
15775 
      if ftype == TType.STOP:
15776 
        break
15777 
      if fid == 1:
15778 
        if ftype == TType.I64:
15779 
          self.startDateTime = iprot.readI64();
15780 
        else:
15781 
          iprot.skip(ftype)
15782 
      else:
15783 
        iprot.skip(ftype)
15784 
      iprot.readFieldEnd()
15785 
    iprot.readStructEnd()
15786 
 
15787 
  def write(self, oprot):
15788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15790 
      return
15791 
    oprot.writeStructBegin('getProductNotifications_args')
15792 
    if self.startDateTime is not None:
15793 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
15794 
      oprot.writeI64(self.startDateTime)
15795 
      oprot.writeFieldEnd()
15796 
    oprot.writeFieldStop()
15797 
    oprot.writeStructEnd()
15798 
 
15799 
  def validate(self):
15800 
    return
15801 
 
15802 
 
15803 
  def __repr__(self):
15804 
    L = ['%s=%r' % (key, value)
15805 
      for key, value in self.__dict__.iteritems()]
15806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15807 
 
15808 
  def __eq__(self, other):
15809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15810 
 
15811 
  def __ne__(self, other):
15812 
    return not (self == other)
15813 
 
15814 
class getProductNotifications_result:
15815 
  """
15816 
  Attributes:
15817 
   - success
15818 
  """
15819 
 
15820 
  thrift_spec = (
15821 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
15822 
  )
15823 
 
15824 
  def __init__(self, success=None,):
15825 
    self.success = success
15826 
 
15827 
  def read(self, iprot):
15828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15830 
      return
15831 
    iprot.readStructBegin()
15832 
    while True:
15833 
      (fname, ftype, fid) = iprot.readFieldBegin()
15834 
      if ftype == TType.STOP:
15835 
        break
15836 
      if fid == 0:
15837 
        if ftype == TType.LIST:
15838 
          self.success = []
8590 kshitij.so 15839 
          (_etype333, _size330) = iprot.readListBegin()
15840 
          for _i334 in xrange(_size330):
15841 
            _elem335 = ProductNotificationRequest()
15842 
            _elem335.read(iprot)
15843 
            self.success.append(_elem335)
5944 mandeep.dh 15844 
          iprot.readListEnd()
15845 
        else:
15846 
          iprot.skip(ftype)
15847 
      else:
15848 
        iprot.skip(ftype)
15849 
      iprot.readFieldEnd()
15850 
    iprot.readStructEnd()
15851 
 
15852 
  def write(self, oprot):
15853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15855 
      return
15856 
    oprot.writeStructBegin('getProductNotifications_result')
15857 
    if self.success is not None:
15858 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15859 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15860 
      for iter336 in self.success:
15861 
        iter336.write(oprot)
5944 mandeep.dh 15862 
      oprot.writeListEnd()
15863 
      oprot.writeFieldEnd()
15864 
    oprot.writeFieldStop()
15865 
    oprot.writeStructEnd()
15866 
 
15867 
  def validate(self):
15868 
    return
15869 
 
15870 
 
15871 
  def __repr__(self):
15872 
    L = ['%s=%r' % (key, value)
15873 
      for key, value in self.__dict__.iteritems()]
15874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15875 
 
15876 
  def __eq__(self, other):
15877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15878 
 
15879 
  def __ne__(self, other):
15880 
    return not (self == other)
15881 
 
15882 
class getProductNotificationRequestCount_args:
15883 
  """
15884 
  Attributes:
15885 
   - startDateTime
7897 amar.kumar 15886 
   - categoryId
5944 mandeep.dh 15887 
  """
15888 
 
15889 
  thrift_spec = (
15890 
    None, # 0
15891 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 15892 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 15893 
  )
15894 
 
7897 amar.kumar 15895 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 15896 
    self.startDateTime = startDateTime
7897 amar.kumar 15897 
    self.categoryId = categoryId
5944 mandeep.dh 15898 
 
15899 
  def read(self, iprot):
15900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15902 
      return
15903 
    iprot.readStructBegin()
15904 
    while True:
15905 
      (fname, ftype, fid) = iprot.readFieldBegin()
15906 
      if ftype == TType.STOP:
15907 
        break
15908 
      if fid == 1:
15909 
        if ftype == TType.I64:
15910 
          self.startDateTime = iprot.readI64();
15911 
        else:
15912 
          iprot.skip(ftype)
7897 amar.kumar 15913 
      elif fid == 2:
15914 
        if ftype == TType.I64:
15915 
          self.categoryId = iprot.readI64();
15916 
        else:
15917 
          iprot.skip(ftype)
5944 mandeep.dh 15918 
      else:
15919 
        iprot.skip(ftype)
15920 
      iprot.readFieldEnd()
15921 
    iprot.readStructEnd()
15922 
 
15923 
  def write(self, oprot):
15924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15926 
      return
15927 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
15928 
    if self.startDateTime is not None:
15929 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
15930 
      oprot.writeI64(self.startDateTime)
15931 
      oprot.writeFieldEnd()
7897 amar.kumar 15932 
    if self.categoryId is not None:
15933 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
15934 
      oprot.writeI64(self.categoryId)
15935 
      oprot.writeFieldEnd()
5944 mandeep.dh 15936 
    oprot.writeFieldStop()
15937 
    oprot.writeStructEnd()
15938 
 
15939 
  def validate(self):
15940 
    return
15941 
 
15942 
 
15943 
  def __repr__(self):
15944 
    L = ['%s=%r' % (key, value)
15945 
      for key, value in self.__dict__.iteritems()]
15946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15947 
 
15948 
  def __eq__(self, other):
15949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15950 
 
15951 
  def __ne__(self, other):
15952 
    return not (self == other)
15953 
 
15954 
class getProductNotificationRequestCount_result:
15955 
  """
15956 
  Attributes:
15957 
   - success
15958 
  """
15959 
 
15960 
  thrift_spec = (
15961 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
15962 
  )
15963 
 
15964 
  def __init__(self, success=None,):
15965 
    self.success = success
15966 
 
15967 
  def read(self, iprot):
15968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15970 
      return
15971 
    iprot.readStructBegin()
15972 
    while True:
15973 
      (fname, ftype, fid) = iprot.readFieldBegin()
15974 
      if ftype == TType.STOP:
15975 
        break
15976 
      if fid == 0:
15977 
        if ftype == TType.LIST:
15978 
          self.success = []
8590 kshitij.so 15979 
          (_etype340, _size337) = iprot.readListBegin()
15980 
          for _i341 in xrange(_size337):
15981 
            _elem342 = ProductNotificationRequestCount()
15982 
            _elem342.read(iprot)
15983 
            self.success.append(_elem342)
5944 mandeep.dh 15984 
          iprot.readListEnd()
15985 
        else:
15986 
          iprot.skip(ftype)
15987 
      else:
15988 
        iprot.skip(ftype)
15989 
      iprot.readFieldEnd()
15990 
    iprot.readStructEnd()
15991 
 
15992 
  def write(self, oprot):
15993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15995 
      return
15996 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
15997 
    if self.success is not None:
15998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16000 
      for iter343 in self.success:
16001 
        iter343.write(oprot)
5944 mandeep.dh 16002 
      oprot.writeListEnd()
16003 
      oprot.writeFieldEnd()
16004 
    oprot.writeFieldStop()
16005 
    oprot.writeStructEnd()
16006 
 
16007 
  def validate(self):
16008 
    return
16009 
 
16010 
 
16011 
  def __repr__(self):
16012 
    L = ['%s=%r' % (key, value)
16013 
      for key, value in self.__dict__.iteritems()]
16014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16015 
 
16016 
  def __eq__(self, other):
16017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16018 
 
16019 
  def __ne__(self, other):
16020 
    return not (self == other)
16021 
 
16022 
class addAuthorizationLog_args:
16023 
  """
16024 
  Attributes:
16025 
   - itemId
16026 
   - username
16027 
   - reason
16028 
  """
16029 
 
16030 
  thrift_spec = (
16031 
    None, # 0
16032 
    (1, TType.I64, 'itemId', None, None, ), # 1
16033 
    (2, TType.STRING, 'username', None, None, ), # 2
16034 
    (3, TType.STRING, 'reason', None, None, ), # 3
16035 
  )
16036 
 
16037 
  def __init__(self, itemId=None, username=None, reason=None,):
16038 
    self.itemId = itemId
16039 
    self.username = username
16040 
    self.reason = reason
16041 
 
16042 
  def read(self, iprot):
16043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16045 
      return
16046 
    iprot.readStructBegin()
16047 
    while True:
16048 
      (fname, ftype, fid) = iprot.readFieldBegin()
16049 
      if ftype == TType.STOP:
16050 
        break
16051 
      if fid == 1:
16052 
        if ftype == TType.I64:
16053 
          self.itemId = iprot.readI64();
16054 
        else:
16055 
          iprot.skip(ftype)
16056 
      elif fid == 2:
16057 
        if ftype == TType.STRING:
16058 
          self.username = iprot.readString();
16059 
        else:
16060 
          iprot.skip(ftype)
16061 
      elif fid == 3:
16062 
        if ftype == TType.STRING:
16063 
          self.reason = iprot.readString();
16064 
        else:
16065 
          iprot.skip(ftype)
16066 
      else:
16067 
        iprot.skip(ftype)
16068 
      iprot.readFieldEnd()
16069 
    iprot.readStructEnd()
16070 
 
16071 
  def write(self, oprot):
16072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16074 
      return
16075 
    oprot.writeStructBegin('addAuthorizationLog_args')
16076 
    if self.itemId is not None:
16077 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16078 
      oprot.writeI64(self.itemId)
16079 
      oprot.writeFieldEnd()
16080 
    if self.username is not None:
16081 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16082 
      oprot.writeString(self.username)
16083 
      oprot.writeFieldEnd()
16084 
    if self.reason is not None:
16085 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16086 
      oprot.writeString(self.reason)
16087 
      oprot.writeFieldEnd()
16088 
    oprot.writeFieldStop()
16089 
    oprot.writeStructEnd()
16090 
 
16091 
  def validate(self):
16092 
    return
16093 
 
16094 
 
16095 
  def __repr__(self):
16096 
    L = ['%s=%r' % (key, value)
16097 
      for key, value in self.__dict__.iteritems()]
16098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16099 
 
16100 
  def __eq__(self, other):
16101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16102 
 
16103 
  def __ne__(self, other):
16104 
    return not (self == other)
16105 
 
16106 
class addAuthorizationLog_result:
16107 
  """
16108 
  Attributes:
16109 
   - success
16110 
   - cex
16111 
  """
16112 
 
16113 
  thrift_spec = (
16114 
    (0, TType.BOOL, 'success', None, None, ), # 0
16115 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16116 
  )
16117 
 
16118 
  def __init__(self, success=None, cex=None,):
16119 
    self.success = success
16120 
    self.cex = cex
16121 
 
16122 
  def read(self, iprot):
16123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16125 
      return
16126 
    iprot.readStructBegin()
16127 
    while True:
16128 
      (fname, ftype, fid) = iprot.readFieldBegin()
16129 
      if ftype == TType.STOP:
16130 
        break
16131 
      if fid == 0:
16132 
        if ftype == TType.BOOL:
16133 
          self.success = iprot.readBool();
16134 
        else:
16135 
          iprot.skip(ftype)
16136 
      elif fid == 1:
16137 
        if ftype == TType.STRUCT:
16138 
          self.cex = CatalogServiceException()
16139 
          self.cex.read(iprot)
16140 
        else:
16141 
          iprot.skip(ftype)
16142 
      else:
16143 
        iprot.skip(ftype)
16144 
      iprot.readFieldEnd()
16145 
    iprot.readStructEnd()
16146 
 
16147 
  def write(self, oprot):
16148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16150 
      return
16151 
    oprot.writeStructBegin('addAuthorizationLog_result')
16152 
    if self.success is not None:
16153 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16154 
      oprot.writeBool(self.success)
16155 
      oprot.writeFieldEnd()
16156 
    if self.cex is not None:
16157 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16158 
      self.cex.write(oprot)
16159 
      oprot.writeFieldEnd()
16160 
    oprot.writeFieldStop()
16161 
    oprot.writeStructEnd()
16162 
 
16163 
  def validate(self):
16164 
    return
16165 
 
16166 
 
16167 
  def __repr__(self):
16168 
    L = ['%s=%r' % (key, value)
16169 
      for key, value in self.__dict__.iteritems()]
16170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16171 
 
16172 
  def __eq__(self, other):
16173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16174 
 
16175 
  def __ne__(self, other):
16176 
    return not (self == other)
16177 
 
16178 
class addupdateVoucherForItem_args:
16179 
  """
16180 
  Attributes:
16181 
   - catalog_item_id
16182 
   - voucherType
16183 
   - voucherAmount
16184 
  """
16185 
 
16186 
  thrift_spec = (
16187 
    None, # 0
16188 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16189 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16190 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
16191 
  )
16192 
 
16193 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
16194 
    self.catalog_item_id = catalog_item_id
16195 
    self.voucherType = voucherType
16196 
    self.voucherAmount = voucherAmount
16197 
 
16198 
  def read(self, iprot):
16199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16201 
      return
16202 
    iprot.readStructBegin()
16203 
    while True:
16204 
      (fname, ftype, fid) = iprot.readFieldBegin()
16205 
      if ftype == TType.STOP:
16206 
        break
16207 
      if fid == 1:
16208 
        if ftype == TType.I64:
16209 
          self.catalog_item_id = iprot.readI64();
16210 
        else:
16211 
          iprot.skip(ftype)
16212 
      elif fid == 2:
16213 
        if ftype == TType.I64:
16214 
          self.voucherType = iprot.readI64();
16215 
        else:
16216 
          iprot.skip(ftype)
16217 
      elif fid == 3:
16218 
        if ftype == TType.I64:
16219 
          self.voucherAmount = iprot.readI64();
16220 
        else:
16221 
          iprot.skip(ftype)
16222 
      else:
16223 
        iprot.skip(ftype)
16224 
      iprot.readFieldEnd()
16225 
    iprot.readStructEnd()
16226 
 
16227 
  def write(self, oprot):
16228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16230 
      return
16231 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
16232 
    if self.catalog_item_id is not None:
16233 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16234 
      oprot.writeI64(self.catalog_item_id)
16235 
      oprot.writeFieldEnd()
16236 
    if self.voucherType is not None:
16237 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16238 
      oprot.writeI64(self.voucherType)
16239 
      oprot.writeFieldEnd()
16240 
    if self.voucherAmount is not None:
16241 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
16242 
      oprot.writeI64(self.voucherAmount)
16243 
      oprot.writeFieldEnd()
16244 
    oprot.writeFieldStop()
16245 
    oprot.writeStructEnd()
16246 
 
16247 
  def validate(self):
16248 
    return
16249 
 
16250 
 
16251 
  def __repr__(self):
16252 
    L = ['%s=%r' % (key, value)
16253 
      for key, value in self.__dict__.iteritems()]
16254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16255 
 
16256 
  def __eq__(self, other):
16257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16258 
 
16259 
  def __ne__(self, other):
16260 
    return not (self == other)
16261 
 
16262 
class addupdateVoucherForItem_result:
16263 
  """
16264 
  Attributes:
16265 
   - success
16266 
   - cex
16267 
  """
16268 
 
16269 
  thrift_spec = (
16270 
    (0, TType.BOOL, 'success', None, None, ), # 0
16271 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16272 
  )
16273 
 
16274 
  def __init__(self, success=None, cex=None,):
16275 
    self.success = success
16276 
    self.cex = cex
16277 
 
16278 
  def read(self, iprot):
16279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16281 
      return
16282 
    iprot.readStructBegin()
16283 
    while True:
16284 
      (fname, ftype, fid) = iprot.readFieldBegin()
16285 
      if ftype == TType.STOP:
16286 
        break
16287 
      if fid == 0:
16288 
        if ftype == TType.BOOL:
16289 
          self.success = iprot.readBool();
16290 
        else:
16291 
          iprot.skip(ftype)
16292 
      elif fid == 1:
16293 
        if ftype == TType.STRUCT:
16294 
          self.cex = CatalogServiceException()
16295 
          self.cex.read(iprot)
16296 
        else:
16297 
          iprot.skip(ftype)
16298 
      else:
16299 
        iprot.skip(ftype)
16300 
      iprot.readFieldEnd()
16301 
    iprot.readStructEnd()
16302 
 
16303 
  def write(self, oprot):
16304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16306 
      return
16307 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
16308 
    if self.success is not None:
16309 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16310 
      oprot.writeBool(self.success)
16311 
      oprot.writeFieldEnd()
16312 
    if self.cex is not None:
16313 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16314 
      self.cex.write(oprot)
16315 
      oprot.writeFieldEnd()
16316 
    oprot.writeFieldStop()
16317 
    oprot.writeStructEnd()
16318 
 
16319 
  def validate(self):
16320 
    return
16321 
 
16322 
 
16323 
  def __repr__(self):
16324 
    L = ['%s=%r' % (key, value)
16325 
      for key, value in self.__dict__.iteritems()]
16326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16327 
 
16328 
  def __eq__(self, other):
16329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16330 
 
16331 
  def __ne__(self, other):
16332 
    return not (self == other)
16333 
 
16334 
class deleteVoucherForItem_args:
16335 
  """
16336 
  Attributes:
16337 
   - catalog_item_id
16338 
   - voucherType
16339 
  """
16340 
 
16341 
  thrift_spec = (
16342 
    None, # 0
16343 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16344 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16345 
  )
16346 
 
16347 
  def __init__(self, catalog_item_id=None, voucherType=None,):
16348 
    self.catalog_item_id = catalog_item_id
16349 
    self.voucherType = voucherType
16350 
 
16351 
  def read(self, iprot):
16352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16354 
      return
16355 
    iprot.readStructBegin()
16356 
    while True:
16357 
      (fname, ftype, fid) = iprot.readFieldBegin()
16358 
      if ftype == TType.STOP:
16359 
        break
16360 
      if fid == 1:
16361 
        if ftype == TType.I64:
16362 
          self.catalog_item_id = iprot.readI64();
16363 
        else:
16364 
          iprot.skip(ftype)
16365 
      elif fid == 2:
16366 
        if ftype == TType.I64:
16367 
          self.voucherType = iprot.readI64();
16368 
        else:
16369 
          iprot.skip(ftype)
16370 
      else:
16371 
        iprot.skip(ftype)
16372 
      iprot.readFieldEnd()
16373 
    iprot.readStructEnd()
16374 
 
16375 
  def write(self, oprot):
16376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16378 
      return
16379 
    oprot.writeStructBegin('deleteVoucherForItem_args')
16380 
    if self.catalog_item_id is not None:
16381 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16382 
      oprot.writeI64(self.catalog_item_id)
16383 
      oprot.writeFieldEnd()
16384 
    if self.voucherType is not None:
16385 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16386 
      oprot.writeI64(self.voucherType)
16387 
      oprot.writeFieldEnd()
16388 
    oprot.writeFieldStop()
16389 
    oprot.writeStructEnd()
16390 
 
16391 
  def validate(self):
16392 
    return
16393 
 
16394 
 
16395 
  def __repr__(self):
16396 
    L = ['%s=%r' % (key, value)
16397 
      for key, value in self.__dict__.iteritems()]
16398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16399 
 
16400 
  def __eq__(self, other):
16401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16402 
 
16403 
  def __ne__(self, other):
16404 
    return not (self == other)
16405 
 
16406 
class deleteVoucherForItem_result:
16407 
  """
16408 
  Attributes:
16409 
   - success
16410 
   - cex
16411 
  """
16412 
 
16413 
  thrift_spec = (
16414 
    (0, TType.BOOL, 'success', None, None, ), # 0
16415 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16416 
  )
16417 
 
16418 
  def __init__(self, success=None, cex=None,):
16419 
    self.success = success
16420 
    self.cex = cex
16421 
 
16422 
  def read(self, iprot):
16423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16425 
      return
16426 
    iprot.readStructBegin()
16427 
    while True:
16428 
      (fname, ftype, fid) = iprot.readFieldBegin()
16429 
      if ftype == TType.STOP:
16430 
        break
16431 
      if fid == 0:
16432 
        if ftype == TType.BOOL:
16433 
          self.success = iprot.readBool();
16434 
        else:
16435 
          iprot.skip(ftype)
16436 
      elif fid == 1:
16437 
        if ftype == TType.STRUCT:
16438 
          self.cex = CatalogServiceException()
16439 
          self.cex.read(iprot)
16440 
        else:
16441 
          iprot.skip(ftype)
16442 
      else:
16443 
        iprot.skip(ftype)
16444 
      iprot.readFieldEnd()
16445 
    iprot.readStructEnd()
16446 
 
16447 
  def write(self, oprot):
16448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16450 
      return
16451 
    oprot.writeStructBegin('deleteVoucherForItem_result')
16452 
    if self.success is not None:
16453 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16454 
      oprot.writeBool(self.success)
16455 
      oprot.writeFieldEnd()
16456 
    if self.cex is not None:
16457 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16458 
      self.cex.write(oprot)
16459 
      oprot.writeFieldEnd()
16460 
    oprot.writeFieldStop()
16461 
    oprot.writeStructEnd()
16462 
 
16463 
  def validate(self):
16464 
    return
16465 
 
16466 
 
16467 
  def __repr__(self):
16468 
    L = ['%s=%r' % (key, value)
16469 
      for key, value in self.__dict__.iteritems()]
16470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16471 
 
16472 
  def __eq__(self, other):
16473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16474 
 
16475 
  def __ne__(self, other):
16476 
    return not (self == other)
16477 
 
16478 
class getVoucherAmount_args:
16479 
  """
16480 
  Attributes:
16481 
   - itemId
16482 
   - voucherType
16483 
  """
16484 
 
16485 
  thrift_spec = (
16486 
    None, # 0
16487 
    (1, TType.I64, 'itemId', None, None, ), # 1
16488 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16489 
  )
16490 
 
16491 
  def __init__(self, itemId=None, voucherType=None,):
16492 
    self.itemId = itemId
16493 
    self.voucherType = voucherType
16494 
 
16495 
  def read(self, iprot):
16496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16498 
      return
16499 
    iprot.readStructBegin()
16500 
    while True:
16501 
      (fname, ftype, fid) = iprot.readFieldBegin()
16502 
      if ftype == TType.STOP:
16503 
        break
16504 
      if fid == 1:
16505 
        if ftype == TType.I64:
16506 
          self.itemId = iprot.readI64();
16507 
        else:
16508 
          iprot.skip(ftype)
16509 
      elif fid == 2:
16510 
        if ftype == TType.I64:
16511 
          self.voucherType = iprot.readI64();
16512 
        else:
16513 
          iprot.skip(ftype)
16514 
      else:
16515 
        iprot.skip(ftype)
16516 
      iprot.readFieldEnd()
16517 
    iprot.readStructEnd()
16518 
 
16519 
  def write(self, oprot):
16520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16522 
      return
16523 
    oprot.writeStructBegin('getVoucherAmount_args')
16524 
    if self.itemId is not None:
16525 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16526 
      oprot.writeI64(self.itemId)
16527 
      oprot.writeFieldEnd()
16528 
    if self.voucherType is not None:
16529 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16530 
      oprot.writeI64(self.voucherType)
16531 
      oprot.writeFieldEnd()
16532 
    oprot.writeFieldStop()
16533 
    oprot.writeStructEnd()
16534 
 
16535 
  def validate(self):
16536 
    return
16537 
 
16538 
 
16539 
  def __repr__(self):
16540 
    L = ['%s=%r' % (key, value)
16541 
      for key, value in self.__dict__.iteritems()]
16542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16543 
 
16544 
  def __eq__(self, other):
16545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16546 
 
16547 
  def __ne__(self, other):
16548 
    return not (self == other)
16549 
 
16550 
class getVoucherAmount_result:
16551 
  """
16552 
  Attributes:
16553 
   - success
16554 
  """
16555 
 
16556 
  thrift_spec = (
16557 
    (0, TType.I64, 'success', None, None, ), # 0
16558 
  )
16559 
 
16560 
  def __init__(self, success=None,):
16561 
    self.success = success
16562 
 
16563 
  def read(self, iprot):
16564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16566 
      return
16567 
    iprot.readStructBegin()
16568 
    while True:
16569 
      (fname, ftype, fid) = iprot.readFieldBegin()
16570 
      if ftype == TType.STOP:
16571 
        break
16572 
      if fid == 0:
16573 
        if ftype == TType.I64:
16574 
          self.success = iprot.readI64();
16575 
        else:
16576 
          iprot.skip(ftype)
16577 
      else:
16578 
        iprot.skip(ftype)
16579 
      iprot.readFieldEnd()
16580 
    iprot.readStructEnd()
16581 
 
16582 
  def write(self, oprot):
16583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16585 
      return
16586 
    oprot.writeStructBegin('getVoucherAmount_result')
16587 
    if self.success is not None:
16588 
      oprot.writeFieldBegin('success', TType.I64, 0)
16589 
      oprot.writeI64(self.success)
16590 
      oprot.writeFieldEnd()
16591 
    oprot.writeFieldStop()
16592 
    oprot.writeStructEnd()
16593 
 
16594 
  def validate(self):
16595 
    return
16596 
 
16597 
 
16598 
  def __repr__(self):
16599 
    L = ['%s=%r' % (key, value)
16600 
      for key, value in self.__dict__.iteritems()]
16601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16602 
 
16603 
  def __eq__(self, other):
16604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16605 
 
16606 
  def __ne__(self, other):
16607 
    return not (self == other)
16608 
 
16609 
class getAllItemVouchers_args:
16610 
  """
16611 
  Attributes:
16612 
   - itemId
16613 
  """
16614 
 
16615 
  thrift_spec = (
16616 
    None, # 0
16617 
    (1, TType.I64, 'itemId', None, None, ), # 1
16618 
  )
16619 
 
16620 
  def __init__(self, itemId=None,):
16621 
    self.itemId = itemId
16622 
 
16623 
  def read(self, iprot):
16624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16626 
      return
16627 
    iprot.readStructBegin()
16628 
    while True:
16629 
      (fname, ftype, fid) = iprot.readFieldBegin()
16630 
      if ftype == TType.STOP:
16631 
        break
16632 
      if fid == 1:
16633 
        if ftype == TType.I64:
16634 
          self.itemId = iprot.readI64();
16635 
        else:
16636 
          iprot.skip(ftype)
16637 
      else:
16638 
        iprot.skip(ftype)
16639 
      iprot.readFieldEnd()
16640 
    iprot.readStructEnd()
16641 
 
16642 
  def write(self, oprot):
16643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16645 
      return
16646 
    oprot.writeStructBegin('getAllItemVouchers_args')
16647 
    if self.itemId is not None:
16648 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16649 
      oprot.writeI64(self.itemId)
16650 
      oprot.writeFieldEnd()
16651 
    oprot.writeFieldStop()
16652 
    oprot.writeStructEnd()
16653 
 
16654 
  def validate(self):
16655 
    return
16656 
 
16657 
 
16658 
  def __repr__(self):
16659 
    L = ['%s=%r' % (key, value)
16660 
      for key, value in self.__dict__.iteritems()]
16661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16662 
 
16663 
  def __eq__(self, other):
16664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16665 
 
16666 
  def __ne__(self, other):
16667 
    return not (self == other)
16668 
 
16669 
class getAllItemVouchers_result:
16670 
  """
16671 
  Attributes:
16672 
   - success
16673 
  """
16674 
 
16675 
  thrift_spec = (
16676 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
16677 
  )
16678 
 
16679 
  def __init__(self, success=None,):
16680 
    self.success = success
16681 
 
16682 
  def read(self, iprot):
16683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16685 
      return
16686 
    iprot.readStructBegin()
16687 
    while True:
16688 
      (fname, ftype, fid) = iprot.readFieldBegin()
16689 
      if ftype == TType.STOP:
16690 
        break
16691 
      if fid == 0:
16692 
        if ftype == TType.LIST:
16693 
          self.success = []
8590 kshitij.so 16694 
          (_etype347, _size344) = iprot.readListBegin()
16695 
          for _i348 in xrange(_size344):
16696 
            _elem349 = VoucherItemMapping()
16697 
            _elem349.read(iprot)
16698 
            self.success.append(_elem349)
5944 mandeep.dh 16699 
          iprot.readListEnd()
16700 
        else:
16701 
          iprot.skip(ftype)
16702 
      else:
16703 
        iprot.skip(ftype)
16704 
      iprot.readFieldEnd()
16705 
    iprot.readStructEnd()
16706 
 
16707 
  def write(self, oprot):
16708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16710 
      return
16711 
    oprot.writeStructBegin('getAllItemVouchers_result')
16712 
    if self.success is not None:
16713 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16714 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16715 
      for iter350 in self.success:
16716 
        iter350.write(oprot)
5944 mandeep.dh 16717 
      oprot.writeListEnd()
16718 
      oprot.writeFieldEnd()
16719 
    oprot.writeFieldStop()
16720 
    oprot.writeStructEnd()
16721 
 
16722 
  def validate(self):
16723 
    return
16724 
 
16725 
 
16726 
  def __repr__(self):
16727 
    L = ['%s=%r' % (key, value)
16728 
      for key, value in self.__dict__.iteritems()]
16729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16730 
 
16731 
  def __eq__(self, other):
16732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16733 
 
16734 
  def __ne__(self, other):
16735 
    return not (self == other)
16736 
 
16737 
class isValidCatalogItemId_args:
16738 
  """
16739 
  Attributes:
16740 
   - catalog_item_id
16741 
  """
16742 
 
16743 
  thrift_spec = (
16744 
    None, # 0
16745 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16746 
  )
16747 
 
16748 
  def __init__(self, catalog_item_id=None,):
16749 
    self.catalog_item_id = catalog_item_id
16750 
 
16751 
  def read(self, iprot):
16752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16754 
      return
16755 
    iprot.readStructBegin()
16756 
    while True:
16757 
      (fname, ftype, fid) = iprot.readFieldBegin()
16758 
      if ftype == TType.STOP:
16759 
        break
16760 
      if fid == 1:
16761 
        if ftype == TType.I64:
16762 
          self.catalog_item_id = iprot.readI64();
16763 
        else:
16764 
          iprot.skip(ftype)
16765 
      else:
16766 
        iprot.skip(ftype)
16767 
      iprot.readFieldEnd()
16768 
    iprot.readStructEnd()
16769 
 
16770 
  def write(self, oprot):
16771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16773 
      return
16774 
    oprot.writeStructBegin('isValidCatalogItemId_args')
16775 
    if self.catalog_item_id is not None:
16776 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16777 
      oprot.writeI64(self.catalog_item_id)
16778 
      oprot.writeFieldEnd()
16779 
    oprot.writeFieldStop()
16780 
    oprot.writeStructEnd()
16781 
 
16782 
  def validate(self):
16783 
    return
16784 
 
16785 
 
16786 
  def __repr__(self):
16787 
    L = ['%s=%r' % (key, value)
16788 
      for key, value in self.__dict__.iteritems()]
16789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16790 
 
16791 
  def __eq__(self, other):
16792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16793 
 
16794 
  def __ne__(self, other):
16795 
    return not (self == other)
16796 
 
16797 
class isValidCatalogItemId_result:
16798 
  """
16799 
  Attributes:
16800 
   - success
16801 
  """
16802 
 
16803 
  thrift_spec = (
16804 
    (0, TType.BOOL, 'success', None, None, ), # 0
16805 
  )
16806 
 
16807 
  def __init__(self, success=None,):
16808 
    self.success = success
16809 
 
16810 
  def read(self, iprot):
16811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16813 
      return
16814 
    iprot.readStructBegin()
16815 
    while True:
16816 
      (fname, ftype, fid) = iprot.readFieldBegin()
16817 
      if ftype == TType.STOP:
16818 
        break
16819 
      if fid == 0:
16820 
        if ftype == TType.BOOL:
16821 
          self.success = iprot.readBool();
16822 
        else:
16823 
          iprot.skip(ftype)
16824 
      else:
16825 
        iprot.skip(ftype)
16826 
      iprot.readFieldEnd()
16827 
    iprot.readStructEnd()
16828 
 
16829 
  def write(self, oprot):
16830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16832 
      return
16833 
    oprot.writeStructBegin('isValidCatalogItemId_result')
16834 
    if self.success is not None:
16835 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16836 
      oprot.writeBool(self.success)
16837 
      oprot.writeFieldEnd()
16838 
    oprot.writeFieldStop()
16839 
    oprot.writeStructEnd()
16840 
 
16841 
  def validate(self):
16842 
    return
16843 
 
16844 
 
16845 
  def __repr__(self):
16846 
    L = ['%s=%r' % (key, value)
16847 
      for key, value in self.__dict__.iteritems()]
16848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16849 
 
16850 
  def __eq__(self, other):
16851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16852 
 
16853 
  def __ne__(self, other):
16854 
    return not (self == other)
6039 amit.gupta 16855 
 
16856 
class getVatPercentageForItem_args:
16857 
  """
16858 
  Attributes:
16859 
   - itemId
7330 amit.gupta 16860 
   - stateId
6039 amit.gupta 16861 
   - price
16862 
  """
16863 
 
16864 
  thrift_spec = (
16865 
    None, # 0
16866 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 16867 
    (2, TType.I64, 'stateId', None, None, ), # 2
16868 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 16869 
  )
16870 
 
7330 amit.gupta 16871 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 16872 
    self.itemId = itemId
7330 amit.gupta 16873 
    self.stateId = stateId
6039 amit.gupta 16874 
    self.price = price
16875 
 
16876 
  def read(self, iprot):
16877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16879 
      return
16880 
    iprot.readStructBegin()
16881 
    while True:
16882 
      (fname, ftype, fid) = iprot.readFieldBegin()
16883 
      if ftype == TType.STOP:
16884 
        break
16885 
      if fid == 1:
16886 
        if ftype == TType.I64:
16887 
          self.itemId = iprot.readI64();
16888 
        else:
16889 
          iprot.skip(ftype)
16890 
      elif fid == 2:
7330 amit.gupta 16891 
        if ftype == TType.I64:
16892 
          self.stateId = iprot.readI64();
16893 
        else:
16894 
          iprot.skip(ftype)
16895 
      elif fid == 3:
6039 amit.gupta 16896 
        if ftype == TType.DOUBLE:
16897 
          self.price = iprot.readDouble();
16898 
        else:
16899 
          iprot.skip(ftype)
16900 
      else:
16901 
        iprot.skip(ftype)
16902 
      iprot.readFieldEnd()
16903 
    iprot.readStructEnd()
16904 
 
16905 
  def write(self, oprot):
16906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16908 
      return
16909 
    oprot.writeStructBegin('getVatPercentageForItem_args')
16910 
    if self.itemId is not None:
16911 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16912 
      oprot.writeI64(self.itemId)
16913 
      oprot.writeFieldEnd()
7330 amit.gupta 16914 
    if self.stateId is not None:
16915 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
16916 
      oprot.writeI64(self.stateId)
16917 
      oprot.writeFieldEnd()
6039 amit.gupta 16918 
    if self.price is not None:
7330 amit.gupta 16919 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 16920 
      oprot.writeDouble(self.price)
16921 
      oprot.writeFieldEnd()
16922 
    oprot.writeFieldStop()
16923 
    oprot.writeStructEnd()
16924 
 
16925 
  def validate(self):
16926 
    return
16927 
 
16928 
 
16929 
  def __repr__(self):
16930 
    L = ['%s=%r' % (key, value)
16931 
      for key, value in self.__dict__.iteritems()]
16932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16933 
 
16934 
  def __eq__(self, other):
16935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16936 
 
16937 
  def __ne__(self, other):
16938 
    return not (self == other)
16939 
 
16940 
class getVatPercentageForItem_result:
16941 
  """
16942 
  Attributes:
16943 
   - success
7340 amit.gupta 16944 
   - cex
6039 amit.gupta 16945 
  """
16946 
 
16947 
  thrift_spec = (
16948 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 16949 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 16950 
  )
16951 
 
7340 amit.gupta 16952 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 16953 
    self.success = success
7340 amit.gupta 16954 
    self.cex = cex
6039 amit.gupta 16955 
 
16956 
  def read(self, iprot):
16957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16959 
      return
16960 
    iprot.readStructBegin()
16961 
    while True:
16962 
      (fname, ftype, fid) = iprot.readFieldBegin()
16963 
      if ftype == TType.STOP:
16964 
        break
16965 
      if fid == 0:
16966 
        if ftype == TType.DOUBLE:
16967 
          self.success = iprot.readDouble();
16968 
        else:
16969 
          iprot.skip(ftype)
7340 amit.gupta 16970 
      elif fid == 1:
16971 
        if ftype == TType.STRUCT:
16972 
          self.cex = CatalogServiceException()
16973 
          self.cex.read(iprot)
16974 
        else:
16975 
          iprot.skip(ftype)
6039 amit.gupta 16976 
      else:
16977 
        iprot.skip(ftype)
16978 
      iprot.readFieldEnd()
16979 
    iprot.readStructEnd()
16980 
 
16981 
  def write(self, oprot):
16982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16984 
      return
16985 
    oprot.writeStructBegin('getVatPercentageForItem_result')
16986 
    if self.success is not None:
16987 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
16988 
      oprot.writeDouble(self.success)
16989 
      oprot.writeFieldEnd()
7340 amit.gupta 16990 
    if self.cex is not None:
16991 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16992 
      self.cex.write(oprot)
16993 
      oprot.writeFieldEnd()
6039 amit.gupta 16994 
    oprot.writeFieldStop()
16995 
    oprot.writeStructEnd()
16996 
 
16997 
  def validate(self):
16998 
    return
16999 
 
17000 
 
17001 
  def __repr__(self):
17002 
    L = ['%s=%r' % (key, value)
17003 
      for key, value in self.__dict__.iteritems()]
17004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17005 
 
17006 
  def __eq__(self, other):
17007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17008 
 
17009 
  def __ne__(self, other):
17010 
    return not (self == other)
17011 
 
17012 
class getVatAmountForItem_args:
17013 
  """
17014 
  Attributes:
17015 
   - itemId
17016 
   - price
17017 
  """
17018 
 
17019 
  thrift_spec = (
17020 
    None, # 0
17021 
    (1, TType.I64, 'itemId', None, None, ), # 1
17022 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17023 
  )
17024 
 
17025 
  def __init__(self, itemId=None, price=None,):
17026 
    self.itemId = itemId
17027 
    self.price = price
17028 
 
17029 
  def read(self, iprot):
17030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17032 
      return
17033 
    iprot.readStructBegin()
17034 
    while True:
17035 
      (fname, ftype, fid) = iprot.readFieldBegin()
17036 
      if ftype == TType.STOP:
17037 
        break
17038 
      if fid == 1:
17039 
        if ftype == TType.I64:
17040 
          self.itemId = iprot.readI64();
17041 
        else:
17042 
          iprot.skip(ftype)
17043 
      elif fid == 2:
17044 
        if ftype == TType.DOUBLE:
17045 
          self.price = iprot.readDouble();
17046 
        else:
17047 
          iprot.skip(ftype)
17048 
      else:
17049 
        iprot.skip(ftype)
17050 
      iprot.readFieldEnd()
17051 
    iprot.readStructEnd()
17052 
 
17053 
  def write(self, oprot):
17054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17056 
      return
17057 
    oprot.writeStructBegin('getVatAmountForItem_args')
17058 
    if self.itemId is not None:
17059 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17060 
      oprot.writeI64(self.itemId)
17061 
      oprot.writeFieldEnd()
17062 
    if self.price is not None:
17063 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17064 
      oprot.writeDouble(self.price)
17065 
      oprot.writeFieldEnd()
17066 
    oprot.writeFieldStop()
17067 
    oprot.writeStructEnd()
17068 
 
17069 
  def validate(self):
17070 
    return
17071 
 
17072 
 
17073 
  def __repr__(self):
17074 
    L = ['%s=%r' % (key, value)
17075 
      for key, value in self.__dict__.iteritems()]
17076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17077 
 
17078 
  def __eq__(self, other):
17079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17080 
 
17081 
  def __ne__(self, other):
17082 
    return not (self == other)
17083 
 
17084 
class getVatAmountForItem_result:
17085 
  """
17086 
  Attributes:
17087 
   - success
17088 
  """
17089 
 
17090 
  thrift_spec = (
17091 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17092 
  )
17093 
 
17094 
  def __init__(self, success=None,):
17095 
    self.success = success
17096 
 
17097 
  def read(self, iprot):
17098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17100 
      return
17101 
    iprot.readStructBegin()
17102 
    while True:
17103 
      (fname, ftype, fid) = iprot.readFieldBegin()
17104 
      if ftype == TType.STOP:
17105 
        break
17106 
      if fid == 0:
17107 
        if ftype == TType.DOUBLE:
17108 
          self.success = iprot.readDouble();
17109 
        else:
17110 
          iprot.skip(ftype)
17111 
      else:
17112 
        iprot.skip(ftype)
17113 
      iprot.readFieldEnd()
17114 
    iprot.readStructEnd()
17115 
 
17116 
  def write(self, oprot):
17117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17119 
      return
17120 
    oprot.writeStructBegin('getVatAmountForItem_result')
17121 
    if self.success is not None:
17122 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17123 
      oprot.writeDouble(self.success)
17124 
      oprot.writeFieldEnd()
17125 
    oprot.writeFieldStop()
17126 
    oprot.writeStructEnd()
17127 
 
17128 
  def validate(self):
17129 
    return
17130 
 
17131 
 
17132 
  def __repr__(self):
17133 
    L = ['%s=%r' % (key, value)
17134 
      for key, value in self.__dict__.iteritems()]
17135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17136 
 
17137 
  def __eq__(self, other):
17138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17139 
 
17140 
  def __ne__(self, other):
17141 
    return not (self == other)
6531 vikram.rag 17142 
 
17143 
class getAllIgnoredInventoryUpdateItemsList_args:
17144 
  """
17145 
  Attributes:
17146 
   - offset
17147 
   - limit
17148 
  """
17149 
 
17150 
  thrift_spec = (
17151 
    None, # 0
17152 
    (1, TType.I32, 'offset', None, None, ), # 1
17153 
    (2, TType.I32, 'limit', None, None, ), # 2
17154 
  )
17155 
 
17156 
  def __init__(self, offset=None, limit=None,):
17157 
    self.offset = offset
17158 
    self.limit = limit
17159 
 
17160 
  def read(self, iprot):
17161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17163 
      return
17164 
    iprot.readStructBegin()
17165 
    while True:
17166 
      (fname, ftype, fid) = iprot.readFieldBegin()
17167 
      if ftype == TType.STOP:
17168 
        break
17169 
      if fid == 1:
17170 
        if ftype == TType.I32:
17171 
          self.offset = iprot.readI32();
17172 
        else:
17173 
          iprot.skip(ftype)
17174 
      elif fid == 2:
17175 
        if ftype == TType.I32:
17176 
          self.limit = iprot.readI32();
17177 
        else:
17178 
          iprot.skip(ftype)
17179 
      else:
17180 
        iprot.skip(ftype)
17181 
      iprot.readFieldEnd()
17182 
    iprot.readStructEnd()
17183 
 
17184 
  def write(self, oprot):
17185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17187 
      return
17188 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17189 
    if self.offset is not None:
17190 
      oprot.writeFieldBegin('offset', TType.I32, 1)
17191 
      oprot.writeI32(self.offset)
17192 
      oprot.writeFieldEnd()
17193 
    if self.limit is not None:
17194 
      oprot.writeFieldBegin('limit', TType.I32, 2)
17195 
      oprot.writeI32(self.limit)
17196 
      oprot.writeFieldEnd()
17197 
    oprot.writeFieldStop()
17198 
    oprot.writeStructEnd()
17199 
 
17200 
  def validate(self):
17201 
    return
17202 
 
17203 
 
17204 
  def __repr__(self):
17205 
    L = ['%s=%r' % (key, value)
17206 
      for key, value in self.__dict__.iteritems()]
17207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17208 
 
17209 
  def __eq__(self, other):
17210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17211 
 
17212 
  def __ne__(self, other):
17213 
    return not (self == other)
17214 
 
17215 
class getAllIgnoredInventoryUpdateItemsList_result:
17216 
  """
17217 
  Attributes:
17218 
   - success
17219 
  """
17220 
 
17221 
  thrift_spec = (
17222 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17223 
  )
17224 
 
17225 
  def __init__(self, success=None,):
17226 
    self.success = success
17227 
 
17228 
  def read(self, iprot):
17229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17231 
      return
17232 
    iprot.readStructBegin()
17233 
    while True:
17234 
      (fname, ftype, fid) = iprot.readFieldBegin()
17235 
      if ftype == TType.STOP:
17236 
        break
17237 
      if fid == 0:
17238 
        if ftype == TType.LIST:
17239 
          self.success = []
8590 kshitij.so 17240 
          (_etype354, _size351) = iprot.readListBegin()
17241 
          for _i355 in xrange(_size351):
17242 
            _elem356 = Item()
17243 
            _elem356.read(iprot)
17244 
            self.success.append(_elem356)
6531 vikram.rag 17245 
          iprot.readListEnd()
17246 
        else:
17247 
          iprot.skip(ftype)
17248 
      else:
17249 
        iprot.skip(ftype)
17250 
      iprot.readFieldEnd()
17251 
    iprot.readStructEnd()
17252 
 
17253 
  def write(self, oprot):
17254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17256 
      return
17257 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
17258 
    if self.success is not None:
17259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17261 
      for iter357 in self.success:
17262 
        iter357.write(oprot)
6531 vikram.rag 17263 
      oprot.writeListEnd()
17264 
      oprot.writeFieldEnd()
17265 
    oprot.writeFieldStop()
17266 
    oprot.writeStructEnd()
17267 
 
17268 
  def validate(self):
17269 
    return
17270 
 
17271 
 
17272 
  def __repr__(self):
17273 
    L = ['%s=%r' % (key, value)
17274 
      for key, value in self.__dict__.iteritems()]
17275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17276 
 
17277 
  def __eq__(self, other):
17278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17279 
 
17280 
  def __ne__(self, other):
17281 
    return not (self == other)
6805 anupam.sin 17282 
 
6821 amar.kumar 17283 
class getAllAliveItems_args:
17284 
 
17285 
  thrift_spec = (
17286 
  )
17287 
 
17288 
  def read(self, iprot):
17289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17291 
      return
17292 
    iprot.readStructBegin()
17293 
    while True:
17294 
      (fname, ftype, fid) = iprot.readFieldBegin()
17295 
      if ftype == TType.STOP:
17296 
        break
17297 
      else:
17298 
        iprot.skip(ftype)
17299 
      iprot.readFieldEnd()
17300 
    iprot.readStructEnd()
17301 
 
17302 
  def write(self, oprot):
17303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17305 
      return
17306 
    oprot.writeStructBegin('getAllAliveItems_args')
17307 
    oprot.writeFieldStop()
17308 
    oprot.writeStructEnd()
17309 
 
17310 
  def validate(self):
17311 
    return
17312 
 
17313 
 
17314 
  def __repr__(self):
17315 
    L = ['%s=%r' % (key, value)
17316 
      for key, value in self.__dict__.iteritems()]
17317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17318 
 
17319 
  def __eq__(self, other):
17320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17321 
 
17322 
  def __ne__(self, other):
17323 
    return not (self == other)
17324 
 
17325 
class getAllAliveItems_result:
17326 
  """
17327 
  Attributes:
17328 
   - success
17329 
  """
17330 
 
17331 
  thrift_spec = (
17332 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17333 
  )
17334 
 
17335 
  def __init__(self, success=None,):
17336 
    self.success = success
17337 
 
17338 
  def read(self, iprot):
17339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17341 
      return
17342 
    iprot.readStructBegin()
17343 
    while True:
17344 
      (fname, ftype, fid) = iprot.readFieldBegin()
17345 
      if ftype == TType.STOP:
17346 
        break
17347 
      if fid == 0:
17348 
        if ftype == TType.LIST:
17349 
          self.success = []
8590 kshitij.so 17350 
          (_etype361, _size358) = iprot.readListBegin()
17351 
          for _i362 in xrange(_size358):
17352 
            _elem363 = Item()
17353 
            _elem363.read(iprot)
17354 
            self.success.append(_elem363)
6821 amar.kumar 17355 
          iprot.readListEnd()
17356 
        else:
17357 
          iprot.skip(ftype)
17358 
      else:
17359 
        iprot.skip(ftype)
17360 
      iprot.readFieldEnd()
17361 
    iprot.readStructEnd()
17362 
 
17363 
  def write(self, oprot):
17364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17366 
      return
17367 
    oprot.writeStructBegin('getAllAliveItems_result')
17368 
    if self.success is not None:
17369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17370 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17371 
      for iter364 in self.success:
17372 
        iter364.write(oprot)
6821 amar.kumar 17373 
      oprot.writeListEnd()
17374 
      oprot.writeFieldEnd()
17375 
    oprot.writeFieldStop()
17376 
    oprot.writeStructEnd()
17377 
 
17378 
  def validate(self):
17379 
    return
17380 
 
17381 
 
17382 
  def __repr__(self):
17383 
    L = ['%s=%r' % (key, value)
17384 
      for key, value in self.__dict__.iteritems()]
17385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17386 
 
17387 
  def __eq__(self, other):
17388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17389 
 
17390 
  def __ne__(self, other):
17391 
    return not (self == other)
17392 
 
6805 anupam.sin 17393 
class getInsuranceAmount_args:
17394 
  """
17395 
  Attributes:
17396 
   - itemId
6921 anupam.sin 17397 
   - price
6805 anupam.sin 17398 
   - insurerId
17399 
   - quantity
17400 
  """
17401 
 
17402 
  thrift_spec = (
17403 
    None, # 0
17404 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 17405 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17406 
    (3, TType.I64, 'insurerId', None, None, ), # 3
17407 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 17408 
  )
17409 
 
6921 anupam.sin 17410 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 17411 
    self.itemId = itemId
6921 anupam.sin 17412 
    self.price = price
6805 anupam.sin 17413 
    self.insurerId = insurerId
17414 
    self.quantity = quantity
17415 
 
17416 
  def read(self, iprot):
17417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17419 
      return
17420 
    iprot.readStructBegin()
17421 
    while True:
17422 
      (fname, ftype, fid) = iprot.readFieldBegin()
17423 
      if ftype == TType.STOP:
17424 
        break
17425 
      if fid == 1:
17426 
        if ftype == TType.I64:
17427 
          self.itemId = iprot.readI64();
17428 
        else:
17429 
          iprot.skip(ftype)
17430 
      elif fid == 2:
6921 anupam.sin 17431 
        if ftype == TType.DOUBLE:
17432 
          self.price = iprot.readDouble();
17433 
        else:
17434 
          iprot.skip(ftype)
17435 
      elif fid == 3:
6805 anupam.sin 17436 
        if ftype == TType.I64:
17437 
          self.insurerId = iprot.readI64();
17438 
        else:
17439 
          iprot.skip(ftype)
6921 anupam.sin 17440 
      elif fid == 4:
6805 anupam.sin 17441 
        if ftype == TType.I64:
17442 
          self.quantity = iprot.readI64();
17443 
        else:
17444 
          iprot.skip(ftype)
17445 
      else:
17446 
        iprot.skip(ftype)
17447 
      iprot.readFieldEnd()
17448 
    iprot.readStructEnd()
17449 
 
17450 
  def write(self, oprot):
17451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17453 
      return
17454 
    oprot.writeStructBegin('getInsuranceAmount_args')
17455 
    if self.itemId is not None:
17456 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17457 
      oprot.writeI64(self.itemId)
17458 
      oprot.writeFieldEnd()
6921 anupam.sin 17459 
    if self.price is not None:
17460 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17461 
      oprot.writeDouble(self.price)
17462 
      oprot.writeFieldEnd()
6805 anupam.sin 17463 
    if self.insurerId is not None:
6921 anupam.sin 17464 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 17465 
      oprot.writeI64(self.insurerId)
17466 
      oprot.writeFieldEnd()
17467 
    if self.quantity is not None:
6921 anupam.sin 17468 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 17469 
      oprot.writeI64(self.quantity)
17470 
      oprot.writeFieldEnd()
17471 
    oprot.writeFieldStop()
17472 
    oprot.writeStructEnd()
17473 
 
17474 
  def validate(self):
17475 
    return
17476 
 
17477 
 
17478 
  def __repr__(self):
17479 
    L = ['%s=%r' % (key, value)
17480 
      for key, value in self.__dict__.iteritems()]
17481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17482 
 
17483 
  def __eq__(self, other):
17484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17485 
 
17486 
  def __ne__(self, other):
17487 
    return not (self == other)
17488 
 
17489 
class getInsuranceAmount_result:
17490 
  """
17491 
  Attributes:
17492 
   - success
17493 
  """
17494 
 
17495 
  thrift_spec = (
17496 
    (0, TType.I64, 'success', None, None, ), # 0
17497 
  )
17498 
 
17499 
  def __init__(self, success=None,):
17500 
    self.success = success
17501 
 
17502 
  def read(self, iprot):
17503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17505 
      return
17506 
    iprot.readStructBegin()
17507 
    while True:
17508 
      (fname, ftype, fid) = iprot.readFieldBegin()
17509 
      if ftype == TType.STOP:
17510 
        break
17511 
      if fid == 0:
17512 
        if ftype == TType.I64:
17513 
          self.success = iprot.readI64();
17514 
        else:
17515 
          iprot.skip(ftype)
17516 
      else:
17517 
        iprot.skip(ftype)
17518 
      iprot.readFieldEnd()
17519 
    iprot.readStructEnd()
17520 
 
17521 
  def write(self, oprot):
17522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17524 
      return
17525 
    oprot.writeStructBegin('getInsuranceAmount_result')
17526 
    if self.success is not None:
17527 
      oprot.writeFieldBegin('success', TType.I64, 0)
17528 
      oprot.writeI64(self.success)
17529 
      oprot.writeFieldEnd()
17530 
    oprot.writeFieldStop()
17531 
    oprot.writeStructEnd()
17532 
 
17533 
  def validate(self):
17534 
    return
17535 
 
17536 
 
17537 
  def __repr__(self):
17538 
    L = ['%s=%r' % (key, value)
17539 
      for key, value in self.__dict__.iteritems()]
17540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17541 
 
17542 
  def __eq__(self, other):
17543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17544 
 
17545 
  def __ne__(self, other):
17546 
    return not (self == other)
17547 
 
17548 
class getInsurer_args:
17549 
  """
17550 
  Attributes:
17551 
   - insurerId
17552 
  """
17553 
 
17554 
  thrift_spec = (
17555 
    None, # 0
17556 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17557 
  )
17558 
 
17559 
  def __init__(self, insurerId=None,):
17560 
    self.insurerId = insurerId
17561 
 
17562 
  def read(self, iprot):
17563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17565 
      return
17566 
    iprot.readStructBegin()
17567 
    while True:
17568 
      (fname, ftype, fid) = iprot.readFieldBegin()
17569 
      if ftype == TType.STOP:
17570 
        break
17571 
      if fid == 1:
17572 
        if ftype == TType.I64:
17573 
          self.insurerId = iprot.readI64();
17574 
        else:
17575 
          iprot.skip(ftype)
17576 
      else:
17577 
        iprot.skip(ftype)
17578 
      iprot.readFieldEnd()
17579 
    iprot.readStructEnd()
17580 
 
17581 
  def write(self, oprot):
17582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17584 
      return
17585 
    oprot.writeStructBegin('getInsurer_args')
17586 
    if self.insurerId is not None:
17587 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17588 
      oprot.writeI64(self.insurerId)
17589 
      oprot.writeFieldEnd()
17590 
    oprot.writeFieldStop()
17591 
    oprot.writeStructEnd()
17592 
 
17593 
  def validate(self):
17594 
    return
17595 
 
17596 
 
17597 
  def __repr__(self):
17598 
    L = ['%s=%r' % (key, value)
17599 
      for key, value in self.__dict__.iteritems()]
17600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17601 
 
17602 
  def __eq__(self, other):
17603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17604 
 
17605 
  def __ne__(self, other):
17606 
    return not (self == other)
17607 
 
17608 
class getInsurer_result:
17609 
  """
17610 
  Attributes:
17611 
   - success
17612 
  """
17613 
 
17614 
  thrift_spec = (
17615 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
17616 
  )
17617 
 
17618 
  def __init__(self, success=None,):
17619 
    self.success = success
17620 
 
17621 
  def read(self, iprot):
17622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17624 
      return
17625 
    iprot.readStructBegin()
17626 
    while True:
17627 
      (fname, ftype, fid) = iprot.readFieldBegin()
17628 
      if ftype == TType.STOP:
17629 
        break
17630 
      if fid == 0:
17631 
        if ftype == TType.STRUCT:
17632 
          self.success = Insurer()
17633 
          self.success.read(iprot)
17634 
        else:
17635 
          iprot.skip(ftype)
17636 
      else:
17637 
        iprot.skip(ftype)
17638 
      iprot.readFieldEnd()
17639 
    iprot.readStructEnd()
17640 
 
17641 
  def write(self, oprot):
17642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17644 
      return
17645 
    oprot.writeStructBegin('getInsurer_result')
17646 
    if self.success is not None:
17647 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17648 
      self.success.write(oprot)
17649 
      oprot.writeFieldEnd()
17650 
    oprot.writeFieldStop()
17651 
    oprot.writeStructEnd()
17652 
 
17653 
  def validate(self):
17654 
    return
17655 
 
17656 
 
17657 
  def __repr__(self):
17658 
    L = ['%s=%r' % (key, value)
17659 
      for key, value in self.__dict__.iteritems()]
17660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17661 
 
17662 
  def __eq__(self, other):
17663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17664 
 
17665 
  def __ne__(self, other):
17666 
    return not (self == other)
6838 vikram.rag 17667 
 
17668 
class getAllInsurers_args:
17669 
 
17670 
  thrift_spec = (
17671 
  )
17672 
 
17673 
  def read(self, iprot):
17674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17676 
      return
17677 
    iprot.readStructBegin()
17678 
    while True:
17679 
      (fname, ftype, fid) = iprot.readFieldBegin()
17680 
      if ftype == TType.STOP:
17681 
        break
17682 
      else:
17683 
        iprot.skip(ftype)
17684 
      iprot.readFieldEnd()
17685 
    iprot.readStructEnd()
17686 
 
17687 
  def write(self, oprot):
17688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17690 
      return
17691 
    oprot.writeStructBegin('getAllInsurers_args')
17692 
    oprot.writeFieldStop()
17693 
    oprot.writeStructEnd()
17694 
 
17695 
  def validate(self):
17696 
    return
17697 
 
17698 
 
17699 
  def __repr__(self):
17700 
    L = ['%s=%r' % (key, value)
17701 
      for key, value in self.__dict__.iteritems()]
17702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17703 
 
17704 
  def __eq__(self, other):
17705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17706 
 
17707 
  def __ne__(self, other):
17708 
    return not (self == other)
17709 
 
17710 
class getAllInsurers_result:
17711 
  """
17712 
  Attributes:
17713 
   - success
17714 
  """
17715 
 
17716 
  thrift_spec = (
17717 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
17718 
  )
17719 
 
17720 
  def __init__(self, success=None,):
17721 
    self.success = success
17722 
 
17723 
  def read(self, iprot):
17724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17726 
      return
17727 
    iprot.readStructBegin()
17728 
    while True:
17729 
      (fname, ftype, fid) = iprot.readFieldBegin()
17730 
      if ftype == TType.STOP:
17731 
        break
17732 
      if fid == 0:
17733 
        if ftype == TType.LIST:
17734 
          self.success = []
8590 kshitij.so 17735 
          (_etype368, _size365) = iprot.readListBegin()
17736 
          for _i369 in xrange(_size365):
17737 
            _elem370 = Insurer()
17738 
            _elem370.read(iprot)
17739 
            self.success.append(_elem370)
6838 vikram.rag 17740 
          iprot.readListEnd()
17741 
        else:
17742 
          iprot.skip(ftype)
17743 
      else:
17744 
        iprot.skip(ftype)
17745 
      iprot.readFieldEnd()
17746 
    iprot.readStructEnd()
17747 
 
17748 
  def write(self, oprot):
17749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17751 
      return
17752 
    oprot.writeStructBegin('getAllInsurers_result')
17753 
    if self.success is not None:
17754 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17755 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17756 
      for iter371 in self.success:
17757 
        iter371.write(oprot)
6838 vikram.rag 17758 
      oprot.writeListEnd()
17759 
      oprot.writeFieldEnd()
17760 
    oprot.writeFieldStop()
17761 
    oprot.writeStructEnd()
17762 
 
17763 
  def validate(self):
17764 
    return
17765 
 
17766 
 
17767 
  def __repr__(self):
17768 
    L = ['%s=%r' % (key, value)
17769 
      for key, value in self.__dict__.iteritems()]
17770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17771 
 
17772 
  def __eq__(self, other):
17773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17774 
 
17775 
  def __ne__(self, other):
17776 
    return not (self == other)
6962 rajveer 17777 
 
17778 
class updateInsuranceDeclaredAmount_args:
17779 
  """
17780 
  Attributes:
17781 
   - insurerId
17782 
   - amount
17783 
  """
17784 
 
17785 
  thrift_spec = (
17786 
    None, # 0
17787 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17788 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
17789 
  )
17790 
 
17791 
  def __init__(self, insurerId=None, amount=None,):
17792 
    self.insurerId = insurerId
17793 
    self.amount = amount
17794 
 
17795 
  def read(self, iprot):
17796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17798 
      return
17799 
    iprot.readStructBegin()
17800 
    while True:
17801 
      (fname, ftype, fid) = iprot.readFieldBegin()
17802 
      if ftype == TType.STOP:
17803 
        break
17804 
      if fid == 1:
17805 
        if ftype == TType.I64:
17806 
          self.insurerId = iprot.readI64();
17807 
        else:
17808 
          iprot.skip(ftype)
17809 
      elif fid == 2:
17810 
        if ftype == TType.DOUBLE:
17811 
          self.amount = iprot.readDouble();
17812 
        else:
17813 
          iprot.skip(ftype)
17814 
      else:
17815 
        iprot.skip(ftype)
17816 
      iprot.readFieldEnd()
17817 
    iprot.readStructEnd()
17818 
 
17819 
  def write(self, oprot):
17820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17822 
      return
17823 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
17824 
    if self.insurerId is not None:
17825 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17826 
      oprot.writeI64(self.insurerId)
17827 
      oprot.writeFieldEnd()
17828 
    if self.amount is not None:
17829 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
17830 
      oprot.writeDouble(self.amount)
17831 
      oprot.writeFieldEnd()
17832 
    oprot.writeFieldStop()
17833 
    oprot.writeStructEnd()
17834 
 
17835 
  def validate(self):
17836 
    return
17837 
 
17838 
 
17839 
  def __repr__(self):
17840 
    L = ['%s=%r' % (key, value)
17841 
      for key, value in self.__dict__.iteritems()]
17842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17843 
 
17844 
  def __eq__(self, other):
17845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17846 
 
17847 
  def __ne__(self, other):
17848 
    return not (self == other)
17849 
 
17850 
class updateInsuranceDeclaredAmount_result:
17851 
 
17852 
  thrift_spec = (
17853 
  )
17854 
 
17855 
  def read(self, iprot):
17856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17858 
      return
17859 
    iprot.readStructBegin()
17860 
    while True:
17861 
      (fname, ftype, fid) = iprot.readFieldBegin()
17862 
      if ftype == TType.STOP:
17863 
        break
17864 
      else:
17865 
        iprot.skip(ftype)
17866 
      iprot.readFieldEnd()
17867 
    iprot.readStructEnd()
17868 
 
17869 
  def write(self, oprot):
17870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17872 
      return
17873 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
17874 
    oprot.writeFieldStop()
17875 
    oprot.writeStructEnd()
17876 
 
17877 
  def validate(self):
17878 
    return
17879 
 
17880 
 
17881 
  def __repr__(self):
17882 
    L = ['%s=%r' % (key, value)
17883 
      for key, value in self.__dict__.iteritems()]
17884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17885 
 
17886 
  def __eq__(self, other):
17887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17888 
 
17889 
  def __ne__(self, other):
17890 
    return not (self == other)
7190 amar.kumar 17891 
 
17892 
class getFreebieForItem_args:
17893 
  """
17894 
  Attributes:
17895 
   - itemId
17896 
  """
17897 
 
17898 
  thrift_spec = (
17899 
    None, # 0
17900 
    (1, TType.I64, 'itemId', None, None, ), # 1
17901 
  )
17902 
 
17903 
  def __init__(self, itemId=None,):
17904 
    self.itemId = itemId
17905 
 
17906 
  def read(self, iprot):
17907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17909 
      return
17910 
    iprot.readStructBegin()
17911 
    while True:
17912 
      (fname, ftype, fid) = iprot.readFieldBegin()
17913 
      if ftype == TType.STOP:
17914 
        break
17915 
      if fid == 1:
17916 
        if ftype == TType.I64:
17917 
          self.itemId = iprot.readI64();
17918 
        else:
17919 
          iprot.skip(ftype)
17920 
      else:
17921 
        iprot.skip(ftype)
17922 
      iprot.readFieldEnd()
17923 
    iprot.readStructEnd()
17924 
 
17925 
  def write(self, oprot):
17926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17928 
      return
17929 
    oprot.writeStructBegin('getFreebieForItem_args')
17930 
    if self.itemId is not None:
17931 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17932 
      oprot.writeI64(self.itemId)
17933 
      oprot.writeFieldEnd()
17934 
    oprot.writeFieldStop()
17935 
    oprot.writeStructEnd()
17936 
 
17937 
  def validate(self):
17938 
    return
17939 
 
17940 
 
17941 
  def __repr__(self):
17942 
    L = ['%s=%r' % (key, value)
17943 
      for key, value in self.__dict__.iteritems()]
17944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17945 
 
17946 
  def __eq__(self, other):
17947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17948 
 
17949 
  def __ne__(self, other):
17950 
    return not (self == other)
17951 
 
17952 
class getFreebieForItem_result:
17953 
  """
17954 
  Attributes:
17955 
   - success
17956 
  """
17957 
 
17958 
  thrift_spec = (
17959 
    (0, TType.I64, 'success', None, None, ), # 0
17960 
  )
17961 
 
17962 
  def __init__(self, success=None,):
17963 
    self.success = success
17964 
 
17965 
  def read(self, iprot):
17966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17968 
      return
17969 
    iprot.readStructBegin()
17970 
    while True:
17971 
      (fname, ftype, fid) = iprot.readFieldBegin()
17972 
      if ftype == TType.STOP:
17973 
        break
17974 
      if fid == 0:
17975 
        if ftype == TType.I64:
17976 
          self.success = iprot.readI64();
17977 
        else:
17978 
          iprot.skip(ftype)
17979 
      else:
17980 
        iprot.skip(ftype)
17981 
      iprot.readFieldEnd()
17982 
    iprot.readStructEnd()
17983 
 
17984 
  def write(self, oprot):
17985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17987 
      return
17988 
    oprot.writeStructBegin('getFreebieForItem_result')
17989 
    if self.success is not None:
17990 
      oprot.writeFieldBegin('success', TType.I64, 0)
17991 
      oprot.writeI64(self.success)
17992 
      oprot.writeFieldEnd()
17993 
    oprot.writeFieldStop()
17994 
    oprot.writeStructEnd()
17995 
 
17996 
  def validate(self):
17997 
    return
17998 
 
17999 
 
18000 
  def __repr__(self):
18001 
    L = ['%s=%r' % (key, value)
18002 
      for key, value in self.__dict__.iteritems()]
18003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18004 
 
18005 
  def __eq__(self, other):
18006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18007 
 
18008 
  def __ne__(self, other):
18009 
    return not (self == other)
18010 
 
18011 
class addOrUpdateFreebieForItem_args:
18012 
  """
18013 
  Attributes:
18014 
   - freebieItem
18015 
  """
18016 
 
18017 
  thrift_spec = (
18018 
    None, # 0
18019 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18020 
  )
18021 
 
18022 
  def __init__(self, freebieItem=None,):
18023 
    self.freebieItem = freebieItem
18024 
 
18025 
  def read(self, iprot):
18026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18028 
      return
18029 
    iprot.readStructBegin()
18030 
    while True:
18031 
      (fname, ftype, fid) = iprot.readFieldBegin()
18032 
      if ftype == TType.STOP:
18033 
        break
18034 
      if fid == 1:
18035 
        if ftype == TType.STRUCT:
18036 
          self.freebieItem = FreebieItem()
18037 
          self.freebieItem.read(iprot)
18038 
        else:
18039 
          iprot.skip(ftype)
18040 
      else:
18041 
        iprot.skip(ftype)
18042 
      iprot.readFieldEnd()
18043 
    iprot.readStructEnd()
18044 
 
18045 
  def write(self, oprot):
18046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18048 
      return
18049 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18050 
    if self.freebieItem is not None:
18051 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18052 
      self.freebieItem.write(oprot)
18053 
      oprot.writeFieldEnd()
18054 
    oprot.writeFieldStop()
18055 
    oprot.writeStructEnd()
18056 
 
18057 
  def validate(self):
18058 
    return
18059 
 
18060 
 
18061 
  def __repr__(self):
18062 
    L = ['%s=%r' % (key, value)
18063 
      for key, value in self.__dict__.iteritems()]
18064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18065 
 
18066 
  def __eq__(self, other):
18067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18068 
 
18069 
  def __ne__(self, other):
18070 
    return not (self == other)
18071 
 
18072 
class addOrUpdateFreebieForItem_result:
18073 
 
18074 
  thrift_spec = (
18075 
  )
18076 
 
18077 
  def read(self, iprot):
18078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18080 
      return
18081 
    iprot.readStructBegin()
18082 
    while True:
18083 
      (fname, ftype, fid) = iprot.readFieldBegin()
18084 
      if ftype == TType.STOP:
18085 
        break
18086 
      else:
18087 
        iprot.skip(ftype)
18088 
      iprot.readFieldEnd()
18089 
    iprot.readStructEnd()
18090 
 
18091 
  def write(self, oprot):
18092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18094 
      return
18095 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18096 
    oprot.writeFieldStop()
18097 
    oprot.writeStructEnd()
18098 
 
18099 
  def validate(self):
18100 
    return
18101 
 
18102 
 
18103 
  def __repr__(self):
18104 
    L = ['%s=%r' % (key, value)
18105 
      for key, value in self.__dict__.iteritems()]
18106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18107 
 
18108 
  def __eq__(self, other):
18109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18110 
 
18111 
  def __ne__(self, other):
18112 
    return not (self == other)
7256 rajveer 18113 
 
7272 amit.gupta 18114 
class addOrUpdateBrandInfo_args:
18115 
  """
18116 
  Attributes:
18117 
   - brandInfo
18118 
  """
18119 
 
18120 
  thrift_spec = (
18121 
    None, # 0
18122 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18123 
  )
18124 
 
18125 
  def __init__(self, brandInfo=None,):
18126 
    self.brandInfo = brandInfo
18127 
 
18128 
  def read(self, iprot):
18129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18131 
      return
18132 
    iprot.readStructBegin()
18133 
    while True:
18134 
      (fname, ftype, fid) = iprot.readFieldBegin()
18135 
      if ftype == TType.STOP:
18136 
        break
18137 
      if fid == 1:
18138 
        if ftype == TType.STRUCT:
18139 
          self.brandInfo = BrandInfo()
18140 
          self.brandInfo.read(iprot)
18141 
        else:
18142 
          iprot.skip(ftype)
18143 
      else:
18144 
        iprot.skip(ftype)
18145 
      iprot.readFieldEnd()
18146 
    iprot.readStructEnd()
18147 
 
18148 
  def write(self, oprot):
18149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18151 
      return
18152 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18153 
    if self.brandInfo is not None:
18154 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18155 
      self.brandInfo.write(oprot)
18156 
      oprot.writeFieldEnd()
18157 
    oprot.writeFieldStop()
18158 
    oprot.writeStructEnd()
18159 
 
18160 
  def validate(self):
18161 
    return
18162 
 
18163 
 
18164 
  def __repr__(self):
18165 
    L = ['%s=%r' % (key, value)
18166 
      for key, value in self.__dict__.iteritems()]
18167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18168 
 
18169 
  def __eq__(self, other):
18170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18171 
 
18172 
  def __ne__(self, other):
18173 
    return not (self == other)
18174 
 
18175 
class addOrUpdateBrandInfo_result:
18176 
 
18177 
  thrift_spec = (
18178 
  )
18179 
 
18180 
  def read(self, iprot):
18181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18183 
      return
18184 
    iprot.readStructBegin()
18185 
    while True:
18186 
      (fname, ftype, fid) = iprot.readFieldBegin()
18187 
      if ftype == TType.STOP:
18188 
        break
18189 
      else:
18190 
        iprot.skip(ftype)
18191 
      iprot.readFieldEnd()
18192 
    iprot.readStructEnd()
18193 
 
18194 
  def write(self, oprot):
18195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18197 
      return
18198 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
18199 
    oprot.writeFieldStop()
18200 
    oprot.writeStructEnd()
18201 
 
18202 
  def validate(self):
18203 
    return
18204 
 
18205 
 
18206 
  def __repr__(self):
18207 
    L = ['%s=%r' % (key, value)
18208 
      for key, value in self.__dict__.iteritems()]
18209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18210 
 
18211 
  def __eq__(self, other):
18212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18213 
 
18214 
  def __ne__(self, other):
18215 
    return not (self == other)
18216 
 
18217 
class getBrandInfo_args:
18218 
 
18219 
  thrift_spec = (
18220 
  )
18221 
 
18222 
  def read(self, iprot):
18223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18225 
      return
18226 
    iprot.readStructBegin()
18227 
    while True:
18228 
      (fname, ftype, fid) = iprot.readFieldBegin()
18229 
      if ftype == TType.STOP:
18230 
        break
18231 
      else:
18232 
        iprot.skip(ftype)
18233 
      iprot.readFieldEnd()
18234 
    iprot.readStructEnd()
18235 
 
18236 
  def write(self, oprot):
18237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18239 
      return
18240 
    oprot.writeStructBegin('getBrandInfo_args')
18241 
    oprot.writeFieldStop()
18242 
    oprot.writeStructEnd()
18243 
 
18244 
  def validate(self):
18245 
    return
18246 
 
18247 
 
18248 
  def __repr__(self):
18249 
    L = ['%s=%r' % (key, value)
18250 
      for key, value in self.__dict__.iteritems()]
18251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18252 
 
18253 
  def __eq__(self, other):
18254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18255 
 
18256 
  def __ne__(self, other):
18257 
    return not (self == other)
18258 
 
18259 
class getBrandInfo_result:
18260 
  """
18261 
  Attributes:
18262 
   - success
18263 
  """
18264 
 
18265 
  thrift_spec = (
18266 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
18267 
  )
18268 
 
18269 
  def __init__(self, success=None,):
18270 
    self.success = success
18271 
 
18272 
  def read(self, iprot):
18273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18275 
      return
18276 
    iprot.readStructBegin()
18277 
    while True:
18278 
      (fname, ftype, fid) = iprot.readFieldBegin()
18279 
      if ftype == TType.STOP:
18280 
        break
18281 
      if fid == 0:
18282 
        if ftype == TType.MAP:
18283 
          self.success = {}
8590 kshitij.so 18284 
          (_ktype373, _vtype374, _size372 ) = iprot.readMapBegin()
18285 
          for _i376 in xrange(_size372):
18286 
            _key377 = iprot.readString();
18287 
            _val378 = BrandInfo()
18288 
            _val378.read(iprot)
18289 
            self.success[_key377] = _val378
7272 amit.gupta 18290 
          iprot.readMapEnd()
18291 
        else:
18292 
          iprot.skip(ftype)
18293 
      else:
18294 
        iprot.skip(ftype)
18295 
      iprot.readFieldEnd()
18296 
    iprot.readStructEnd()
18297 
 
18298 
  def write(self, oprot):
18299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18301 
      return
18302 
    oprot.writeStructBegin('getBrandInfo_result')
18303 
    if self.success is not None:
18304 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18305 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
8590 kshitij.so 18306 
      for kiter379,viter380 in self.success.items():
18307 
        oprot.writeString(kiter379)
18308 
        viter380.write(oprot)
7272 amit.gupta 18309 
      oprot.writeMapEnd()
18310 
      oprot.writeFieldEnd()
18311 
    oprot.writeFieldStop()
18312 
    oprot.writeStructEnd()
18313 
 
18314 
  def validate(self):
18315 
    return
18316 
 
18317 
 
18318 
  def __repr__(self):
18319 
    L = ['%s=%r' % (key, value)
18320 
      for key, value in self.__dict__.iteritems()]
18321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18322 
 
18323 
  def __eq__(self, other):
18324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18325 
 
18326 
  def __ne__(self, other):
18327 
    return not (self == other)
18328 
 
7256 rajveer 18329 
class getStorePricing_args:
18330 
  """
18331 
  Attributes:
18332 
   - itemId
18333 
  """
18334 
 
18335 
  thrift_spec = (
18336 
    None, # 0
18337 
    (1, TType.I64, 'itemId', None, None, ), # 1
18338 
  )
18339 
 
18340 
  def __init__(self, itemId=None,):
18341 
    self.itemId = itemId
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      if fid == 1:
18353 
        if ftype == TType.I64:
18354 
          self.itemId = iprot.readI64();
18355 
        else:
18356 
          iprot.skip(ftype)
18357 
      else:
18358 
        iprot.skip(ftype)
18359 
      iprot.readFieldEnd()
18360 
    iprot.readStructEnd()
18361 
 
18362 
  def write(self, oprot):
18363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18365 
      return
18366 
    oprot.writeStructBegin('getStorePricing_args')
18367 
    if self.itemId is not None:
18368 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18369 
      oprot.writeI64(self.itemId)
18370 
      oprot.writeFieldEnd()
18371 
    oprot.writeFieldStop()
18372 
    oprot.writeStructEnd()
18373 
 
18374 
  def validate(self):
18375 
    return
18376 
 
18377 
 
18378 
  def __repr__(self):
18379 
    L = ['%s=%r' % (key, value)
18380 
      for key, value in self.__dict__.iteritems()]
18381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18382 
 
18383 
  def __eq__(self, other):
18384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18385 
 
18386 
  def __ne__(self, other):
18387 
    return not (self == other)
18388 
 
18389 
class getStorePricing_result:
18390 
  """
18391 
  Attributes:
18392 
   - success
18393 
  """
18394 
 
18395 
  thrift_spec = (
18396 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
18397 
  )
18398 
 
18399 
  def __init__(self, success=None,):
18400 
    self.success = success
18401 
 
18402 
  def read(self, iprot):
18403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18405 
      return
18406 
    iprot.readStructBegin()
18407 
    while True:
18408 
      (fname, ftype, fid) = iprot.readFieldBegin()
18409 
      if ftype == TType.STOP:
18410 
        break
18411 
      if fid == 0:
18412 
        if ftype == TType.STRUCT:
18413 
          self.success = StorePricing()
18414 
          self.success.read(iprot)
18415 
        else:
18416 
          iprot.skip(ftype)
18417 
      else:
18418 
        iprot.skip(ftype)
18419 
      iprot.readFieldEnd()
18420 
    iprot.readStructEnd()
18421 
 
18422 
  def write(self, oprot):
18423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18425 
      return
18426 
    oprot.writeStructBegin('getStorePricing_result')
18427 
    if self.success is not None:
18428 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18429 
      self.success.write(oprot)
18430 
      oprot.writeFieldEnd()
18431 
    oprot.writeFieldStop()
18432 
    oprot.writeStructEnd()
18433 
 
18434 
  def validate(self):
18435 
    return
18436 
 
18437 
 
18438 
  def __repr__(self):
18439 
    L = ['%s=%r' % (key, value)
18440 
      for key, value in self.__dict__.iteritems()]
18441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18442 
 
18443 
  def __eq__(self, other):
18444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18445 
 
18446 
  def __ne__(self, other):
18447 
    return not (self == other)
7265 rajveer 18448 
 
7306 rajveer 18449 
class getStorePricings_args:
18450 
  """
18451 
  Attributes:
18452 
   - itemIds
18453 
  """
18454 
 
18455 
  thrift_spec = (
18456 
    None, # 0
18457 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18458 
  )
18459 
 
18460 
  def __init__(self, itemIds=None,):
18461 
    self.itemIds = itemIds
18462 
 
18463 
  def read(self, iprot):
18464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18466 
      return
18467 
    iprot.readStructBegin()
18468 
    while True:
18469 
      (fname, ftype, fid) = iprot.readFieldBegin()
18470 
      if ftype == TType.STOP:
18471 
        break
18472 
      if fid == 1:
18473 
        if ftype == TType.LIST:
18474 
          self.itemIds = []
8590 kshitij.so 18475 
          (_etype384, _size381) = iprot.readListBegin()
18476 
          for _i385 in xrange(_size381):
18477 
            _elem386 = iprot.readI64();
18478 
            self.itemIds.append(_elem386)
7306 rajveer 18479 
          iprot.readListEnd()
18480 
        else:
18481 
          iprot.skip(ftype)
18482 
      else:
18483 
        iprot.skip(ftype)
18484 
      iprot.readFieldEnd()
18485 
    iprot.readStructEnd()
18486 
 
18487 
  def write(self, oprot):
18488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18490 
      return
18491 
    oprot.writeStructBegin('getStorePricings_args')
18492 
    if self.itemIds is not None:
18493 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18494 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 18495 
      for iter387 in self.itemIds:
18496 
        oprot.writeI64(iter387)
7306 rajveer 18497 
      oprot.writeListEnd()
18498 
      oprot.writeFieldEnd()
18499 
    oprot.writeFieldStop()
18500 
    oprot.writeStructEnd()
18501 
 
18502 
  def validate(self):
18503 
    return
18504 
 
18505 
 
18506 
  def __repr__(self):
18507 
    L = ['%s=%r' % (key, value)
18508 
      for key, value in self.__dict__.iteritems()]
18509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18510 
 
18511 
  def __eq__(self, other):
18512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18513 
 
18514 
  def __ne__(self, other):
18515 
    return not (self == other)
18516 
 
18517 
class getStorePricings_result:
18518 
  """
18519 
  Attributes:
18520 
   - success
18521 
  """
18522 
 
18523 
  thrift_spec = (
18524 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
18525 
  )
18526 
 
18527 
  def __init__(self, success=None,):
18528 
    self.success = success
18529 
 
18530 
  def read(self, iprot):
18531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18533 
      return
18534 
    iprot.readStructBegin()
18535 
    while True:
18536 
      (fname, ftype, fid) = iprot.readFieldBegin()
18537 
      if ftype == TType.STOP:
18538 
        break
18539 
      if fid == 0:
18540 
        if ftype == TType.LIST:
18541 
          self.success = []
8590 kshitij.so 18542 
          (_etype391, _size388) = iprot.readListBegin()
18543 
          for _i392 in xrange(_size388):
18544 
            _elem393 = StorePricing()
18545 
            _elem393.read(iprot)
18546 
            self.success.append(_elem393)
7306 rajveer 18547 
          iprot.readListEnd()
18548 
        else:
18549 
          iprot.skip(ftype)
18550 
      else:
18551 
        iprot.skip(ftype)
18552 
      iprot.readFieldEnd()
18553 
    iprot.readStructEnd()
18554 
 
18555 
  def write(self, oprot):
18556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18558 
      return
18559 
    oprot.writeStructBegin('getStorePricings_result')
18560 
    if self.success is not None:
18561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18562 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 18563 
      for iter394 in self.success:
18564 
        iter394.write(oprot)
7306 rajveer 18565 
      oprot.writeListEnd()
18566 
      oprot.writeFieldEnd()
18567 
    oprot.writeFieldStop()
18568 
    oprot.writeStructEnd()
18569 
 
18570 
  def validate(self):
18571 
    return
18572 
 
18573 
 
18574 
  def __repr__(self):
18575 
    L = ['%s=%r' % (key, value)
18576 
      for key, value in self.__dict__.iteritems()]
18577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18578 
 
18579 
  def __eq__(self, other):
18580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18581 
 
18582 
  def __ne__(self, other):
18583 
    return not (self == other)
18584 
 
7265 rajveer 18585 
class updateStorePricing_args:
18586 
  """
18587 
  Attributes:
18588 
   - sp
7382 rajveer 18589 
   - allColors
7265 rajveer 18590 
  """
18591 
 
18592 
  thrift_spec = (
18593 
    None, # 0
18594 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 18595 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 18596 
  )
18597 
 
7382 rajveer 18598 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 18599 
    self.sp = sp
7382 rajveer 18600 
    self.allColors = allColors
7265 rajveer 18601 
 
18602 
  def read(self, iprot):
18603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18605 
      return
18606 
    iprot.readStructBegin()
18607 
    while True:
18608 
      (fname, ftype, fid) = iprot.readFieldBegin()
18609 
      if ftype == TType.STOP:
18610 
        break
18611 
      if fid == 1:
18612 
        if ftype == TType.STRUCT:
18613 
          self.sp = StorePricing()
18614 
          self.sp.read(iprot)
18615 
        else:
18616 
          iprot.skip(ftype)
7382 rajveer 18617 
      elif fid == 2:
18618 
        if ftype == TType.BOOL:
18619 
          self.allColors = iprot.readBool();
18620 
        else:
18621 
          iprot.skip(ftype)
7265 rajveer 18622 
      else:
18623 
        iprot.skip(ftype)
18624 
      iprot.readFieldEnd()
18625 
    iprot.readStructEnd()
18626 
 
18627 
  def write(self, oprot):
18628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18630 
      return
18631 
    oprot.writeStructBegin('updateStorePricing_args')
18632 
    if self.sp is not None:
18633 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
18634 
      self.sp.write(oprot)
18635 
      oprot.writeFieldEnd()
7382 rajveer 18636 
    if self.allColors is not None:
18637 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
18638 
      oprot.writeBool(self.allColors)
18639 
      oprot.writeFieldEnd()
7265 rajveer 18640 
    oprot.writeFieldStop()
18641 
    oprot.writeStructEnd()
18642 
 
18643 
  def validate(self):
18644 
    return
18645 
 
18646 
 
18647 
  def __repr__(self):
18648 
    L = ['%s=%r' % (key, value)
18649 
      for key, value in self.__dict__.iteritems()]
18650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18651 
 
18652 
  def __eq__(self, other):
18653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18654 
 
18655 
  def __ne__(self, other):
18656 
    return not (self == other)
18657 
 
18658 
class updateStorePricing_result:
18659 
 
18660 
  thrift_spec = (
18661 
  )
18662 
 
18663 
  def read(self, iprot):
18664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18666 
      return
18667 
    iprot.readStructBegin()
18668 
    while True:
18669 
      (fname, ftype, fid) = iprot.readFieldBegin()
18670 
      if ftype == TType.STOP:
18671 
        break
18672 
      else:
18673 
        iprot.skip(ftype)
18674 
      iprot.readFieldEnd()
18675 
    iprot.readStructEnd()
18676 
 
18677 
  def write(self, oprot):
18678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18680 
      return
18681 
    oprot.writeStructBegin('updateStorePricing_result')
18682 
    oprot.writeFieldStop()
18683 
    oprot.writeStructEnd()
18684 
 
18685 
  def validate(self):
18686 
    return
18687 
 
18688 
 
18689 
  def __repr__(self):
18690 
    L = ['%s=%r' % (key, value)
18691 
      for key, value in self.__dict__.iteritems()]
18692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18693 
 
18694 
  def __eq__(self, other):
18695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18696 
 
18697 
  def __ne__(self, other):
18698 
    return not (self == other)
7281 kshitij.so 18699 
 
18700 
class getAllAmazonListedItems_args:
18701 
 
18702 
  thrift_spec = (
18703 
  )
18704 
 
18705 
  def read(self, iprot):
18706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18708 
      return
18709 
    iprot.readStructBegin()
18710 
    while True:
18711 
      (fname, ftype, fid) = iprot.readFieldBegin()
18712 
      if ftype == TType.STOP:
18713 
        break
18714 
      else:
18715 
        iprot.skip(ftype)
18716 
      iprot.readFieldEnd()
18717 
    iprot.readStructEnd()
18718 
 
18719 
  def write(self, oprot):
18720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18722 
      return
18723 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
18724 
    oprot.writeFieldStop()
18725 
    oprot.writeStructEnd()
18726 
 
18727 
  def validate(self):
18728 
    return
18729 
 
18730 
 
18731 
  def __repr__(self):
18732 
    L = ['%s=%r' % (key, value)
18733 
      for key, value in self.__dict__.iteritems()]
18734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18735 
 
18736 
  def __eq__(self, other):
18737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18738 
 
18739 
  def __ne__(self, other):
18740 
    return not (self == other)
18741 
 
18742 
class getAllAmazonListedItems_result:
18743 
  """
18744 
  Attributes:
18745 
   - success
18746 
  """
18747 
 
18748 
  thrift_spec = (
18749 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18750 
  )
18751 
 
18752 
  def __init__(self, success=None,):
18753 
    self.success = success
18754 
 
18755 
  def read(self, iprot):
18756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18758 
      return
18759 
    iprot.readStructBegin()
18760 
    while True:
18761 
      (fname, ftype, fid) = iprot.readFieldBegin()
18762 
      if ftype == TType.STOP:
18763 
        break
18764 
      if fid == 0:
18765 
        if ftype == TType.LIST:
18766 
          self.success = []
8590 kshitij.so 18767 
          (_etype398, _size395) = iprot.readListBegin()
18768 
          for _i399 in xrange(_size395):
18769 
            _elem400 = Amazonlisted()
18770 
            _elem400.read(iprot)
18771 
            self.success.append(_elem400)
7281 kshitij.so 18772 
          iprot.readListEnd()
18773 
        else:
18774 
          iprot.skip(ftype)
18775 
      else:
18776 
        iprot.skip(ftype)
18777 
      iprot.readFieldEnd()
18778 
    iprot.readStructEnd()
18779 
 
18780 
  def write(self, oprot):
18781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18783 
      return
18784 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
18785 
    if self.success is not None:
18786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 18788 
      for iter401 in self.success:
18789 
        iter401.write(oprot)
7281 kshitij.so 18790 
      oprot.writeListEnd()
18791 
      oprot.writeFieldEnd()
18792 
    oprot.writeFieldStop()
18793 
    oprot.writeStructEnd()
18794 
 
18795 
  def validate(self):
18796 
    return
18797 
 
18798 
 
18799 
  def __repr__(self):
18800 
    L = ['%s=%r' % (key, value)
18801 
      for key, value in self.__dict__.iteritems()]
18802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18803 
 
18804 
  def __eq__(self, other):
18805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18806 
 
18807 
  def __ne__(self, other):
18808 
    return not (self == other)
18809 
 
18810 
class getAmazonItemDetails_args:
18811 
  """
18812 
  Attributes:
18813 
   - itemId
18814 
  """
18815 
 
18816 
  thrift_spec = (
18817 
    None, # 0
18818 
    (1, TType.I64, 'itemId', None, None, ), # 1
18819 
  )
18820 
 
18821 
  def __init__(self, itemId=None,):
18822 
    self.itemId = itemId
18823 
 
18824 
  def read(self, iprot):
18825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18827 
      return
18828 
    iprot.readStructBegin()
18829 
    while True:
18830 
      (fname, ftype, fid) = iprot.readFieldBegin()
18831 
      if ftype == TType.STOP:
18832 
        break
18833 
      if fid == 1:
18834 
        if ftype == TType.I64:
18835 
          self.itemId = iprot.readI64();
18836 
        else:
18837 
          iprot.skip(ftype)
18838 
      else:
18839 
        iprot.skip(ftype)
18840 
      iprot.readFieldEnd()
18841 
    iprot.readStructEnd()
18842 
 
18843 
  def write(self, oprot):
18844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18846 
      return
18847 
    oprot.writeStructBegin('getAmazonItemDetails_args')
18848 
    if self.itemId is not None:
18849 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18850 
      oprot.writeI64(self.itemId)
18851 
      oprot.writeFieldEnd()
18852 
    oprot.writeFieldStop()
18853 
    oprot.writeStructEnd()
18854 
 
18855 
  def validate(self):
18856 
    return
18857 
 
18858 
 
18859 
  def __repr__(self):
18860 
    L = ['%s=%r' % (key, value)
18861 
      for key, value in self.__dict__.iteritems()]
18862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18863 
 
18864 
  def __eq__(self, other):
18865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18866 
 
18867 
  def __ne__(self, other):
18868 
    return not (self == other)
18869 
 
18870 
class getAmazonItemDetails_result:
18871 
  """
18872 
  Attributes:
18873 
   - success
18874 
  """
18875 
 
18876 
  thrift_spec = (
18877 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
18878 
  )
18879 
 
18880 
  def __init__(self, success=None,):
18881 
    self.success = success
18882 
 
18883 
  def read(self, iprot):
18884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18886 
      return
18887 
    iprot.readStructBegin()
18888 
    while True:
18889 
      (fname, ftype, fid) = iprot.readFieldBegin()
18890 
      if ftype == TType.STOP:
18891 
        break
18892 
      if fid == 0:
18893 
        if ftype == TType.STRUCT:
18894 
          self.success = Amazonlisted()
18895 
          self.success.read(iprot)
18896 
        else:
18897 
          iprot.skip(ftype)
18898 
      else:
18899 
        iprot.skip(ftype)
18900 
      iprot.readFieldEnd()
18901 
    iprot.readStructEnd()
18902 
 
18903 
  def write(self, oprot):
18904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18906 
      return
18907 
    oprot.writeStructBegin('getAmazonItemDetails_result')
18908 
    if self.success is not None:
18909 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18910 
      self.success.write(oprot)
18911 
      oprot.writeFieldEnd()
18912 
    oprot.writeFieldStop()
18913 
    oprot.writeStructEnd()
18914 
 
18915 
  def validate(self):
18916 
    return
18917 
 
18918 
 
18919 
  def __repr__(self):
18920 
    L = ['%s=%r' % (key, value)
18921 
      for key, value in self.__dict__.iteritems()]
18922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18923 
 
18924 
  def __eq__(self, other):
18925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18926 
 
18927 
  def __ne__(self, other):
18928 
    return not (self == other)
18929 
 
18930 
class updateAmazonItemDetails_args:
18931 
  """
18932 
  Attributes:
8168 kshitij.so 18933 
   - amazonlisted
7281 kshitij.so 18934 
  """
18935 
 
18936 
  thrift_spec = (
18937 
    None, # 0
8168 kshitij.so 18938 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 18939 
  )
18940 
 
8168 kshitij.so 18941 
  def __init__(self, amazonlisted=None,):
18942 
    self.amazonlisted = amazonlisted
7281 kshitij.so 18943 
 
18944 
  def read(self, iprot):
18945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18947 
      return
18948 
    iprot.readStructBegin()
18949 
    while True:
18950 
      (fname, ftype, fid) = iprot.readFieldBegin()
18951 
      if ftype == TType.STOP:
18952 
        break
18953 
      if fid == 1:
8168 kshitij.so 18954 
        if ftype == TType.STRUCT:
18955 
          self.amazonlisted = Amazonlisted()
18956 
          self.amazonlisted.read(iprot)
7281 kshitij.so 18957 
        else:
18958 
          iprot.skip(ftype)
18959 
      else:
18960 
        iprot.skip(ftype)
18961 
      iprot.readFieldEnd()
18962 
    iprot.readStructEnd()
18963 
 
18964 
  def write(self, oprot):
18965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18967 
      return
18968 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 18969 
    if self.amazonlisted is not None:
18970 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
18971 
      self.amazonlisted.write(oprot)
7281 kshitij.so 18972 
      oprot.writeFieldEnd()
18973 
    oprot.writeFieldStop()
18974 
    oprot.writeStructEnd()
18975 
 
18976 
  def validate(self):
18977 
    return
18978 
 
18979 
 
18980 
  def __repr__(self):
18981 
    L = ['%s=%r' % (key, value)
18982 
      for key, value in self.__dict__.iteritems()]
18983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18984 
 
18985 
  def __eq__(self, other):
18986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18987 
 
18988 
  def __ne__(self, other):
18989 
    return not (self == other)
18990 
 
18991 
class updateAmazonItemDetails_result:
18992 
 
18993 
  thrift_spec = (
18994 
  )
18995 
 
18996 
  def read(self, iprot):
18997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18999 
      return
19000 
    iprot.readStructBegin()
19001 
    while True:
19002 
      (fname, ftype, fid) = iprot.readFieldBegin()
19003 
      if ftype == TType.STOP:
19004 
        break
19005 
      else:
19006 
        iprot.skip(ftype)
19007 
      iprot.readFieldEnd()
19008 
    iprot.readStructEnd()
19009 
 
19010 
  def write(self, oprot):
19011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19013 
      return
19014 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
19015 
    oprot.writeFieldStop()
19016 
    oprot.writeStructEnd()
19017 
 
19018 
  def validate(self):
19019 
    return
19020 
 
19021 
 
19022 
  def __repr__(self):
19023 
    L = ['%s=%r' % (key, value)
19024 
      for key, value in self.__dict__.iteritems()]
19025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19026 
 
19027 
  def __eq__(self, other):
19028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19029 
 
19030 
  def __ne__(self, other):
19031 
    return not (self == other)
19032 
 
19033 
class addAmazonItem_args:
19034 
  """
19035 
  Attributes:
19036 
   - amazonlisted
19037 
  """
19038 
 
19039 
  thrift_spec = (
19040 
    None, # 0
19041 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
19042 
  )
19043 
 
19044 
  def __init__(self, amazonlisted=None,):
19045 
    self.amazonlisted = amazonlisted
19046 
 
19047 
  def read(self, iprot):
19048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19050 
      return
19051 
    iprot.readStructBegin()
19052 
    while True:
19053 
      (fname, ftype, fid) = iprot.readFieldBegin()
19054 
      if ftype == TType.STOP:
19055 
        break
19056 
      if fid == 1:
19057 
        if ftype == TType.STRUCT:
19058 
          self.amazonlisted = Amazonlisted()
19059 
          self.amazonlisted.read(iprot)
19060 
        else:
19061 
          iprot.skip(ftype)
19062 
      else:
19063 
        iprot.skip(ftype)
19064 
      iprot.readFieldEnd()
19065 
    iprot.readStructEnd()
19066 
 
19067 
  def write(self, oprot):
19068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19070 
      return
19071 
    oprot.writeStructBegin('addAmazonItem_args')
19072 
    if self.amazonlisted is not None:
19073 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19074 
      self.amazonlisted.write(oprot)
19075 
      oprot.writeFieldEnd()
19076 
    oprot.writeFieldStop()
19077 
    oprot.writeStructEnd()
19078 
 
19079 
  def validate(self):
19080 
    return
19081 
 
19082 
 
19083 
  def __repr__(self):
19084 
    L = ['%s=%r' % (key, value)
19085 
      for key, value in self.__dict__.iteritems()]
19086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19087 
 
19088 
  def __eq__(self, other):
19089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19090 
 
19091 
  def __ne__(self, other):
19092 
    return not (self == other)
19093 
 
19094 
class addAmazonItem_result:
19095 
 
19096 
  thrift_spec = (
19097 
  )
19098 
 
19099 
  def read(self, iprot):
19100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19102 
      return
19103 
    iprot.readStructBegin()
19104 
    while True:
19105 
      (fname, ftype, fid) = iprot.readFieldBegin()
19106 
      if ftype == TType.STOP:
19107 
        break
19108 
      else:
19109 
        iprot.skip(ftype)
19110 
      iprot.readFieldEnd()
19111 
    iprot.readStructEnd()
19112 
 
19113 
  def write(self, oprot):
19114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19116 
      return
19117 
    oprot.writeStructBegin('addAmazonItem_result')
19118 
    oprot.writeFieldStop()
19119 
    oprot.writeStructEnd()
19120 
 
19121 
  def validate(self):
19122 
    return
19123 
 
19124 
 
19125 
  def __repr__(self):
19126 
    L = ['%s=%r' % (key, value)
19127 
      for key, value in self.__dict__.iteritems()]
19128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19129 
 
19130 
  def __eq__(self, other):
19131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19132 
 
19133 
  def __ne__(self, other):
19134 
    return not (self == other)
7291 vikram.rag 19135 
 
19136 
class getAsinItems_args:
19137 
 
19138 
  thrift_spec = (
19139 
  )
19140 
 
19141 
  def read(self, iprot):
19142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19144 
      return
19145 
    iprot.readStructBegin()
19146 
    while True:
19147 
      (fname, ftype, fid) = iprot.readFieldBegin()
19148 
      if ftype == TType.STOP:
19149 
        break
19150 
      else:
19151 
        iprot.skip(ftype)
19152 
      iprot.readFieldEnd()
19153 
    iprot.readStructEnd()
19154 
 
19155 
  def write(self, oprot):
19156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19158 
      return
19159 
    oprot.writeStructBegin('getAsinItems_args')
19160 
    oprot.writeFieldStop()
19161 
    oprot.writeStructEnd()
19162 
 
19163 
  def validate(self):
19164 
    return
19165 
 
19166 
 
19167 
  def __repr__(self):
19168 
    L = ['%s=%r' % (key, value)
19169 
      for key, value in self.__dict__.iteritems()]
19170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19171 
 
19172 
  def __eq__(self, other):
19173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19174 
 
19175 
  def __ne__(self, other):
19176 
    return not (self == other)
19177 
 
19178 
class getAsinItems_result:
19179 
  """
19180 
  Attributes:
19181 
   - success
19182 
  """
19183 
 
19184 
  thrift_spec = (
19185 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19186 
  )
19187 
 
19188 
  def __init__(self, success=None,):
19189 
    self.success = success
19190 
 
19191 
  def read(self, iprot):
19192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19194 
      return
19195 
    iprot.readStructBegin()
19196 
    while True:
19197 
      (fname, ftype, fid) = iprot.readFieldBegin()
19198 
      if ftype == TType.STOP:
19199 
        break
19200 
      if fid == 0:
19201 
        if ftype == TType.LIST:
19202 
          self.success = []
8590 kshitij.so 19203 
          (_etype405, _size402) = iprot.readListBegin()
19204 
          for _i406 in xrange(_size402):
19205 
            _elem407 = Item()
19206 
            _elem407.read(iprot)
19207 
            self.success.append(_elem407)
7291 vikram.rag 19208 
          iprot.readListEnd()
19209 
        else:
19210 
          iprot.skip(ftype)
19211 
      else:
19212 
        iprot.skip(ftype)
19213 
      iprot.readFieldEnd()
19214 
    iprot.readStructEnd()
19215 
 
19216 
  def write(self, oprot):
19217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19219 
      return
19220 
    oprot.writeStructBegin('getAsinItems_result')
19221 
    if self.success is not None:
19222 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19223 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19224 
      for iter408 in self.success:
19225 
        iter408.write(oprot)
7291 vikram.rag 19226 
      oprot.writeListEnd()
19227 
      oprot.writeFieldEnd()
19228 
    oprot.writeFieldStop()
19229 
    oprot.writeStructEnd()
19230 
 
19231 
  def validate(self):
19232 
    return
19233 
 
19234 
 
19235 
  def __repr__(self):
19236 
    L = ['%s=%r' % (key, value)
19237 
      for key, value in self.__dict__.iteritems()]
19238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19239 
 
19240 
  def __eq__(self, other):
19241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19242 
 
19243 
  def __ne__(self, other):
19244 
    return not (self == other)
19245 
 
19246 
class getAllFbaListedItems_args:
19247 
 
19248 
  thrift_spec = (
19249 
  )
19250 
 
19251 
  def read(self, iprot):
19252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19254 
      return
19255 
    iprot.readStructBegin()
19256 
    while True:
19257 
      (fname, ftype, fid) = iprot.readFieldBegin()
19258 
      if ftype == TType.STOP:
19259 
        break
19260 
      else:
19261 
        iprot.skip(ftype)
19262 
      iprot.readFieldEnd()
19263 
    iprot.readStructEnd()
19264 
 
19265 
  def write(self, oprot):
19266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19268 
      return
19269 
    oprot.writeStructBegin('getAllFbaListedItems_args')
19270 
    oprot.writeFieldStop()
19271 
    oprot.writeStructEnd()
19272 
 
19273 
  def validate(self):
19274 
    return
19275 
 
19276 
 
19277 
  def __repr__(self):
19278 
    L = ['%s=%r' % (key, value)
19279 
      for key, value in self.__dict__.iteritems()]
19280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19281 
 
19282 
  def __eq__(self, other):
19283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19284 
 
19285 
  def __ne__(self, other):
19286 
    return not (self == other)
19287 
 
19288 
class getAllFbaListedItems_result:
19289 
  """
19290 
  Attributes:
19291 
   - success
19292 
  """
19293 
 
19294 
  thrift_spec = (
19295 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19296 
  )
19297 
 
19298 
  def __init__(self, success=None,):
19299 
    self.success = success
19300 
 
19301 
  def read(self, iprot):
19302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19304 
      return
19305 
    iprot.readStructBegin()
19306 
    while True:
19307 
      (fname, ftype, fid) = iprot.readFieldBegin()
19308 
      if ftype == TType.STOP:
19309 
        break
19310 
      if fid == 0:
19311 
        if ftype == TType.LIST:
19312 
          self.success = []
8590 kshitij.so 19313 
          (_etype412, _size409) = iprot.readListBegin()
19314 
          for _i413 in xrange(_size409):
19315 
            _elem414 = Amazonlisted()
19316 
            _elem414.read(iprot)
19317 
            self.success.append(_elem414)
7291 vikram.rag 19318 
          iprot.readListEnd()
19319 
        else:
19320 
          iprot.skip(ftype)
19321 
      else:
19322 
        iprot.skip(ftype)
19323 
      iprot.readFieldEnd()
19324 
    iprot.readStructEnd()
19325 
 
19326 
  def write(self, oprot):
19327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19329 
      return
19330 
    oprot.writeStructBegin('getAllFbaListedItems_result')
19331 
    if self.success is not None:
19332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19334 
      for iter415 in self.success:
19335 
        iter415.write(oprot)
7291 vikram.rag 19336 
      oprot.writeListEnd()
19337 
      oprot.writeFieldEnd()
19338 
    oprot.writeFieldStop()
19339 
    oprot.writeStructEnd()
19340 
 
19341 
  def validate(self):
19342 
    return
19343 
 
19344 
 
19345 
  def __repr__(self):
19346 
    L = ['%s=%r' % (key, value)
19347 
      for key, value in self.__dict__.iteritems()]
19348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19349 
 
19350 
  def __eq__(self, other):
19351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19352 
 
19353 
  def __ne__(self, other):
19354 
    return not (self == other)
19355 
 
19356 
class getAllNonFbaListedItems_args:
19357 
 
19358 
  thrift_spec = (
19359 
  )
19360 
 
19361 
  def read(self, iprot):
19362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19364 
      return
19365 
    iprot.readStructBegin()
19366 
    while True:
19367 
      (fname, ftype, fid) = iprot.readFieldBegin()
19368 
      if ftype == TType.STOP:
19369 
        break
19370 
      else:
19371 
        iprot.skip(ftype)
19372 
      iprot.readFieldEnd()
19373 
    iprot.readStructEnd()
19374 
 
19375 
  def write(self, oprot):
19376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19378 
      return
19379 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
19380 
    oprot.writeFieldStop()
19381 
    oprot.writeStructEnd()
19382 
 
19383 
  def validate(self):
19384 
    return
19385 
 
19386 
 
19387 
  def __repr__(self):
19388 
    L = ['%s=%r' % (key, value)
19389 
      for key, value in self.__dict__.iteritems()]
19390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19391 
 
19392 
  def __eq__(self, other):
19393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19394 
 
19395 
  def __ne__(self, other):
19396 
    return not (self == other)
19397 
 
19398 
class getAllNonFbaListedItems_result:
19399 
  """
19400 
  Attributes:
19401 
   - success
19402 
  """
19403 
 
19404 
  thrift_spec = (
19405 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19406 
  )
19407 
 
19408 
  def __init__(self, success=None,):
19409 
    self.success = success
19410 
 
19411 
  def read(self, iprot):
19412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19414 
      return
19415 
    iprot.readStructBegin()
19416 
    while True:
19417 
      (fname, ftype, fid) = iprot.readFieldBegin()
19418 
      if ftype == TType.STOP:
19419 
        break
19420 
      if fid == 0:
19421 
        if ftype == TType.LIST:
19422 
          self.success = []
8590 kshitij.so 19423 
          (_etype419, _size416) = iprot.readListBegin()
19424 
          for _i420 in xrange(_size416):
19425 
            _elem421 = Amazonlisted()
19426 
            _elem421.read(iprot)
19427 
            self.success.append(_elem421)
7291 vikram.rag 19428 
          iprot.readListEnd()
19429 
        else:
19430 
          iprot.skip(ftype)
19431 
      else:
19432 
        iprot.skip(ftype)
19433 
      iprot.readFieldEnd()
19434 
    iprot.readStructEnd()
19435 
 
19436 
  def write(self, oprot):
19437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19439 
      return
19440 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
19441 
    if self.success is not None:
19442 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19443 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19444 
      for iter422 in self.success:
19445 
        iter422.write(oprot)
7291 vikram.rag 19446 
      oprot.writeListEnd()
19447 
      oprot.writeFieldEnd()
19448 
    oprot.writeFieldStop()
19449 
    oprot.writeStructEnd()
19450 
 
19451 
  def validate(self):
19452 
    return
19453 
 
19454 
 
19455 
  def __repr__(self):
19456 
    L = ['%s=%r' % (key, value)
19457 
      for key, value in self.__dict__.iteritems()]
19458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19459 
 
19460 
  def __eq__(self, other):
19461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19462 
 
19463 
  def __ne__(self, other):
19464 
    return not (self == other)
7460 kshitij.so 19465 
 
19466 
class updateItemInventory_args:
19467 
  """
19468 
  Attributes:
19469 
   - itemId
19470 
   - holdInventory
19471 
   - defaultInventory
19472 
  """
19473 
 
19474 
  thrift_spec = (
19475 
    None, # 0
19476 
    (1, TType.I64, 'itemId', None, None, ), # 1
19477 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
19478 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
19479 
  )
19480 
 
19481 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
19482 
    self.itemId = itemId
19483 
    self.holdInventory = holdInventory
19484 
    self.defaultInventory = defaultInventory
19485 
 
19486 
  def read(self, iprot):
19487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19489 
      return
19490 
    iprot.readStructBegin()
19491 
    while True:
19492 
      (fname, ftype, fid) = iprot.readFieldBegin()
19493 
      if ftype == TType.STOP:
19494 
        break
19495 
      if fid == 1:
19496 
        if ftype == TType.I64:
19497 
          self.itemId = iprot.readI64();
19498 
        else:
19499 
          iprot.skip(ftype)
19500 
      elif fid == 2:
19501 
        if ftype == TType.I64:
19502 
          self.holdInventory = iprot.readI64();
19503 
        else:
19504 
          iprot.skip(ftype)
19505 
      elif fid == 3:
19506 
        if ftype == TType.I64:
19507 
          self.defaultInventory = iprot.readI64();
19508 
        else:
19509 
          iprot.skip(ftype)
19510 
      else:
19511 
        iprot.skip(ftype)
19512 
      iprot.readFieldEnd()
19513 
    iprot.readStructEnd()
19514 
 
19515 
  def write(self, oprot):
19516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19518 
      return
19519 
    oprot.writeStructBegin('updateItemInventory_args')
19520 
    if self.itemId is not None:
19521 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19522 
      oprot.writeI64(self.itemId)
19523 
      oprot.writeFieldEnd()
19524 
    if self.holdInventory is not None:
19525 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
19526 
      oprot.writeI64(self.holdInventory)
19527 
      oprot.writeFieldEnd()
19528 
    if self.defaultInventory is not None:
19529 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
19530 
      oprot.writeI64(self.defaultInventory)
19531 
      oprot.writeFieldEnd()
19532 
    oprot.writeFieldStop()
19533 
    oprot.writeStructEnd()
19534 
 
19535 
  def validate(self):
19536 
    return
19537 
 
19538 
 
19539 
  def __repr__(self):
19540 
    L = ['%s=%r' % (key, value)
19541 
      for key, value in self.__dict__.iteritems()]
19542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19543 
 
19544 
  def __eq__(self, other):
19545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19546 
 
19547 
  def __ne__(self, other):
19548 
    return not (self == other)
19549 
 
19550 
class updateItemInventory_result:
19551 
  """
19552 
  Attributes:
19553 
   - success
19554 
  """
19555 
 
19556 
  thrift_spec = (
19557 
    (0, TType.BOOL, 'success', None, None, ), # 0
19558 
  )
19559 
 
19560 
  def __init__(self, success=None,):
19561 
    self.success = success
19562 
 
19563 
  def read(self, iprot):
19564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19566 
      return
19567 
    iprot.readStructBegin()
19568 
    while True:
19569 
      (fname, ftype, fid) = iprot.readFieldBegin()
19570 
      if ftype == TType.STOP:
19571 
        break
19572 
      if fid == 0:
19573 
        if ftype == TType.BOOL:
19574 
          self.success = iprot.readBool();
19575 
        else:
19576 
          iprot.skip(ftype)
19577 
      else:
19578 
        iprot.skip(ftype)
19579 
      iprot.readFieldEnd()
19580 
    iprot.readStructEnd()
19581 
 
19582 
  def write(self, oprot):
19583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19585 
      return
19586 
    oprot.writeStructBegin('updateItemInventory_result')
19587 
    if self.success is not None:
19588 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19589 
      oprot.writeBool(self.success)
19590 
      oprot.writeFieldEnd()
19591 
    oprot.writeFieldStop()
19592 
    oprot.writeStructEnd()
19593 
 
19594 
  def validate(self):
19595 
    return
19596 
 
19597 
 
19598 
  def __repr__(self):
19599 
    L = ['%s=%r' % (key, value)
19600 
      for key, value in self.__dict__.iteritems()]
19601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19602 
 
19603 
  def __eq__(self, other):
19604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19605 
 
19606 
  def __ne__(self, other):
19607 
    return not (self == other)
7770 kshitij.so 19608 
 
19609 
class updateTimestampForAmazonFeeds_args:
19610 
  """
19611 
  Attributes:
19612 
   - type
19613 
   - sku
19614 
   - timestamp
19615 
  """
19616 
 
19617 
  thrift_spec = (
19618 
    None, # 0
19619 
    (1, TType.STRING, 'type', None, None, ), # 1
19620 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
19621 
    (3, TType.I64, 'timestamp', None, None, ), # 3
19622 
  )
19623 
 
19624 
  def __init__(self, type=None, sku=None, timestamp=None,):
19625 
    self.type = type
19626 
    self.sku = sku
19627 
    self.timestamp = timestamp
19628 
 
19629 
  def read(self, iprot):
19630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19632 
      return
19633 
    iprot.readStructBegin()
19634 
    while True:
19635 
      (fname, ftype, fid) = iprot.readFieldBegin()
19636 
      if ftype == TType.STOP:
19637 
        break
19638 
      if fid == 1:
19639 
        if ftype == TType.STRING:
19640 
          self.type = iprot.readString();
19641 
        else:
19642 
          iprot.skip(ftype)
19643 
      elif fid == 2:
19644 
        if ftype == TType.LIST:
19645 
          self.sku = []
8590 kshitij.so 19646 
          (_etype426, _size423) = iprot.readListBegin()
19647 
          for _i427 in xrange(_size423):
19648 
            _elem428 = iprot.readI64();
19649 
            self.sku.append(_elem428)
7770 kshitij.so 19650 
          iprot.readListEnd()
19651 
        else:
19652 
          iprot.skip(ftype)
19653 
      elif fid == 3:
19654 
        if ftype == TType.I64:
19655 
          self.timestamp = iprot.readI64();
19656 
        else:
19657 
          iprot.skip(ftype)
19658 
      else:
19659 
        iprot.skip(ftype)
19660 
      iprot.readFieldEnd()
19661 
    iprot.readStructEnd()
19662 
 
19663 
  def write(self, oprot):
19664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19666 
      return
19667 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
19668 
    if self.type is not None:
19669 
      oprot.writeFieldBegin('type', TType.STRING, 1)
19670 
      oprot.writeString(self.type)
19671 
      oprot.writeFieldEnd()
19672 
    if self.sku is not None:
19673 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
19674 
      oprot.writeListBegin(TType.I64, len(self.sku))
8590 kshitij.so 19675 
      for iter429 in self.sku:
19676 
        oprot.writeI64(iter429)
7770 kshitij.so 19677 
      oprot.writeListEnd()
19678 
      oprot.writeFieldEnd()
19679 
    if self.timestamp is not None:
19680 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
19681 
      oprot.writeI64(self.timestamp)
19682 
      oprot.writeFieldEnd()
19683 
    oprot.writeFieldStop()
19684 
    oprot.writeStructEnd()
19685 
 
19686 
  def validate(self):
19687 
    return
19688 
 
19689 
 
19690 
  def __repr__(self):
19691 
    L = ['%s=%r' % (key, value)
19692 
      for key, value in self.__dict__.iteritems()]
19693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19694 
 
19695 
  def __eq__(self, other):
19696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19697 
 
19698 
  def __ne__(self, other):
19699 
    return not (self == other)
19700 
 
19701 
class updateTimestampForAmazonFeeds_result:
19702 
  """
19703 
  Attributes:
19704 
   - success
19705 
  """
19706 
 
19707 
  thrift_spec = (
19708 
    (0, TType.BOOL, 'success', None, None, ), # 0
19709 
  )
19710 
 
19711 
  def __init__(self, success=None,):
19712 
    self.success = success
19713 
 
19714 
  def read(self, iprot):
19715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19717 
      return
19718 
    iprot.readStructBegin()
19719 
    while True:
19720 
      (fname, ftype, fid) = iprot.readFieldBegin()
19721 
      if ftype == TType.STOP:
19722 
        break
19723 
      if fid == 0:
19724 
        if ftype == TType.BOOL:
19725 
          self.success = iprot.readBool();
19726 
        else:
19727 
          iprot.skip(ftype)
19728 
      else:
19729 
        iprot.skip(ftype)
19730 
      iprot.readFieldEnd()
19731 
    iprot.readStructEnd()
19732 
 
19733 
  def write(self, oprot):
19734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19736 
      return
19737 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
19738 
    if self.success is not None:
19739 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19740 
      oprot.writeBool(self.success)
19741 
      oprot.writeFieldEnd()
19742 
    oprot.writeFieldStop()
19743 
    oprot.writeStructEnd()
19744 
 
19745 
  def validate(self):
19746 
    return
19747 
 
19748 
 
19749 
  def __repr__(self):
19750 
    L = ['%s=%r' % (key, value)
19751 
      for key, value in self.__dict__.iteritems()]
19752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19753 
 
19754 
  def __eq__(self, other):
19755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19756 
 
19757 
  def __ne__(self, other):
19758 
    return not (self == other)
7897 amar.kumar 19759 
 
19760 
class getAllParentCategories_args:
19761 
 
19762 
  thrift_spec = (
19763 
  )
19764 
 
19765 
  def read(self, iprot):
19766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19768 
      return
19769 
    iprot.readStructBegin()
19770 
    while True:
19771 
      (fname, ftype, fid) = iprot.readFieldBegin()
19772 
      if ftype == TType.STOP:
19773 
        break
19774 
      else:
19775 
        iprot.skip(ftype)
19776 
      iprot.readFieldEnd()
19777 
    iprot.readStructEnd()
19778 
 
19779 
  def write(self, oprot):
19780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19782 
      return
19783 
    oprot.writeStructBegin('getAllParentCategories_args')
19784 
    oprot.writeFieldStop()
19785 
    oprot.writeStructEnd()
19786 
 
19787 
  def validate(self):
19788 
    return
19789 
 
19790 
 
19791 
  def __repr__(self):
19792 
    L = ['%s=%r' % (key, value)
19793 
      for key, value in self.__dict__.iteritems()]
19794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19795 
 
19796 
  def __eq__(self, other):
19797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19798 
 
19799 
  def __ne__(self, other):
19800 
    return not (self == other)
19801 
 
19802 
class getAllParentCategories_result:
19803 
  """
19804 
  Attributes:
19805 
   - success
19806 
  """
19807 
 
19808 
  thrift_spec = (
19809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
19810 
  )
19811 
 
19812 
  def __init__(self, success=None,):
19813 
    self.success = success
19814 
 
19815 
  def read(self, iprot):
19816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19818 
      return
19819 
    iprot.readStructBegin()
19820 
    while True:
19821 
      (fname, ftype, fid) = iprot.readFieldBegin()
19822 
      if ftype == TType.STOP:
19823 
        break
19824 
      if fid == 0:
19825 
        if ftype == TType.LIST:
19826 
          self.success = []
8590 kshitij.so 19827 
          (_etype433, _size430) = iprot.readListBegin()
19828 
          for _i434 in xrange(_size430):
19829 
            _elem435 = Category()
19830 
            _elem435.read(iprot)
19831 
            self.success.append(_elem435)
7897 amar.kumar 19832 
          iprot.readListEnd()
19833 
        else:
19834 
          iprot.skip(ftype)
19835 
      else:
19836 
        iprot.skip(ftype)
19837 
      iprot.readFieldEnd()
19838 
    iprot.readStructEnd()
19839 
 
19840 
  def write(self, oprot):
19841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19843 
      return
19844 
    oprot.writeStructBegin('getAllParentCategories_result')
19845 
    if self.success is not None:
19846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19848 
      for iter436 in self.success:
19849 
        iter436.write(oprot)
7897 amar.kumar 19850 
      oprot.writeListEnd()
19851 
      oprot.writeFieldEnd()
19852 
    oprot.writeFieldStop()
19853 
    oprot.writeStructEnd()
19854 
 
19855 
  def validate(self):
19856 
    return
19857 
 
19858 
 
19859 
  def __repr__(self):
19860 
    L = ['%s=%r' % (key, value)
19861 
      for key, value in self.__dict__.iteritems()]
19862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19863 
 
19864 
  def __eq__(self, other):
19865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19866 
 
19867 
  def __ne__(self, other):
19868 
    return not (self == other)
7977 kshitij.so 19869 
 
19870 
class addPageViewEvent_args:
19871 
  """
19872 
  Attributes:
19873 
   - pageViewEvents
19874 
  """
19875 
 
19876 
  thrift_spec = (
19877 
    None, # 0
19878 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
19879 
  )
19880 
 
19881 
  def __init__(self, pageViewEvents=None,):
19882 
    self.pageViewEvents = pageViewEvents
19883 
 
19884 
  def read(self, iprot):
19885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19887 
      return
19888 
    iprot.readStructBegin()
19889 
    while True:
19890 
      (fname, ftype, fid) = iprot.readFieldBegin()
19891 
      if ftype == TType.STOP:
19892 
        break
19893 
      if fid == 1:
19894 
        if ftype == TType.STRUCT:
19895 
          self.pageViewEvents = PageViewEvents()
19896 
          self.pageViewEvents.read(iprot)
19897 
        else:
19898 
          iprot.skip(ftype)
19899 
      else:
19900 
        iprot.skip(ftype)
19901 
      iprot.readFieldEnd()
19902 
    iprot.readStructEnd()
19903 
 
19904 
  def write(self, oprot):
19905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19907 
      return
19908 
    oprot.writeStructBegin('addPageViewEvent_args')
19909 
    if self.pageViewEvents is not None:
19910 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
19911 
      self.pageViewEvents.write(oprot)
19912 
      oprot.writeFieldEnd()
19913 
    oprot.writeFieldStop()
19914 
    oprot.writeStructEnd()
19915 
 
19916 
  def validate(self):
19917 
    return
19918 
 
19919 
 
19920 
  def __repr__(self):
19921 
    L = ['%s=%r' % (key, value)
19922 
      for key, value in self.__dict__.iteritems()]
19923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19924 
 
19925 
  def __eq__(self, other):
19926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19927 
 
19928 
  def __ne__(self, other):
19929 
    return not (self == other)
19930 
 
19931 
class addPageViewEvent_result:
19932 
 
19933 
  thrift_spec = (
19934 
  )
19935 
 
19936 
  def read(self, iprot):
19937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19939 
      return
19940 
    iprot.readStructBegin()
19941 
    while True:
19942 
      (fname, ftype, fid) = iprot.readFieldBegin()
19943 
      if ftype == TType.STOP:
19944 
        break
19945 
      else:
19946 
        iprot.skip(ftype)
19947 
      iprot.readFieldEnd()
19948 
    iprot.readStructEnd()
19949 
 
19950 
  def write(self, oprot):
19951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19953 
      return
19954 
    oprot.writeStructBegin('addPageViewEvent_result')
19955 
    oprot.writeFieldStop()
19956 
    oprot.writeStructEnd()
19957 
 
19958 
  def validate(self):
19959 
    return
19960 
 
19961 
 
19962 
  def __repr__(self):
19963 
    L = ['%s=%r' % (key, value)
19964 
      for key, value in self.__dict__.iteritems()]
19965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19966 
 
19967 
  def __eq__(self, other):
19968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19969 
 
19970 
  def __ne__(self, other):
19971 
    return not (self == other)
19972 
 
19973 
class addCartEvent_args:
19974 
  """
19975 
  Attributes:
19976 
   - cartEvents
19977 
  """
19978 
 
19979 
  thrift_spec = (
19980 
    None, # 0
19981 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
19982 
  )
19983 
 
19984 
  def __init__(self, cartEvents=None,):
19985 
    self.cartEvents = cartEvents
19986 
 
19987 
  def read(self, iprot):
19988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19990 
      return
19991 
    iprot.readStructBegin()
19992 
    while True:
19993 
      (fname, ftype, fid) = iprot.readFieldBegin()
19994 
      if ftype == TType.STOP:
19995 
        break
19996 
      if fid == 1:
19997 
        if ftype == TType.STRUCT:
19998 
          self.cartEvents = CartEvents()
19999 
          self.cartEvents.read(iprot)
20000 
        else:
20001 
          iprot.skip(ftype)
20002 
      else:
20003 
        iprot.skip(ftype)
20004 
      iprot.readFieldEnd()
20005 
    iprot.readStructEnd()
20006 
 
20007 
  def write(self, oprot):
20008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20010 
      return
20011 
    oprot.writeStructBegin('addCartEvent_args')
20012 
    if self.cartEvents is not None:
20013 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
20014 
      self.cartEvents.write(oprot)
20015 
      oprot.writeFieldEnd()
20016 
    oprot.writeFieldStop()
20017 
    oprot.writeStructEnd()
20018 
 
20019 
  def validate(self):
20020 
    return
20021 
 
20022 
 
20023 
  def __repr__(self):
20024 
    L = ['%s=%r' % (key, value)
20025 
      for key, value in self.__dict__.iteritems()]
20026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20027 
 
20028 
  def __eq__(self, other):
20029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20030 
 
20031 
  def __ne__(self, other):
20032 
    return not (self == other)
20033 
 
20034 
class addCartEvent_result:
20035 
 
20036 
  thrift_spec = (
20037 
  )
20038 
 
20039 
  def read(self, iprot):
20040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20042 
      return
20043 
    iprot.readStructBegin()
20044 
    while True:
20045 
      (fname, ftype, fid) = iprot.readFieldBegin()
20046 
      if ftype == TType.STOP:
20047 
        break
20048 
      else:
20049 
        iprot.skip(ftype)
20050 
      iprot.readFieldEnd()
20051 
    iprot.readStructEnd()
20052 
 
20053 
  def write(self, oprot):
20054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20056 
      return
20057 
    oprot.writeStructBegin('addCartEvent_result')
20058 
    oprot.writeFieldStop()
20059 
    oprot.writeStructEnd()
20060 
 
20061 
  def validate(self):
20062 
    return
20063 
 
20064 
 
20065 
  def __repr__(self):
20066 
    L = ['%s=%r' % (key, value)
20067 
      for key, value in self.__dict__.iteritems()]
20068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20069 
 
20070 
  def __eq__(self, other):
20071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20072 
 
20073 
  def __ne__(self, other):
20074 
    return not (self == other)
8139 kshitij.so 20075 
 
8182 amar.kumar 20076 
class addEbayItem_args:
20077 
  """
20078 
  Attributes:
20079 
   - ebayItem
20080 
  """
20081 
 
20082 
  thrift_spec = (
20083 
    None, # 0
20084 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20085 
  )
20086 
 
20087 
  def __init__(self, ebayItem=None,):
20088 
    self.ebayItem = ebayItem
20089 
 
20090 
  def read(self, iprot):
20091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20093 
      return
20094 
    iprot.readStructBegin()
20095 
    while True:
20096 
      (fname, ftype, fid) = iprot.readFieldBegin()
20097 
      if ftype == TType.STOP:
20098 
        break
20099 
      if fid == 1:
20100 
        if ftype == TType.STRUCT:
20101 
          self.ebayItem = EbayItem()
20102 
          self.ebayItem.read(iprot)
20103 
        else:
20104 
          iprot.skip(ftype)
20105 
      else:
20106 
        iprot.skip(ftype)
20107 
      iprot.readFieldEnd()
20108 
    iprot.readStructEnd()
20109 
 
20110 
  def write(self, oprot):
20111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20113 
      return
20114 
    oprot.writeStructBegin('addEbayItem_args')
20115 
    if self.ebayItem is not None:
20116 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20117 
      self.ebayItem.write(oprot)
20118 
      oprot.writeFieldEnd()
20119 
    oprot.writeFieldStop()
20120 
    oprot.writeStructEnd()
20121 
 
20122 
  def validate(self):
20123 
    return
20124 
 
20125 
 
20126 
  def __repr__(self):
20127 
    L = ['%s=%r' % (key, value)
20128 
      for key, value in self.__dict__.iteritems()]
20129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20130 
 
20131 
  def __eq__(self, other):
20132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20133 
 
20134 
  def __ne__(self, other):
20135 
    return not (self == other)
20136 
 
20137 
class addEbayItem_result:
20138 
 
20139 
  thrift_spec = (
20140 
  )
20141 
 
20142 
  def read(self, iprot):
20143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20145 
      return
20146 
    iprot.readStructBegin()
20147 
    while True:
20148 
      (fname, ftype, fid) = iprot.readFieldBegin()
20149 
      if ftype == TType.STOP:
20150 
        break
20151 
      else:
20152 
        iprot.skip(ftype)
20153 
      iprot.readFieldEnd()
20154 
    iprot.readStructEnd()
20155 
 
20156 
  def write(self, oprot):
20157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20159 
      return
20160 
    oprot.writeStructBegin('addEbayItem_result')
20161 
    oprot.writeFieldStop()
20162 
    oprot.writeStructEnd()
20163 
 
20164 
  def validate(self):
20165 
    return
20166 
 
20167 
 
20168 
  def __repr__(self):
20169 
    L = ['%s=%r' % (key, value)
20170 
      for key, value in self.__dict__.iteritems()]
20171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20172 
 
20173 
  def __eq__(self, other):
20174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20175 
 
20176 
  def __ne__(self, other):
20177 
    return not (self == other)
20178 
 
20179 
class getEbayItem_args:
20180 
  """
20181 
  Attributes:
20182 
   - listingId
20183 
  """
20184 
 
20185 
  thrift_spec = (
20186 
    None, # 0
20187 
    (1, TType.STRING, 'listingId', None, None, ), # 1
20188 
  )
20189 
 
20190 
  def __init__(self, listingId=None,):
20191 
    self.listingId = listingId
20192 
 
20193 
  def read(self, iprot):
20194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20196 
      return
20197 
    iprot.readStructBegin()
20198 
    while True:
20199 
      (fname, ftype, fid) = iprot.readFieldBegin()
20200 
      if ftype == TType.STOP:
20201 
        break
20202 
      if fid == 1:
20203 
        if ftype == TType.STRING:
20204 
          self.listingId = iprot.readString();
20205 
        else:
20206 
          iprot.skip(ftype)
20207 
      else:
20208 
        iprot.skip(ftype)
20209 
      iprot.readFieldEnd()
20210 
    iprot.readStructEnd()
20211 
 
20212 
  def write(self, oprot):
20213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20215 
      return
20216 
    oprot.writeStructBegin('getEbayItem_args')
20217 
    if self.listingId is not None:
20218 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
20219 
      oprot.writeString(self.listingId)
20220 
      oprot.writeFieldEnd()
20221 
    oprot.writeFieldStop()
20222 
    oprot.writeStructEnd()
20223 
 
20224 
  def validate(self):
20225 
    return
20226 
 
20227 
 
20228 
  def __repr__(self):
20229 
    L = ['%s=%r' % (key, value)
20230 
      for key, value in self.__dict__.iteritems()]
20231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20232 
 
20233 
  def __eq__(self, other):
20234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20235 
 
20236 
  def __ne__(self, other):
20237 
    return not (self == other)
20238 
 
20239 
class getEbayItem_result:
20240 
  """
20241 
  Attributes:
20242 
   - success
20243 
  """
20244 
 
20245 
  thrift_spec = (
20246 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
20247 
  )
20248 
 
20249 
  def __init__(self, success=None,):
20250 
    self.success = success
20251 
 
20252 
  def read(self, iprot):
20253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20255 
      return
20256 
    iprot.readStructBegin()
20257 
    while True:
20258 
      (fname, ftype, fid) = iprot.readFieldBegin()
20259 
      if ftype == TType.STOP:
20260 
        break
20261 
      if fid == 0:
20262 
        if ftype == TType.STRUCT:
20263 
          self.success = EbayItem()
20264 
          self.success.read(iprot)
20265 
        else:
20266 
          iprot.skip(ftype)
20267 
      else:
20268 
        iprot.skip(ftype)
20269 
      iprot.readFieldEnd()
20270 
    iprot.readStructEnd()
20271 
 
20272 
  def write(self, oprot):
20273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20275 
      return
20276 
    oprot.writeStructBegin('getEbayItem_result')
20277 
    if self.success is not None:
20278 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20279 
      self.success.write(oprot)
20280 
      oprot.writeFieldEnd()
20281 
    oprot.writeFieldStop()
20282 
    oprot.writeStructEnd()
20283 
 
20284 
  def validate(self):
20285 
    return
20286 
 
20287 
 
20288 
  def __repr__(self):
20289 
    L = ['%s=%r' % (key, value)
20290 
      for key, value in self.__dict__.iteritems()]
20291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20292 
 
20293 
  def __eq__(self, other):
20294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20295 
 
20296 
  def __ne__(self, other):
20297 
    return not (self == other)
20298 
 
20299 
class updateEbayItem_args:
20300 
  """
20301 
  Attributes:
20302 
   - ebayItem
20303 
  """
20304 
 
20305 
  thrift_spec = (
20306 
    None, # 0
20307 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20308 
  )
20309 
 
20310 
  def __init__(self, ebayItem=None,):
20311 
    self.ebayItem = ebayItem
20312 
 
20313 
  def read(self, iprot):
20314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20316 
      return
20317 
    iprot.readStructBegin()
20318 
    while True:
20319 
      (fname, ftype, fid) = iprot.readFieldBegin()
20320 
      if ftype == TType.STOP:
20321 
        break
20322 
      if fid == 1:
20323 
        if ftype == TType.STRUCT:
20324 
          self.ebayItem = EbayItem()
20325 
          self.ebayItem.read(iprot)
20326 
        else:
20327 
          iprot.skip(ftype)
20328 
      else:
20329 
        iprot.skip(ftype)
20330 
      iprot.readFieldEnd()
20331 
    iprot.readStructEnd()
20332 
 
20333 
  def write(self, oprot):
20334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20336 
      return
20337 
    oprot.writeStructBegin('updateEbayItem_args')
20338 
    if self.ebayItem is not None:
20339 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20340 
      self.ebayItem.write(oprot)
20341 
      oprot.writeFieldEnd()
20342 
    oprot.writeFieldStop()
20343 
    oprot.writeStructEnd()
20344 
 
20345 
  def validate(self):
20346 
    return
20347 
 
20348 
 
20349 
  def __repr__(self):
20350 
    L = ['%s=%r' % (key, value)
20351 
      for key, value in self.__dict__.iteritems()]
20352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20353 
 
20354 
  def __eq__(self, other):
20355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20356 
 
20357 
  def __ne__(self, other):
20358 
    return not (self == other)
20359 
 
20360 
class updateEbayItem_result:
20361 
 
20362 
  thrift_spec = (
20363 
  )
20364 
 
20365 
  def read(self, iprot):
20366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20368 
      return
20369 
    iprot.readStructBegin()
20370 
    while True:
20371 
      (fname, ftype, fid) = iprot.readFieldBegin()
20372 
      if ftype == TType.STOP:
20373 
        break
20374 
      else:
20375 
        iprot.skip(ftype)
20376 
      iprot.readFieldEnd()
20377 
    iprot.readStructEnd()
20378 
 
20379 
  def write(self, oprot):
20380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20382 
      return
20383 
    oprot.writeStructBegin('updateEbayItem_result')
20384 
    oprot.writeFieldStop()
20385 
    oprot.writeStructEnd()
20386 
 
20387 
  def validate(self):
20388 
    return
20389 
 
20390 
 
20391 
  def __repr__(self):
20392 
    L = ['%s=%r' % (key, value)
20393 
      for key, value in self.__dict__.iteritems()]
20394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20395 
 
20396 
  def __eq__(self, other):
20397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20398 
 
20399 
  def __ne__(self, other):
20400 
    return not (self == other)
20401 
 
8139 kshitij.so 20402 
class getAmazonListedItems_args:
20403 
  """
20404 
  Attributes:
20405 
   - offset
20406 
   - limit
20407 
  """
20408 
 
20409 
  thrift_spec = (
20410 
    None, # 0
20411 
    (1, TType.I64, 'offset', None, None, ), # 1
20412 
    (2, TType.I64, 'limit', None, None, ), # 2
20413 
  )
20414 
 
20415 
  def __init__(self, offset=None, limit=None,):
20416 
    self.offset = offset
20417 
    self.limit = limit
20418 
 
20419 
  def read(self, iprot):
20420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20422 
      return
20423 
    iprot.readStructBegin()
20424 
    while True:
20425 
      (fname, ftype, fid) = iprot.readFieldBegin()
20426 
      if ftype == TType.STOP:
20427 
        break
20428 
      if fid == 1:
20429 
        if ftype == TType.I64:
20430 
          self.offset = iprot.readI64();
20431 
        else:
20432 
          iprot.skip(ftype)
20433 
      elif fid == 2:
20434 
        if ftype == TType.I64:
20435 
          self.limit = iprot.readI64();
20436 
        else:
20437 
          iprot.skip(ftype)
20438 
      else:
20439 
        iprot.skip(ftype)
20440 
      iprot.readFieldEnd()
20441 
    iprot.readStructEnd()
20442 
 
20443 
  def write(self, oprot):
20444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20446 
      return
20447 
    oprot.writeStructBegin('getAmazonListedItems_args')
20448 
    if self.offset is not None:
20449 
      oprot.writeFieldBegin('offset', TType.I64, 1)
20450 
      oprot.writeI64(self.offset)
20451 
      oprot.writeFieldEnd()
20452 
    if self.limit is not None:
20453 
      oprot.writeFieldBegin('limit', TType.I64, 2)
20454 
      oprot.writeI64(self.limit)
20455 
      oprot.writeFieldEnd()
20456 
    oprot.writeFieldStop()
20457 
    oprot.writeStructEnd()
20458 
 
20459 
  def validate(self):
20460 
    return
20461 
 
20462 
 
20463 
  def __repr__(self):
20464 
    L = ['%s=%r' % (key, value)
20465 
      for key, value in self.__dict__.iteritems()]
20466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20467 
 
20468 
  def __eq__(self, other):
20469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20470 
 
20471 
  def __ne__(self, other):
20472 
    return not (self == other)
20473 
 
20474 
class getAmazonListedItems_result:
20475 
  """
20476 
  Attributes:
20477 
   - success
20478 
  """
20479 
 
20480 
  thrift_spec = (
20481 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20482 
  )
20483 
 
20484 
  def __init__(self, success=None,):
20485 
    self.success = success
20486 
 
20487 
  def read(self, iprot):
20488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20490 
      return
20491 
    iprot.readStructBegin()
20492 
    while True:
20493 
      (fname, ftype, fid) = iprot.readFieldBegin()
20494 
      if ftype == TType.STOP:
20495 
        break
20496 
      if fid == 0:
20497 
        if ftype == TType.LIST:
20498 
          self.success = []
8590 kshitij.so 20499 
          (_etype440, _size437) = iprot.readListBegin()
20500 
          for _i441 in xrange(_size437):
20501 
            _elem442 = Amazonlisted()
20502 
            _elem442.read(iprot)
20503 
            self.success.append(_elem442)
8139 kshitij.so 20504 
          iprot.readListEnd()
20505 
        else:
20506 
          iprot.skip(ftype)
20507 
      else:
20508 
        iprot.skip(ftype)
20509 
      iprot.readFieldEnd()
20510 
    iprot.readStructEnd()
20511 
 
20512 
  def write(self, oprot):
20513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20515 
      return
20516 
    oprot.writeStructBegin('getAmazonListedItems_result')
20517 
    if self.success is not None:
20518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20519 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 20520 
      for iter443 in self.success:
20521 
        iter443.write(oprot)
8139 kshitij.so 20522 
      oprot.writeListEnd()
20523 
      oprot.writeFieldEnd()
20524 
    oprot.writeFieldStop()
20525 
    oprot.writeStructEnd()
20526 
 
20527 
  def validate(self):
20528 
    return
20529 
 
20530 
 
20531 
  def __repr__(self):
20532 
    L = ['%s=%r' % (key, value)
20533 
      for key, value in self.__dict__.iteritems()]
20534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20535 
 
20536 
  def __eq__(self, other):
20537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20538 
 
20539 
  def __ne__(self, other):
20540 
    return not (self == other)
8168 kshitij.so 20541 
 
20542 
class updateAmazonAttributesInBulk_args:
20543 
  """
20544 
  Attributes:
20545 
   - amazonlisted
20546 
  """
20547 
 
20548 
  thrift_spec = (
20549 
    None, # 0
20550 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
20551 
  )
20552 
 
20553 
  def __init__(self, amazonlisted=None,):
20554 
    self.amazonlisted = amazonlisted
20555 
 
20556 
  def read(self, iprot):
20557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20559 
      return
20560 
    iprot.readStructBegin()
20561 
    while True:
20562 
      (fname, ftype, fid) = iprot.readFieldBegin()
20563 
      if ftype == TType.STOP:
20564 
        break
20565 
      if fid == 1:
20566 
        if ftype == TType.MAP:
20567 
          self.amazonlisted = {}
8590 kshitij.so 20568 
          (_ktype445, _vtype446, _size444 ) = iprot.readMapBegin()
20569 
          for _i448 in xrange(_size444):
20570 
            _key449 = iprot.readI64();
20571 
            _val450 = Amazonlisted()
20572 
            _val450.read(iprot)
20573 
            self.amazonlisted[_key449] = _val450
8168 kshitij.so 20574 
          iprot.readMapEnd()
20575 
        else:
20576 
          iprot.skip(ftype)
20577 
      else:
20578 
        iprot.skip(ftype)
20579 
      iprot.readFieldEnd()
20580 
    iprot.readStructEnd()
20581 
 
20582 
  def write(self, oprot):
20583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20585 
      return
20586 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
20587 
    if self.amazonlisted is not None:
20588 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
20589 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
8590 kshitij.so 20590 
      for kiter451,viter452 in self.amazonlisted.items():
20591 
        oprot.writeI64(kiter451)
20592 
        viter452.write(oprot)
8168 kshitij.so 20593 
      oprot.writeMapEnd()
20594 
      oprot.writeFieldEnd()
20595 
    oprot.writeFieldStop()
20596 
    oprot.writeStructEnd()
20597 
 
20598 
  def validate(self):
20599 
    return
20600 
 
20601 
 
20602 
  def __repr__(self):
20603 
    L = ['%s=%r' % (key, value)
20604 
      for key, value in self.__dict__.iteritems()]
20605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20606 
 
20607 
  def __eq__(self, other):
20608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20609 
 
20610 
  def __ne__(self, other):
20611 
    return not (self == other)
20612 
 
20613 
class updateAmazonAttributesInBulk_result:
20614 
  """
20615 
  Attributes:
20616 
   - success
20617 
  """
20618 
 
20619 
  thrift_spec = (
20620 
    (0, TType.BOOL, 'success', None, None, ), # 0
20621 
  )
20622 
 
20623 
  def __init__(self, success=None,):
20624 
    self.success = success
20625 
 
20626 
  def read(self, iprot):
20627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20629 
      return
20630 
    iprot.readStructBegin()
20631 
    while True:
20632 
      (fname, ftype, fid) = iprot.readFieldBegin()
20633 
      if ftype == TType.STOP:
20634 
        break
20635 
      if fid == 0:
20636 
        if ftype == TType.BOOL:
20637 
          self.success = iprot.readBool();
20638 
        else:
20639 
          iprot.skip(ftype)
20640 
      else:
20641 
        iprot.skip(ftype)
20642 
      iprot.readFieldEnd()
20643 
    iprot.readStructEnd()
20644 
 
20645 
  def write(self, oprot):
20646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20648 
      return
20649 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
20650 
    if self.success is not None:
20651 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20652 
      oprot.writeBool(self.success)
20653 
      oprot.writeFieldEnd()
20654 
    oprot.writeFieldStop()
20655 
    oprot.writeStructEnd()
20656 
 
20657 
  def validate(self):
20658 
    return
20659 
 
20660 
 
20661 
  def __repr__(self):
20662 
    L = ['%s=%r' % (key, value)
20663 
      for key, value in self.__dict__.iteritems()]
20664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20665 
 
20666 
  def __eq__(self, other):
20667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20668 
 
20669 
  def __ne__(self, other):
20670 
    return not (self == other)
8379 vikram.rag 20671 
 
20672 
class getAllItemstoListOnFba_args:
20673 
 
20674 
  thrift_spec = (
20675 
  )
20676 
 
20677 
  def read(self, iprot):
20678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20680 
      return
20681 
    iprot.readStructBegin()
20682 
    while True:
20683 
      (fname, ftype, fid) = iprot.readFieldBegin()
20684 
      if ftype == TType.STOP:
20685 
        break
20686 
      else:
20687 
        iprot.skip(ftype)
20688 
      iprot.readFieldEnd()
20689 
    iprot.readStructEnd()
20690 
 
20691 
  def write(self, oprot):
20692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20694 
      return
20695 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
20696 
    oprot.writeFieldStop()
20697 
    oprot.writeStructEnd()
20698 
 
20699 
  def validate(self):
20700 
    return
20701 
 
20702 
 
20703 
  def __repr__(self):
20704 
    L = ['%s=%r' % (key, value)
20705 
      for key, value in self.__dict__.iteritems()]
20706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20707 
 
20708 
  def __eq__(self, other):
20709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20710 
 
20711 
  def __ne__(self, other):
20712 
    return not (self == other)
20713 
 
20714 
class getAllItemstoListOnFba_result:
20715 
  """
20716 
  Attributes:
20717 
   - success
20718 
  """
20719 
 
20720 
  thrift_spec = (
20721 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20722 
  )
20723 
 
20724 
  def __init__(self, success=None,):
20725 
    self.success = success
20726 
 
20727 
  def read(self, iprot):
20728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20730 
      return
20731 
    iprot.readStructBegin()
20732 
    while True:
20733 
      (fname, ftype, fid) = iprot.readFieldBegin()
20734 
      if ftype == TType.STOP:
20735 
        break
20736 
      if fid == 0:
20737 
        if ftype == TType.LIST:
20738 
          self.success = []
8590 kshitij.so 20739 
          (_etype456, _size453) = iprot.readListBegin()
20740 
          for _i457 in xrange(_size453):
20741 
            _elem458 = Amazonlisted()
20742 
            _elem458.read(iprot)
20743 
            self.success.append(_elem458)
8379 vikram.rag 20744 
          iprot.readListEnd()
20745 
        else:
20746 
          iprot.skip(ftype)
20747 
      else:
20748 
        iprot.skip(ftype)
20749 
      iprot.readFieldEnd()
20750 
    iprot.readStructEnd()
20751 
 
20752 
  def write(self, oprot):
20753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20755 
      return
20756 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
20757 
    if self.success is not None:
20758 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20759 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 20760 
      for iter459 in self.success:
20761 
        iter459.write(oprot)
8379 vikram.rag 20762 
      oprot.writeListEnd()
20763 
      oprot.writeFieldEnd()
20764 
    oprot.writeFieldStop()
20765 
    oprot.writeStructEnd()
20766 
 
20767 
  def validate(self):
20768 
    return
20769 
 
20770 
 
20771 
  def __repr__(self):
20772 
    L = ['%s=%r' % (key, value)
20773 
      for key, value in self.__dict__.iteritems()]
20774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20775 
 
20776 
  def __eq__(self, other):
20777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20778 
 
20779 
  def __ne__(self, other):
20780 
    return not (self == other)
20781 
 
20782 
class getAllItemstoListOnNonFba_args:
20783 
 
20784 
  thrift_spec = (
20785 
  )
20786 
 
20787 
  def read(self, iprot):
20788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20790 
      return
20791 
    iprot.readStructBegin()
20792 
    while True:
20793 
      (fname, ftype, fid) = iprot.readFieldBegin()
20794 
      if ftype == TType.STOP:
20795 
        break
20796 
      else:
20797 
        iprot.skip(ftype)
20798 
      iprot.readFieldEnd()
20799 
    iprot.readStructEnd()
20800 
 
20801 
  def write(self, oprot):
20802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20804 
      return
20805 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
20806 
    oprot.writeFieldStop()
20807 
    oprot.writeStructEnd()
20808 
 
20809 
  def validate(self):
20810 
    return
20811 
 
20812 
 
20813 
  def __repr__(self):
20814 
    L = ['%s=%r' % (key, value)
20815 
      for key, value in self.__dict__.iteritems()]
20816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20817 
 
20818 
  def __eq__(self, other):
20819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20820 
 
20821 
  def __ne__(self, other):
20822 
    return not (self == other)
20823 
 
20824 
class getAllItemstoListOnNonFba_result:
20825 
  """
20826 
  Attributes:
20827 
   - success
20828 
  """
20829 
 
20830 
  thrift_spec = (
20831 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20832 
  )
20833 
 
20834 
  def __init__(self, success=None,):
20835 
    self.success = success
20836 
 
20837 
  def read(self, iprot):
20838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20840 
      return
20841 
    iprot.readStructBegin()
20842 
    while True:
20843 
      (fname, ftype, fid) = iprot.readFieldBegin()
20844 
      if ftype == TType.STOP:
20845 
        break
20846 
      if fid == 0:
20847 
        if ftype == TType.LIST:
20848 
          self.success = []
8590 kshitij.so 20849 
          (_etype463, _size460) = iprot.readListBegin()
20850 
          for _i464 in xrange(_size460):
20851 
            _elem465 = Amazonlisted()
20852 
            _elem465.read(iprot)
20853 
            self.success.append(_elem465)
8379 vikram.rag 20854 
          iprot.readListEnd()
20855 
        else:
20856 
          iprot.skip(ftype)
20857 
      else:
20858 
        iprot.skip(ftype)
20859 
      iprot.readFieldEnd()
20860 
    iprot.readStructEnd()
20861 
 
20862 
  def write(self, oprot):
20863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20865 
      return
20866 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
20867 
    if self.success is not None:
20868 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20869 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 20870 
      for iter466 in self.success:
20871 
        iter466.write(oprot)
8379 vikram.rag 20872 
      oprot.writeListEnd()
20873 
      oprot.writeFieldEnd()
20874 
    oprot.writeFieldStop()
20875 
    oprot.writeStructEnd()
20876 
 
20877 
  def validate(self):
20878 
    return
20879 
 
20880 
 
20881 
  def __repr__(self):
20882 
    L = ['%s=%r' % (key, value)
20883 
      for key, value in self.__dict__.iteritems()]
20884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20885 
 
20886 
  def __eq__(self, other):
20887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20888 
 
20889 
  def __ne__(self, other):
20890 
    return not (self == other)