Subversion Repositories SmartDukaan

Rev

Rev 8182 | Rev 8579 | 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 
 
6850 kshitij.so 316 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
317 
    """
318 
    Parameters:
319 
     - bannerName
320 
     - imageName
321 
     - link
322 
     - priority
323 
     - isActive
324 
     - hasMap
325 
    """
326 
    pass
327 
 
328 
  def getAllBanners(self, ):
329 
    pass
330 
 
331 
  def deleteBanner(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getBannerDetails(self, bannerName):
339 
    """
340 
    Parameters:
341 
     - bannerName
342 
    """
343 
    pass
344 
 
345 
  def getActiveBanners(self, ):
346 
    pass
347 
 
6849 kshitij.so 348 
  def addBannerMap(self, bannerName, mapLink, coordinates):
349 
    """
350 
    Parameters:
351 
     - bannerName
352 
     - mapLink
353 
     - coordinates
354 
    """
355 
    pass
356 
 
357 
  def deleteBannerMap(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
364 
  def getBannerMapDetails(self, bannerName):
365 
    """
366 
    Parameters:
367 
     - bannerName
368 
    """
369 
    pass
370 
 
5944 mandeep.dh 371 
  def deleteSimilarItem(self, itemId, catalogItemId):
372 
    """
373 
    Delete similar item.
374 
 
375 
    Parameters:
376 
     - itemId
377 
     - catalogItemId
378 
    """
379 
    pass
380 
 
381 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
382 
    """
383 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
384 
    If yes, returns the itemId else returns 0
385 
 
386 
    Parameters:
387 
     - brand
388 
     - modelNumber
389 
     - modelName
390 
     - color
391 
    """
392 
    pass
393 
 
394 
  def validateRiskyStatus(self, itemId):
395 
    """
396 
    Check wether item is risky and change status if inventory is not available for risky items
397 
 
398 
    Parameters:
399 
     - itemId
400 
    """
401 
    pass
402 
 
403 
  def changeItemRiskyFlag(self, itemId, risky):
404 
    """
405 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
406 
 
407 
    Parameters:
408 
     - itemId
409 
     - risky
410 
    """
411 
    pass
412 
 
413 
  def getItemsByRiskyFlag(self, ):
414 
    """
415 
    Returns list of items marked as risky.
416 
    """
417 
    pass
418 
 
419 
  def getItemsForMasterSheet(self, category, brand):
420 
    """
421 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
422 
 
423 
    Parameters:
424 
     - category
425 
     - brand
426 
    """
427 
    pass
428 
 
429 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
430 
    """
431 
    Returns list of catalog ids of items with same similarity index as of the given itemId
432 
 
433 
    Parameters:
434 
     - beginIndex
435 
     - totalItems
436 
     - itemId
437 
    """
438 
    pass
439 
 
440 
  def addProductNotification(self, itemId, email):
441 
    """
442 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
443 
 
444 
    Parameters:
445 
     - itemId
446 
     - email
447 
    """
448 
    pass
449 
 
450 
  def sendProductNotifications(self, ):
451 
    """
452 
    Send the product notifications to the users for items which has stock.
453 
    """
454 
    pass
455 
 
456 
  def getAllBrandsByCategory(self, categoryId):
457 
    """
458 
    Returns list of brand names for a given category Id
459 
 
460 
    Parameters:
461 
     - categoryId
462 
    """
463 
    pass
464 
 
465 
  def getAllBrands(self, ):
466 
    """
467 
    Returns list of brand names
468 
    """
469 
    pass
470 
 
471 
  def getAllSources(self, ):
472 
    """
473 
    Return list of all sources
474 
    """
475 
    pass
476 
 
477 
  def getItemPricingBySource(self, itemId, sourceId):
478 
    """
479 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
480 
 
481 
    Parameters:
482 
     - itemId
483 
     - sourceId
484 
    """
485 
    pass
486 
 
487 
  def addSourceItemPricing(self, sourceItemPricing):
488 
    """
489 
    Adds prices to be displayed corresponding to the item if user comes from a source.
490 
    If item is not found or source is not found, it will throw exception.
491 
 
492 
    Parameters:
493 
     - sourceItemPricing
494 
    """
495 
    pass
496 
 
497 
  def getAllSourcePricing(self, itemId):
498 
    """
499 
    Returns the list of source pricing information of an item.
500 
    Raises an exception if item not found corresponding to itemId
501 
 
502 
    Parameters:
503 
     - itemId
504 
    """
505 
    pass
506 
 
507 
  def getItemForSource(self, item_id, sourceId):
508 
    """
509 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
510 
 
511 
    Parameters:
512 
     - item_id
513 
     - sourceId
514 
    """
515 
    pass
516 
 
517 
  def searchItemsInRange(self, searchTerms, offset, limit):
518 
    """
519 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
520 
 
521 
    Parameters:
522 
     - searchTerms
523 
     - offset
524 
     - limit
525 
    """
526 
    pass
527 
 
528 
  def getSearchResultCount(self, searchTerms):
529 
    """
530 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
531 
 
532 
    Parameters:
533 
     - searchTerms
534 
    """
535 
    pass
536 
 
537 
  def getProductNotifications(self, startDateTime):
538 
    """
539 
    Returns a list of product notifications added after a supplied datetime
540 
 
541 
    Parameters:
542 
     - startDateTime
543 
    """
544 
    pass
545 
 
7897 amar.kumar 546 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 547 
    """
548 
    Returns a list of count of requests for product notification against each item
549 
 
550 
    Parameters:
551 
     - startDateTime
7897 amar.kumar 552 
     - categoryId
5944 mandeep.dh 553 
    """
554 
    pass
555 
 
556 
  def addAuthorizationLog(self, itemId, username, reason):
557 
    """
558 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
559 
 
560 
    Parameters:
561 
     - itemId
562 
     - username
563 
     - reason
564 
    """
565 
    pass
566 
 
567 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
568 
    """
569 
    Parameters:
570 
     - catalog_item_id
571 
     - voucherType
572 
     - voucherAmount
573 
    """
574 
    pass
575 
 
576 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
577 
    """
578 
    Parameters:
579 
     - catalog_item_id
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getVoucherAmount(self, itemId, voucherType):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
     - voucherType
589 
    """
590 
    pass
591 
 
592 
  def getAllItemVouchers(self, itemId):
593 
    """
594 
    Parameters:
595 
     - itemId
596 
    """
597 
    pass
598 
 
599 
  def isValidCatalogItemId(self, catalog_item_id):
600 
    """
601 
    Parameters:
602 
     - catalog_item_id
603 
    """
604 
    pass
605 
 
7330 amit.gupta 606 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 607 
    """
608 
    Parameters:
609 
     - itemId
7330 amit.gupta 610 
     - stateId
6039 amit.gupta 611 
     - price
612 
    """
613 
    pass
5944 mandeep.dh 614 
 
6039 amit.gupta 615 
  def getVatAmountForItem(self, itemId, price):
616 
    """
617 
    Parameters:
618 
     - itemId
619 
     - price
620 
    """
621 
    pass
622 
 
6531 vikram.rag 623 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
624 
    """
625 
    Parameters:
626 
     - offset
627 
     - limit
628 
    """
629 
    pass
6039 amit.gupta 630 
 
6821 amar.kumar 631 
  def getAllAliveItems(self, ):
632 
    pass
633 
 
6921 anupam.sin 634 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 635 
    """
636 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 637 
 
6805 anupam.sin 638 
    Parameters:
639 
     - itemId
6921 anupam.sin 640 
     - price
6805 anupam.sin 641 
     - insurerId
642 
     - quantity
643 
    """
644 
    pass
645 
 
646 
  def getInsurer(self, insurerId):
647 
    """
648 
    Parameters:
649 
     - insurerId
650 
    """
651 
    pass
652 
 
6838 vikram.rag 653 
  def getAllInsurers(self, ):
654 
    pass
6805 anupam.sin 655 
 
6962 rajveer 656 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
657 
    """
658 
    Parameters:
659 
     - insurerId
660 
     - amount
661 
    """
662 
    pass
6838 vikram.rag 663 
 
7190 amar.kumar 664 
  def getFreebieForItem(self, itemId):
665 
    """
666 
    Parameters:
667 
     - itemId
668 
    """
669 
    pass
6962 rajveer 670 
 
7190 amar.kumar 671 
  def addOrUpdateFreebieForItem(self, freebieItem):
672 
    """
673 
    Parameters:
674 
     - freebieItem
675 
    """
676 
    pass
677 
 
7272 amit.gupta 678 
  def addOrUpdateBrandInfo(self, brandInfo):
679 
    """
680 
    Parameters:
681 
     - brandInfo
682 
    """
683 
    pass
684 
 
685 
  def getBrandInfo(self, ):
686 
    pass
687 
 
7256 rajveer 688 
  def getStorePricing(self, itemId):
689 
    """
690 
    Parameters:
691 
     - itemId
692 
    """
693 
    pass
7190 amar.kumar 694 
 
7306 rajveer 695 
  def getStorePricings(self, itemIds):
696 
    """
697 
    Parameters:
698 
     - itemIds
699 
    """
700 
    pass
701 
 
7382 rajveer 702 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 703 
    """
704 
    Parameters:
705 
     - sp
7382 rajveer 706 
     - allColors
7265 rajveer 707 
    """
708 
    pass
7256 rajveer 709 
 
7281 kshitij.so 710 
  def getAllAmazonListedItems(self, ):
711 
    pass
7265 rajveer 712 
 
7281 kshitij.so 713 
  def getAmazonItemDetails(self, itemId):
714 
    """
715 
    Parameters:
716 
     - itemId
717 
    """
718 
    pass
719 
 
8168 kshitij.so 720 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 721 
    """
722 
    Parameters:
8168 kshitij.so 723 
     - amazonlisted
7281 kshitij.so 724 
    """
725 
    pass
726 
 
727 
  def addAmazonItem(self, amazonlisted):
728 
    """
729 
    Parameters:
730 
     - amazonlisted
731 
    """
732 
    pass
733 
 
7291 vikram.rag 734 
  def getAsinItems(self, ):
735 
    pass
7281 kshitij.so 736 
 
7291 vikram.rag 737 
  def getAllFbaListedItems(self, ):
738 
    pass
739 
 
740 
  def getAllNonFbaListedItems(self, ):
741 
    pass
742 
 
7460 kshitij.so 743 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
744 
    """
745 
    Parameters:
746 
     - itemId
747 
     - holdInventory
748 
     - defaultInventory
749 
    """
750 
    pass
7291 vikram.rag 751 
 
7770 kshitij.so 752 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
753 
    """
754 
    Parameters:
755 
     - type
756 
     - sku
757 
     - timestamp
758 
    """
759 
    pass
7460 kshitij.so 760 
 
7897 amar.kumar 761 
  def getAllParentCategories(self, ):
762 
    pass
7770 kshitij.so 763 
 
7977 kshitij.so 764 
  def addPageViewEvent(self, pageViewEvents):
765 
    """
766 
    Parameters:
767 
     - pageViewEvents
768 
    """
769 
    pass
7897 amar.kumar 770 
 
7977 kshitij.so 771 
  def addCartEvent(self, cartEvents):
772 
    """
773 
    Parameters:
774 
     - cartEvents
775 
    """
776 
    pass
777 
 
8182 amar.kumar 778 
  def addEbayItem(self, ebayItem):
779 
    """
780 
    Parameters:
781 
     - ebayItem
782 
    """
783 
    pass
784 
 
785 
  def getEbayItem(self, listingId):
786 
    """
787 
    Parameters:
788 
     - listingId
789 
    """
790 
    pass
791 
 
792 
  def updateEbayItem(self, ebayItem):
793 
    """
794 
    Parameters:
795 
     - ebayItem
796 
    """
797 
    pass
798 
 
8139 kshitij.so 799 
  def getAmazonListedItems(self, offset, limit):
800 
    """
801 
    Parameters:
802 
     - offset
803 
     - limit
804 
    """
805 
    pass
7977 kshitij.so 806 
 
8168 kshitij.so 807 
  def updateAmazonAttributesInBulk(self, amazonlisted):
808 
    """
809 
    Parameters:
810 
     - amazonlisted
811 
    """
812 
    pass
8139 kshitij.so 813 
 
8379 vikram.rag 814 
  def getAllItemstoListOnFba(self, ):
815 
    pass
8168 kshitij.so 816 
 
8379 vikram.rag 817 
  def getAllItemstoListOnNonFba(self, ):
818 
    pass
819 
 
820 
 
5944 mandeep.dh 821 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
822 
  def __init__(self, iprot, oprot=None):
823 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
824 
 
825 
  def addItem(self, item):
826 
    """
827 
    Availability and inventory attributes
828 
 
829 
    Parameters:
830 
     - item
831 
    """
832 
    self.send_addItem(item)
833 
    return self.recv_addItem()
834 
 
835 
  def send_addItem(self, item):
836 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
837 
    args = addItem_args()
838 
    args.item = item
839 
    args.write(self._oprot)
840 
    self._oprot.writeMessageEnd()
841 
    self._oprot.trans.flush()
842 
 
843 
  def recv_addItem(self, ):
844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
845 
    if mtype == TMessageType.EXCEPTION:
846 
      x = TApplicationException()
847 
      x.read(self._iprot)
848 
      self._iprot.readMessageEnd()
849 
      raise x
850 
    result = addItem_result()
851 
    result.read(self._iprot)
852 
    self._iprot.readMessageEnd()
853 
    if result.success is not None:
854 
      return result.success
855 
    if result.cex is not None:
856 
      raise result.cex
857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
858 
 
859 
  def updateItem(self, item):
860 
    """
861 
    Parameters:
862 
     - item
863 
    """
864 
    self.send_updateItem(item)
865 
    return self.recv_updateItem()
866 
 
867 
  def send_updateItem(self, item):
868 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
869 
    args = updateItem_args()
870 
    args.item = item
871 
    args.write(self._oprot)
872 
    self._oprot.writeMessageEnd()
873 
    self._oprot.trans.flush()
874 
 
875 
  def recv_updateItem(self, ):
876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
877 
    if mtype == TMessageType.EXCEPTION:
878 
      x = TApplicationException()
879 
      x.read(self._iprot)
880 
      self._iprot.readMessageEnd()
881 
      raise x
882 
    result = updateItem_result()
883 
    result.read(self._iprot)
884 
    self._iprot.readMessageEnd()
885 
    if result.success is not None:
886 
      return result.success
887 
    if result.cex is not None:
888 
      raise result.cex
889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
890 
 
891 
  def isActive(self, itemId):
892 
    """
893 
    Checks if the item given to the corresponding itemId is active. If it's active,
894 
    whether it's risky and if it's risky, its inventory position.
895 
 
896 
    Parameters:
897 
     - itemId
898 
    """
899 
    self.send_isActive(itemId)
900 
    return self.recv_isActive()
901 
 
902 
  def send_isActive(self, itemId):
903 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
904 
    args = isActive_args()
905 
    args.itemId = itemId
906 
    args.write(self._oprot)
907 
    self._oprot.writeMessageEnd()
908 
    self._oprot.trans.flush()
909 
 
910 
  def recv_isActive(self, ):
911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
912 
    if mtype == TMessageType.EXCEPTION:
913 
      x = TApplicationException()
914 
      x.read(self._iprot)
915 
      self._iprot.readMessageEnd()
916 
      raise x
917 
    result = isActive_result()
918 
    result.read(self._iprot)
919 
    self._iprot.readMessageEnd()
920 
    if result.success is not None:
921 
      return result.success
922 
    if result.isex is not None:
923 
      raise result.isex
924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
925 
 
7438 amit.gupta 926 
  def getItemsStatus(self, itemIds):
927 
    """
928 
    Parameters:
929 
     - itemIds
930 
    """
931 
    self.send_getItemsStatus(itemIds)
932 
    return self.recv_getItemsStatus()
933 
 
934 
  def send_getItemsStatus(self, itemIds):
935 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
936 
    args = getItemsStatus_args()
937 
    args.itemIds = itemIds
938 
    args.write(self._oprot)
939 
    self._oprot.writeMessageEnd()
940 
    self._oprot.trans.flush()
941 
 
942 
  def recv_getItemsStatus(self, ):
943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
944 
    if mtype == TMessageType.EXCEPTION:
945 
      x = TApplicationException()
946 
      x.read(self._iprot)
947 
      self._iprot.readMessageEnd()
948 
      raise x
949 
    result = getItemsStatus_result()
950 
    result.read(self._iprot)
951 
    self._iprot.readMessageEnd()
952 
    if result.success is not None:
953 
      return result.success
954 
    if result.isex is not None:
955 
      raise result.isex
956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
957 
 
5944 mandeep.dh 958 
  def getItemStatusDescription(self, itemId):
959 
    """
960 
    Parameters:
961 
     - itemId
962 
    """
963 
    self.send_getItemStatusDescription(itemId)
964 
    return self.recv_getItemStatusDescription()
965 
 
966 
  def send_getItemStatusDescription(self, itemId):
967 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
968 
    args = getItemStatusDescription_args()
969 
    args.itemId = itemId
970 
    args.write(self._oprot)
971 
    self._oprot.writeMessageEnd()
972 
    self._oprot.trans.flush()
973 
 
974 
  def recv_getItemStatusDescription(self, ):
975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
976 
    if mtype == TMessageType.EXCEPTION:
977 
      x = TApplicationException()
978 
      x.read(self._iprot)
979 
      self._iprot.readMessageEnd()
980 
      raise x
981 
    result = getItemStatusDescription_result()
982 
    result.read(self._iprot)
983 
    self._iprot.readMessageEnd()
984 
    if result.success is not None:
985 
      return result.success
986 
    if result.isex is not None:
987 
      raise result.isex
988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
989 
 
990 
  def startItemOn(self, item_id, timestamp):
991 
    """
992 
    Parameters:
993 
     - item_id
994 
     - timestamp
995 
    """
996 
    self.send_startItemOn(item_id, timestamp)
997 
    self.recv_startItemOn()
998 
 
999 
  def send_startItemOn(self, item_id, timestamp):
1000 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1001 
    args = startItemOn_args()
1002 
    args.item_id = item_id
1003 
    args.timestamp = timestamp
1004 
    args.write(self._oprot)
1005 
    self._oprot.writeMessageEnd()
1006 
    self._oprot.trans.flush()
1007 
 
1008 
  def recv_startItemOn(self, ):
1009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1010 
    if mtype == TMessageType.EXCEPTION:
1011 
      x = TApplicationException()
1012 
      x.read(self._iprot)
1013 
      self._iprot.readMessageEnd()
1014 
      raise x
1015 
    result = startItemOn_result()
1016 
    result.read(self._iprot)
1017 
    self._iprot.readMessageEnd()
1018 
    if result.cex is not None:
1019 
      raise result.cex
1020 
    return
1021 
 
1022 
  def retireItemOn(self, item_id, timestamp):
1023 
    """
1024 
    Parameters:
1025 
     - item_id
1026 
     - timestamp
1027 
    """
1028 
    self.send_retireItemOn(item_id, timestamp)
1029 
    self.recv_retireItemOn()
1030 
 
1031 
  def send_retireItemOn(self, item_id, timestamp):
1032 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1033 
    args = retireItemOn_args()
1034 
    args.item_id = item_id
1035 
    args.timestamp = timestamp
1036 
    args.write(self._oprot)
1037 
    self._oprot.writeMessageEnd()
1038 
    self._oprot.trans.flush()
1039 
 
1040 
  def recv_retireItemOn(self, ):
1041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1042 
    if mtype == TMessageType.EXCEPTION:
1043 
      x = TApplicationException()
1044 
      x.read(self._iprot)
1045 
      self._iprot.readMessageEnd()
1046 
      raise x
1047 
    result = retireItemOn_result()
1048 
    result.read(self._iprot)
1049 
    self._iprot.readMessageEnd()
1050 
    if result.cex is not None:
1051 
      raise result.cex
1052 
    return
1053 
 
1054 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1055 
    """
1056 
    Parameters:
1057 
     - item_id
1058 
     - timestamp
1059 
     - newstatus
1060 
    """
1061 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1062 
    self.recv_changeItemStatus()
1063 
 
1064 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1065 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1066 
    args = changeItemStatus_args()
1067 
    args.item_id = item_id
1068 
    args.timestamp = timestamp
1069 
    args.newstatus = newstatus
1070 
    args.write(self._oprot)
1071 
    self._oprot.writeMessageEnd()
1072 
    self._oprot.trans.flush()
1073 
 
1074 
  def recv_changeItemStatus(self, ):
1075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1076 
    if mtype == TMessageType.EXCEPTION:
1077 
      x = TApplicationException()
1078 
      x.read(self._iprot)
1079 
      self._iprot.readMessageEnd()
1080 
      raise x
1081 
    result = changeItemStatus_result()
1082 
    result.read(self._iprot)
1083 
    self._iprot.readMessageEnd()
1084 
    if result.cex is not None:
1085 
      raise result.cex
1086 
    return
1087 
 
1088 
  def getItem(self, item_id):
1089 
    """
1090 
    Parameters:
1091 
     - item_id
1092 
    """
1093 
    self.send_getItem(item_id)
1094 
    return self.recv_getItem()
1095 
 
1096 
  def send_getItem(self, item_id):
1097 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1098 
    args = getItem_args()
1099 
    args.item_id = item_id
1100 
    args.write(self._oprot)
1101 
    self._oprot.writeMessageEnd()
1102 
    self._oprot.trans.flush()
1103 
 
1104 
  def recv_getItem(self, ):
1105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1106 
    if mtype == TMessageType.EXCEPTION:
1107 
      x = TApplicationException()
1108 
      x.read(self._iprot)
1109 
      self._iprot.readMessageEnd()
1110 
      raise x
1111 
    result = getItem_result()
1112 
    result.read(self._iprot)
1113 
    self._iprot.readMessageEnd()
1114 
    if result.success is not None:
1115 
      return result.success
1116 
    if result.cex is not None:
1117 
      raise result.cex
1118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1119 
 
1120 
  def getItemsByCatalogId(self, catalog_item_id):
1121 
    """
1122 
    Parameters:
1123 
     - catalog_item_id
1124 
    """
1125 
    self.send_getItemsByCatalogId(catalog_item_id)
1126 
    return self.recv_getItemsByCatalogId()
1127 
 
1128 
  def send_getItemsByCatalogId(self, catalog_item_id):
1129 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1130 
    args = getItemsByCatalogId_args()
1131 
    args.catalog_item_id = catalog_item_id
1132 
    args.write(self._oprot)
1133 
    self._oprot.writeMessageEnd()
1134 
    self._oprot.trans.flush()
1135 
 
1136 
  def recv_getItemsByCatalogId(self, ):
1137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1138 
    if mtype == TMessageType.EXCEPTION:
1139 
      x = TApplicationException()
1140 
      x.read(self._iprot)
1141 
      self._iprot.readMessageEnd()
1142 
      raise x
1143 
    result = getItemsByCatalogId_result()
1144 
    result.read(self._iprot)
1145 
    self._iprot.readMessageEnd()
1146 
    if result.success is not None:
1147 
      return result.success
1148 
    if result.cex is not None:
1149 
      raise result.cex
1150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1151 
 
1152 
  def getValidItemsByCatalogId(self, catalog_item_id):
1153 
    """
1154 
    Parameters:
1155 
     - catalog_item_id
1156 
    """
1157 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1158 
    return self.recv_getValidItemsByCatalogId()
1159 
 
1160 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1161 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1162 
    args = getValidItemsByCatalogId_args()
1163 
    args.catalog_item_id = catalog_item_id
1164 
    args.write(self._oprot)
1165 
    self._oprot.writeMessageEnd()
1166 
    self._oprot.trans.flush()
1167 
 
1168 
  def recv_getValidItemsByCatalogId(self, ):
1169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1170 
    if mtype == TMessageType.EXCEPTION:
1171 
      x = TApplicationException()
1172 
      x.read(self._iprot)
1173 
      self._iprot.readMessageEnd()
1174 
      raise x
1175 
    result = getValidItemsByCatalogId_result()
1176 
    result.read(self._iprot)
1177 
    self._iprot.readMessageEnd()
1178 
    if result.success is not None:
1179 
      return result.success
1180 
    if result.cex is not None:
1181 
      raise result.cex
1182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1183 
 
1184 
  def getAllItems(self, isActive):
1185 
    """
1186 
    Parameters:
1187 
     - isActive
1188 
    """
1189 
    self.send_getAllItems(isActive)
1190 
    return self.recv_getAllItems()
1191 
 
1192 
  def send_getAllItems(self, isActive):
1193 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1194 
    args = getAllItems_args()
1195 
    args.isActive = isActive
1196 
    args.write(self._oprot)
1197 
    self._oprot.writeMessageEnd()
1198 
    self._oprot.trans.flush()
1199 
 
1200 
  def recv_getAllItems(self, ):
1201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1202 
    if mtype == TMessageType.EXCEPTION:
1203 
      x = TApplicationException()
1204 
      x.read(self._iprot)
1205 
      self._iprot.readMessageEnd()
1206 
      raise x
1207 
    result = getAllItems_result()
1208 
    result.read(self._iprot)
1209 
    self._iprot.readMessageEnd()
1210 
    if result.success is not None:
1211 
      return result.success
1212 
    if result.cex is not None:
1213 
      raise result.cex
1214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1215 
 
1216 
  def getAllItemsByStatus(self, itemStatus):
1217 
    """
1218 
    Parameters:
1219 
     - itemStatus
1220 
    """
1221 
    self.send_getAllItemsByStatus(itemStatus)
1222 
    return self.recv_getAllItemsByStatus()
1223 
 
1224 
  def send_getAllItemsByStatus(self, itemStatus):
1225 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1226 
    args = getAllItemsByStatus_args()
1227 
    args.itemStatus = itemStatus
1228 
    args.write(self._oprot)
1229 
    self._oprot.writeMessageEnd()
1230 
    self._oprot.trans.flush()
1231 
 
1232 
  def recv_getAllItemsByStatus(self, ):
1233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1234 
    if mtype == TMessageType.EXCEPTION:
1235 
      x = TApplicationException()
1236 
      x.read(self._iprot)
1237 
      self._iprot.readMessageEnd()
1238 
      raise x
1239 
    result = getAllItemsByStatus_result()
1240 
    result.read(self._iprot)
1241 
    self._iprot.readMessageEnd()
1242 
    if result.success is not None:
1243 
      return result.success
1244 
    if result.cex is not None:
1245 
      raise result.cex
1246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1247 
 
1248 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1249 
    """
1250 
    Parameters:
1251 
     - entityId
1252 
     - category
1253 
     - brand
1254 
     - modelName
1255 
     - modelNumber
1256 
    """
1257 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1258 
    return self.recv_markItemAsContentComplete()
1259 
 
1260 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1261 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1262 
    args = markItemAsContentComplete_args()
1263 
    args.entityId = entityId
1264 
    args.category = category
1265 
    args.brand = brand
1266 
    args.modelName = modelName
1267 
    args.modelNumber = modelNumber
1268 
    args.write(self._oprot)
1269 
    self._oprot.writeMessageEnd()
1270 
    self._oprot.trans.flush()
1271 
 
1272 
  def recv_markItemAsContentComplete(self, ):
1273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1274 
    if mtype == TMessageType.EXCEPTION:
1275 
      x = TApplicationException()
1276 
      x.read(self._iprot)
1277 
      self._iprot.readMessageEnd()
1278 
      raise x
1279 
    result = markItemAsContentComplete_result()
1280 
    result.read(self._iprot)
1281 
    self._iprot.readMessageEnd()
1282 
    if result.success is not None:
1283 
      return result.success
1284 
    if result.cex is not None:
1285 
      raise result.cex
1286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1287 
 
1288 
  def getAllItemsInRange(self, offset, limit):
1289 
    """
1290 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1291 
 
1292 
    Parameters:
1293 
     - offset
1294 
     - limit
1295 
    """
1296 
    self.send_getAllItemsInRange(offset, limit)
1297 
    return self.recv_getAllItemsInRange()
1298 
 
1299 
  def send_getAllItemsInRange(self, offset, limit):
1300 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1301 
    args = getAllItemsInRange_args()
1302 
    args.offset = offset
1303 
    args.limit = limit
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_getAllItemsInRange(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = getAllItemsInRange_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
1318 
    if result.success is not None:
1319 
      return result.success
1320 
    if result.cex is not None:
1321 
      raise result.cex
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1323 
 
1324 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1325 
    """
1326 
    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.
1327 
 
1328 
    Parameters:
1329 
     - itemStatus
1330 
     - offset
1331 
     - limit
1332 
    """
1333 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1334 
    return self.recv_getAllItemsByStatusInRange()
1335 
 
1336 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1337 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1338 
    args = getAllItemsByStatusInRange_args()
1339 
    args.itemStatus = itemStatus
1340 
    args.offset = offset
1341 
    args.limit = limit
1342 
    args.write(self._oprot)
1343 
    self._oprot.writeMessageEnd()
1344 
    self._oprot.trans.flush()
1345 
 
1346 
  def recv_getAllItemsByStatusInRange(self, ):
1347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1348 
    if mtype == TMessageType.EXCEPTION:
1349 
      x = TApplicationException()
1350 
      x.read(self._iprot)
1351 
      self._iprot.readMessageEnd()
1352 
      raise x
1353 
    result = getAllItemsByStatusInRange_result()
1354 
    result.read(self._iprot)
1355 
    self._iprot.readMessageEnd()
1356 
    if result.success is not None:
1357 
      return result.success
1358 
    if result.cex is not None:
1359 
      raise result.cex
1360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1361 
 
1362 
  def getItemCountByStatus(self, useStatus, itemStatus):
1363 
    """
1364 
    Gets a count of all items by status
1365 
 
1366 
    Parameters:
1367 
     - useStatus
1368 
     - itemStatus
1369 
    """
1370 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1371 
    return self.recv_getItemCountByStatus()
1372 
 
1373 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1374 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1375 
    args = getItemCountByStatus_args()
1376 
    args.useStatus = useStatus
1377 
    args.itemStatus = itemStatus
1378 
    args.write(self._oprot)
1379 
    self._oprot.writeMessageEnd()
1380 
    self._oprot.trans.flush()
1381 
 
1382 
  def recv_getItemCountByStatus(self, ):
1383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1384 
    if mtype == TMessageType.EXCEPTION:
1385 
      x = TApplicationException()
1386 
      x.read(self._iprot)
1387 
      self._iprot.readMessageEnd()
1388 
      raise x
1389 
    result = getItemCountByStatus_result()
1390 
    result.read(self._iprot)
1391 
    self._iprot.readMessageEnd()
1392 
    if result.success is not None:
1393 
      return result.success
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1395 
 
1396 
  def getBestSellers(self, ):
1397 
    self.send_getBestSellers()
1398 
    return self.recv_getBestSellers()
1399 
 
1400 
  def send_getBestSellers(self, ):
1401 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1402 
    args = getBestSellers_args()
1403 
    args.write(self._oprot)
1404 
    self._oprot.writeMessageEnd()
1405 
    self._oprot.trans.flush()
1406 
 
1407 
  def recv_getBestSellers(self, ):
1408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1409 
    if mtype == TMessageType.EXCEPTION:
1410 
      x = TApplicationException()
1411 
      x.read(self._iprot)
1412 
      self._iprot.readMessageEnd()
1413 
      raise x
1414 
    result = getBestSellers_result()
1415 
    result.read(self._iprot)
1416 
    self._iprot.readMessageEnd()
1417 
    if result.success is not None:
1418 
      return result.success
1419 
    if result.isex is not None:
1420 
      raise result.isex
1421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1422 
 
1423 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1424 
    """
1425 
    Parameters:
1426 
     - beginIndex
1427 
     - totalItems
1428 
     - brand
1429 
     - category
1430 
    """
1431 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1432 
    return self.recv_getBestSellersCatalogIds()
1433 
 
1434 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1435 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1436 
    args = getBestSellersCatalogIds_args()
1437 
    args.beginIndex = beginIndex
1438 
    args.totalItems = totalItems
1439 
    args.brand = brand
1440 
    args.category = category
1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
1445 
  def recv_getBestSellersCatalogIds(self, ):
1446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1447 
    if mtype == TMessageType.EXCEPTION:
1448 
      x = TApplicationException()
1449 
      x.read(self._iprot)
1450 
      self._iprot.readMessageEnd()
1451 
      raise x
1452 
    result = getBestSellersCatalogIds_result()
1453 
    result.read(self._iprot)
1454 
    self._iprot.readMessageEnd()
1455 
    if result.success is not None:
1456 
      return result.success
1457 
    if result.cex is not None:
1458 
      raise result.cex
1459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1460 
 
1461 
  def getBestSellersCount(self, ):
1462 
    self.send_getBestSellersCount()
1463 
    return self.recv_getBestSellersCount()
1464 
 
1465 
  def send_getBestSellersCount(self, ):
1466 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1467 
    args = getBestSellersCount_args()
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_getBestSellersCount(self, ):
1473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1474 
    if mtype == TMessageType.EXCEPTION:
1475 
      x = TApplicationException()
1476 
      x.read(self._iprot)
1477 
      self._iprot.readMessageEnd()
1478 
      raise x
1479 
    result = getBestSellersCount_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
1482 
    if result.success is not None:
1483 
      return result.success
1484 
    if result.cex is not None:
1485 
      raise result.cex
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1487 
 
1488 
  def getBestDeals(self, ):
1489 
    self.send_getBestDeals()
1490 
    return self.recv_getBestDeals()
1491 
 
1492 
  def send_getBestDeals(self, ):
1493 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1494 
    args = getBestDeals_args()
1495 
    args.write(self._oprot)
1496 
    self._oprot.writeMessageEnd()
1497 
    self._oprot.trans.flush()
1498 
 
1499 
  def recv_getBestDeals(self, ):
1500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1501 
    if mtype == TMessageType.EXCEPTION:
1502 
      x = TApplicationException()
1503 
      x.read(self._iprot)
1504 
      self._iprot.readMessageEnd()
1505 
      raise x
1506 
    result = getBestDeals_result()
1507 
    result.read(self._iprot)
1508 
    self._iprot.readMessageEnd()
1509 
    if result.success is not None:
1510 
      return result.success
1511 
    if result.isex is not None:
1512 
      raise result.isex
1513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1514 
 
1515 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1516 
    """
1517 
    Parameters:
1518 
     - beginIndex
1519 
     - totalItems
1520 
     - brand
1521 
     - category
1522 
    """
1523 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1524 
    return self.recv_getBestDealsCatalogIds()
1525 
 
1526 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1527 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1528 
    args = getBestDealsCatalogIds_args()
1529 
    args.beginIndex = beginIndex
1530 
    args.totalItems = totalItems
1531 
    args.brand = brand
1532 
    args.category = category
1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
1537 
  def recv_getBestDealsCatalogIds(self, ):
1538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1539 
    if mtype == TMessageType.EXCEPTION:
1540 
      x = TApplicationException()
1541 
      x.read(self._iprot)
1542 
      self._iprot.readMessageEnd()
1543 
      raise x
1544 
    result = getBestDealsCatalogIds_result()
1545 
    result.read(self._iprot)
1546 
    self._iprot.readMessageEnd()
1547 
    if result.success is not None:
1548 
      return result.success
1549 
    if result.cex is not None:
1550 
      raise result.cex
1551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1552 
 
1553 
  def getBestDealsCount(self, ):
1554 
    self.send_getBestDealsCount()
1555 
    return self.recv_getBestDealsCount()
1556 
 
1557 
  def send_getBestDealsCount(self, ):
1558 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1559 
    args = getBestDealsCount_args()
1560 
    args.write(self._oprot)
1561 
    self._oprot.writeMessageEnd()
1562 
    self._oprot.trans.flush()
1563 
 
1564 
  def recv_getBestDealsCount(self, ):
1565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1566 
    if mtype == TMessageType.EXCEPTION:
1567 
      x = TApplicationException()
1568 
      x.read(self._iprot)
1569 
      self._iprot.readMessageEnd()
1570 
      raise x
1571 
    result = getBestDealsCount_result()
1572 
    result.read(self._iprot)
1573 
    self._iprot.readMessageEnd()
1574 
    if result.success is not None:
1575 
      return result.success
1576 
    if result.cex is not None:
1577 
      raise result.cex
1578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1579 
 
1580 
  def getComingSoon(self, ):
1581 
    self.send_getComingSoon()
1582 
    return self.recv_getComingSoon()
1583 
 
1584 
  def send_getComingSoon(self, ):
1585 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1586 
    args = getComingSoon_args()
1587 
    args.write(self._oprot)
1588 
    self._oprot.writeMessageEnd()
1589 
    self._oprot.trans.flush()
1590 
 
1591 
  def recv_getComingSoon(self, ):
1592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1593 
    if mtype == TMessageType.EXCEPTION:
1594 
      x = TApplicationException()
1595 
      x.read(self._iprot)
1596 
      self._iprot.readMessageEnd()
1597 
      raise x
1598 
    result = getComingSoon_result()
1599 
    result.read(self._iprot)
1600 
    self._iprot.readMessageEnd()
1601 
    if result.success is not None:
1602 
      return result.success
1603 
    if result.isex is not None:
1604 
      raise result.isex
1605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1606 
 
1607 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1608 
    """
1609 
    Parameters:
1610 
     - beginIndex
1611 
     - totalItems
1612 
     - brand
1613 
     - category
1614 
    """
1615 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1616 
    return self.recv_getComingSoonCatalogIds()
1617 
 
1618 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1619 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1620 
    args = getComingSoonCatalogIds_args()
1621 
    args.beginIndex = beginIndex
1622 
    args.totalItems = totalItems
1623 
    args.brand = brand
1624 
    args.category = category
1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
1629 
  def recv_getComingSoonCatalogIds(self, ):
1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
1636 
    result = getComingSoonCatalogIds_result()
1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
1639 
    if result.success is not None:
1640 
      return result.success
1641 
    if result.cex is not None:
1642 
      raise result.cex
1643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1644 
 
1645 
  def getComingSoonCount(self, ):
1646 
    self.send_getComingSoonCount()
1647 
    return self.recv_getComingSoonCount()
1648 
 
1649 
  def send_getComingSoonCount(self, ):
1650 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1651 
    args = getComingSoonCount_args()
1652 
    args.write(self._oprot)
1653 
    self._oprot.writeMessageEnd()
1654 
    self._oprot.trans.flush()
1655 
 
1656 
  def recv_getComingSoonCount(self, ):
1657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1658 
    if mtype == TMessageType.EXCEPTION:
1659 
      x = TApplicationException()
1660 
      x.read(self._iprot)
1661 
      self._iprot.readMessageEnd()
1662 
      raise x
1663 
    result = getComingSoonCount_result()
1664 
    result.read(self._iprot)
1665 
    self._iprot.readMessageEnd()
1666 
    if result.success is not None:
1667 
      return result.success
1668 
    if result.cex is not None:
1669 
      raise result.cex
1670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1671 
 
1672 
  def getLatestArrivals(self, ):
1673 
    """
1674 
    Returns a list of items sorted in the descending order by start date.
1675 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1676 
    """
1677 
    self.send_getLatestArrivals()
1678 
    return self.recv_getLatestArrivals()
1679 
 
1680 
  def send_getLatestArrivals(self, ):
1681 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1682 
    args = getLatestArrivals_args()
1683 
    args.write(self._oprot)
1684 
    self._oprot.writeMessageEnd()
1685 
    self._oprot.trans.flush()
1686 
 
1687 
  def recv_getLatestArrivals(self, ):
1688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1689 
    if mtype == TMessageType.EXCEPTION:
1690 
      x = TApplicationException()
1691 
      x.read(self._iprot)
1692 
      self._iprot.readMessageEnd()
1693 
      raise x
1694 
    result = getLatestArrivals_result()
1695 
    result.read(self._iprot)
1696 
    self._iprot.readMessageEnd()
1697 
    if result.success is not None:
1698 
      return result.success
1699 
    if result.isex is not None:
1700 
      raise result.isex
1701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1702 
 
1703 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1704 
    """
1705 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1706 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1707 
 
1708 
    Parameters:
1709 
     - beginIndex
1710 
     - totalItems
1711 
     - brand
1712 
     - categories
1713 
    """
1714 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1715 
    return self.recv_getLatestArrivalsCatalogIds()
1716 
 
1717 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1718 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1719 
    args = getLatestArrivalsCatalogIds_args()
1720 
    args.beginIndex = beginIndex
1721 
    args.totalItems = totalItems
1722 
    args.brand = brand
1723 
    args.categories = categories
1724 
    args.write(self._oprot)
1725 
    self._oprot.writeMessageEnd()
1726 
    self._oprot.trans.flush()
1727 
 
1728 
  def recv_getLatestArrivalsCatalogIds(self, ):
1729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1730 
    if mtype == TMessageType.EXCEPTION:
1731 
      x = TApplicationException()
1732 
      x.read(self._iprot)
1733 
      self._iprot.readMessageEnd()
1734 
      raise x
1735 
    result = getLatestArrivalsCatalogIds_result()
1736 
    result.read(self._iprot)
1737 
    self._iprot.readMessageEnd()
1738 
    if result.success is not None:
1739 
      return result.success
1740 
    if result.cex is not None:
1741 
      raise result.cex
1742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1743 
 
1744 
  def getLatestArrivalsCount(self, ):
1745 
    """
1746 
    Get the total number of latest arrivals we are willing to show.
1747 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1748 
    """
1749 
    self.send_getLatestArrivalsCount()
1750 
    return self.recv_getLatestArrivalsCount()
1751 
 
1752 
  def send_getLatestArrivalsCount(self, ):
1753 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1754 
    args = getLatestArrivalsCount_args()
1755 
    args.write(self._oprot)
1756 
    self._oprot.writeMessageEnd()
1757 
    self._oprot.trans.flush()
1758 
 
1759 
  def recv_getLatestArrivalsCount(self, ):
1760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1761 
    if mtype == TMessageType.EXCEPTION:
1762 
      x = TApplicationException()
1763 
      x.read(self._iprot)
1764 
      self._iprot.readMessageEnd()
1765 
      raise x
1766 
    result = getLatestArrivalsCount_result()
1767 
    result.read(self._iprot)
1768 
    self._iprot.readMessageEnd()
1769 
    if result.success is not None:
1770 
      return result.success
1771 
    if result.cex is not None:
1772 
      raise result.cex
1773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1774 
 
1775 
  def generateNewEntityID(self, ):
1776 
    self.send_generateNewEntityID()
1777 
    return self.recv_generateNewEntityID()
1778 
 
1779 
  def send_generateNewEntityID(self, ):
1780 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1781 
    args = generateNewEntityID_args()
1782 
    args.write(self._oprot)
1783 
    self._oprot.writeMessageEnd()
1784 
    self._oprot.trans.flush()
1785 
 
1786 
  def recv_generateNewEntityID(self, ):
1787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1788 
    if mtype == TMessageType.EXCEPTION:
1789 
      x = TApplicationException()
1790 
      x.read(self._iprot)
1791 
      self._iprot.readMessageEnd()
1792 
      raise x
1793 
    result = generateNewEntityID_result()
1794 
    result.read(self._iprot)
1795 
    self._iprot.readMessageEnd()
1796 
    if result.success is not None:
1797 
      return result.success
1798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1799 
 
1800 
  def addCategory(self, category):
1801 
    """
1802 
    All category related functions
1803 
 
1804 
    Parameters:
1805 
     - category
1806 
    """
1807 
    self.send_addCategory(category)
1808 
    return self.recv_addCategory()
1809 
 
1810 
  def send_addCategory(self, category):
1811 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1812 
    args = addCategory_args()
1813 
    args.category = category
1814 
    args.write(self._oprot)
1815 
    self._oprot.writeMessageEnd()
1816 
    self._oprot.trans.flush()
1817 
 
1818 
  def recv_addCategory(self, ):
1819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1820 
    if mtype == TMessageType.EXCEPTION:
1821 
      x = TApplicationException()
1822 
      x.read(self._iprot)
1823 
      self._iprot.readMessageEnd()
1824 
      raise x
1825 
    result = addCategory_result()
1826 
    result.read(self._iprot)
1827 
    self._iprot.readMessageEnd()
1828 
    if result.success is not None:
1829 
      return result.success
1830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1831 
 
1832 
  def getCategory(self, id):
1833 
    """
1834 
    Parameters:
1835 
     - id
1836 
    """
1837 
    self.send_getCategory(id)
1838 
    return self.recv_getCategory()
1839 
 
1840 
  def send_getCategory(self, id):
1841 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1842 
    args = getCategory_args()
1843 
    args.id = id
1844 
    args.write(self._oprot)
1845 
    self._oprot.writeMessageEnd()
1846 
    self._oprot.trans.flush()
1847 
 
1848 
  def recv_getCategory(self, ):
1849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1850 
    if mtype == TMessageType.EXCEPTION:
1851 
      x = TApplicationException()
1852 
      x.read(self._iprot)
1853 
      self._iprot.readMessageEnd()
1854 
      raise x
1855 
    result = getCategory_result()
1856 
    result.read(self._iprot)
1857 
    self._iprot.readMessageEnd()
1858 
    if result.success is not None:
1859 
      return result.success
1860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1861 
 
1862 
  def getAllCategories(self, ):
1863 
    self.send_getAllCategories()
1864 
    return self.recv_getAllCategories()
1865 
 
1866 
  def send_getAllCategories(self, ):
1867 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1868 
    args = getAllCategories_args()
1869 
    args.write(self._oprot)
1870 
    self._oprot.writeMessageEnd()
1871 
    self._oprot.trans.flush()
1872 
 
1873 
  def recv_getAllCategories(self, ):
1874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1875 
    if mtype == TMessageType.EXCEPTION:
1876 
      x = TApplicationException()
1877 
      x.read(self._iprot)
1878 
      self._iprot.readMessageEnd()
1879 
      raise x
1880 
    result = getAllCategories_result()
1881 
    result.read(self._iprot)
1882 
    self._iprot.readMessageEnd()
1883 
    if result.success is not None:
1884 
      return result.success
1885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1886 
 
1887 
  def getAllSimilarItems(self, itemId):
1888 
    """
1889 
    Returns the list of similar items.
1890 
 
1891 
    Parameters:
1892 
     - itemId
1893 
    """
1894 
    self.send_getAllSimilarItems(itemId)
1895 
    return self.recv_getAllSimilarItems()
1896 
 
1897 
  def send_getAllSimilarItems(self, itemId):
1898 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1899 
    args = getAllSimilarItems_args()
1900 
    args.itemId = itemId
1901 
    args.write(self._oprot)
1902 
    self._oprot.writeMessageEnd()
1903 
    self._oprot.trans.flush()
1904 
 
1905 
  def recv_getAllSimilarItems(self, ):
1906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1907 
    if mtype == TMessageType.EXCEPTION:
1908 
      x = TApplicationException()
1909 
      x.read(self._iprot)
1910 
      self._iprot.readMessageEnd()
1911 
      raise x
1912 
    result = getAllSimilarItems_result()
1913 
    result.read(self._iprot)
1914 
    self._iprot.readMessageEnd()
1915 
    if result.success is not None:
1916 
      return result.success
1917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1918 
 
1919 
  def addSimilarItem(self, itemId, catalogItemId):
1920 
    """
1921 
    Adds similar item.
1922 
 
1923 
    Parameters:
1924 
     - itemId
1925 
     - catalogItemId
1926 
    """
1927 
    self.send_addSimilarItem(itemId, catalogItemId)
1928 
    return self.recv_addSimilarItem()
1929 
 
1930 
  def send_addSimilarItem(self, itemId, catalogItemId):
1931 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1932 
    args = addSimilarItem_args()
1933 
    args.itemId = itemId
1934 
    args.catalogItemId = catalogItemId
1935 
    args.write(self._oprot)
1936 
    self._oprot.writeMessageEnd()
1937 
    self._oprot.trans.flush()
1938 
 
1939 
  def recv_addSimilarItem(self, ):
1940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1941 
    if mtype == TMessageType.EXCEPTION:
1942 
      x = TApplicationException()
1943 
      x.read(self._iprot)
1944 
      self._iprot.readMessageEnd()
1945 
      raise x
1946 
    result = addSimilarItem_result()
1947 
    result.read(self._iprot)
1948 
    self._iprot.readMessageEnd()
1949 
    if result.success is not None:
1950 
      return result.success
1951 
    if result.cex is not None:
1952 
      raise result.cex
1953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1954 
 
6512 kshitij.so 1955 
  def addTag(self, displayName, itemId):
1956 
    """
1957 
    Tag Related
1958 
 
1959 
    Parameters:
1960 
     - displayName
1961 
     - itemId
1962 
    """
1963 
    self.send_addTag(displayName, itemId)
1964 
    return self.recv_addTag()
1965 
 
1966 
  def send_addTag(self, displayName, itemId):
1967 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1968 
    args = addTag_args()
1969 
    args.displayName = displayName
1970 
    args.itemId = itemId
1971 
    args.write(self._oprot)
1972 
    self._oprot.writeMessageEnd()
1973 
    self._oprot.trans.flush()
1974 
 
1975 
  def recv_addTag(self, ):
1976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1977 
    if mtype == TMessageType.EXCEPTION:
1978 
      x = TApplicationException()
1979 
      x.read(self._iprot)
1980 
      self._iprot.readMessageEnd()
1981 
      raise x
1982 
    result = addTag_result()
1983 
    result.read(self._iprot)
1984 
    self._iprot.readMessageEnd()
1985 
    if result.success is not None:
1986 
      return result.success
1987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1988 
 
1989 
  def deleteEntityTag(self, displayName, itemId):
1990 
    """
1991 
    Parameters:
1992 
     - displayName
1993 
     - itemId
1994 
    """
1995 
    self.send_deleteEntityTag(displayName, itemId)
1996 
    return self.recv_deleteEntityTag()
1997 
 
1998 
  def send_deleteEntityTag(self, displayName, itemId):
1999 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2000 
    args = deleteEntityTag_args()
2001 
    args.displayName = displayName
2002 
    args.itemId = itemId
2003 
    args.write(self._oprot)
2004 
    self._oprot.writeMessageEnd()
2005 
    self._oprot.trans.flush()
2006 
 
2007 
  def recv_deleteEntityTag(self, ):
2008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2009 
    if mtype == TMessageType.EXCEPTION:
2010 
      x = TApplicationException()
2011 
      x.read(self._iprot)
2012 
      self._iprot.readMessageEnd()
2013 
      raise x
2014 
    result = deleteEntityTag_result()
2015 
    result.read(self._iprot)
2016 
    self._iprot.readMessageEnd()
2017 
    if result.success is not None:
2018 
      return result.success
2019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2020 
 
2021 
  def deleteTag(self, displayName):
2022 
    """
2023 
    Parameters:
2024 
     - displayName
2025 
    """
2026 
    self.send_deleteTag(displayName)
2027 
    return self.recv_deleteTag()
2028 
 
2029 
  def send_deleteTag(self, displayName):
2030 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2031 
    args = deleteTag_args()
2032 
    args.displayName = displayName
2033 
    args.write(self._oprot)
2034 
    self._oprot.writeMessageEnd()
2035 
    self._oprot.trans.flush()
2036 
 
2037 
  def recv_deleteTag(self, ):
2038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2039 
    if mtype == TMessageType.EXCEPTION:
2040 
      x = TApplicationException()
2041 
      x.read(self._iprot)
2042 
      self._iprot.readMessageEnd()
2043 
      raise x
2044 
    result = deleteTag_result()
2045 
    result.read(self._iprot)
2046 
    self._iprot.readMessageEnd()
2047 
    if result.success is not None:
2048 
      return result.success
2049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2050 
 
2051 
  def getAllTags(self, ):
2052 
    self.send_getAllTags()
2053 
    return self.recv_getAllTags()
2054 
 
2055 
  def send_getAllTags(self, ):
2056 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2057 
    args = getAllTags_args()
2058 
    args.write(self._oprot)
2059 
    self._oprot.writeMessageEnd()
2060 
    self._oprot.trans.flush()
2061 
 
2062 
  def recv_getAllTags(self, ):
2063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2064 
    if mtype == TMessageType.EXCEPTION:
2065 
      x = TApplicationException()
2066 
      x.read(self._iprot)
2067 
      self._iprot.readMessageEnd()
2068 
      raise x
2069 
    result = getAllTags_result()
2070 
    result.read(self._iprot)
2071 
    self._iprot.readMessageEnd()
2072 
    if result.success is not None:
2073 
      return result.success
2074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2075 
 
2076 
  def getAllEntitiesByTagName(self, displayName):
2077 
    """
2078 
    Parameters:
2079 
     - displayName
2080 
    """
2081 
    self.send_getAllEntitiesByTagName(displayName)
2082 
    return self.recv_getAllEntitiesByTagName()
2083 
 
2084 
  def send_getAllEntitiesByTagName(self, displayName):
2085 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2086 
    args = getAllEntitiesByTagName_args()
2087 
    args.displayName = displayName
2088 
    args.write(self._oprot)
2089 
    self._oprot.writeMessageEnd()
2090 
    self._oprot.trans.flush()
2091 
 
2092 
  def recv_getAllEntitiesByTagName(self, ):
2093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2094 
    if mtype == TMessageType.EXCEPTION:
2095 
      x = TApplicationException()
2096 
      x.read(self._iprot)
2097 
      self._iprot.readMessageEnd()
2098 
      raise x
2099 
    result = getAllEntitiesByTagName_result()
2100 
    result.read(self._iprot)
2101 
    self._iprot.readMessageEnd()
2102 
    if result.success is not None:
2103 
      return result.success
2104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2105 
 
6845 amit.gupta 2106 
  def getAllEntityTags(self, ):
2107 
    self.send_getAllEntityTags()
2108 
    return self.recv_getAllEntityTags()
2109 
 
2110 
  def send_getAllEntityTags(self, ):
2111 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2112 
    args = getAllEntityTags_args()
2113 
    args.write(self._oprot)
2114 
    self._oprot.writeMessageEnd()
2115 
    self._oprot.trans.flush()
2116 
 
2117 
  def recv_getAllEntityTags(self, ):
2118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2119 
    if mtype == TMessageType.EXCEPTION:
2120 
      x = TApplicationException()
2121 
      x.read(self._iprot)
2122 
      self._iprot.readMessageEnd()
2123 
      raise x
2124 
    result = getAllEntityTags_result()
2125 
    result.read(self._iprot)
2126 
    self._iprot.readMessageEnd()
2127 
    if result.success is not None:
2128 
      return result.success
2129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2130 
 
6850 kshitij.so 2131 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2132 
    """
2133 
    Parameters:
2134 
     - bannerName
2135 
     - imageName
2136 
     - link
2137 
     - priority
2138 
     - isActive
2139 
     - hasMap
2140 
    """
2141 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2142 
    return self.recv_addBanner()
2143 
 
2144 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2145 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2146 
    args = addBanner_args()
2147 
    args.bannerName = bannerName
2148 
    args.imageName = imageName
2149 
    args.link = link
2150 
    args.priority = priority
2151 
    args.isActive = isActive
2152 
    args.hasMap = hasMap
2153 
    args.write(self._oprot)
2154 
    self._oprot.writeMessageEnd()
2155 
    self._oprot.trans.flush()
2156 
 
2157 
  def recv_addBanner(self, ):
2158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2159 
    if mtype == TMessageType.EXCEPTION:
2160 
      x = TApplicationException()
2161 
      x.read(self._iprot)
2162 
      self._iprot.readMessageEnd()
2163 
      raise x
2164 
    result = addBanner_result()
2165 
    result.read(self._iprot)
2166 
    self._iprot.readMessageEnd()
2167 
    if result.success is not None:
2168 
      return result.success
2169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2170 
 
2171 
  def getAllBanners(self, ):
2172 
    self.send_getAllBanners()
2173 
    return self.recv_getAllBanners()
2174 
 
2175 
  def send_getAllBanners(self, ):
2176 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2177 
    args = getAllBanners_args()
2178 
    args.write(self._oprot)
2179 
    self._oprot.writeMessageEnd()
2180 
    self._oprot.trans.flush()
2181 
 
2182 
  def recv_getAllBanners(self, ):
2183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2184 
    if mtype == TMessageType.EXCEPTION:
2185 
      x = TApplicationException()
2186 
      x.read(self._iprot)
2187 
      self._iprot.readMessageEnd()
2188 
      raise x
2189 
    result = getAllBanners_result()
2190 
    result.read(self._iprot)
2191 
    self._iprot.readMessageEnd()
2192 
    if result.success is not None:
2193 
      return result.success
2194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2195 
 
2196 
  def deleteBanner(self, bannerName):
2197 
    """
2198 
    Parameters:
2199 
     - bannerName
2200 
    """
2201 
    self.send_deleteBanner(bannerName)
2202 
    return self.recv_deleteBanner()
2203 
 
2204 
  def send_deleteBanner(self, bannerName):
2205 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2206 
    args = deleteBanner_args()
2207 
    args.bannerName = bannerName
2208 
    args.write(self._oprot)
2209 
    self._oprot.writeMessageEnd()
2210 
    self._oprot.trans.flush()
2211 
 
2212 
  def recv_deleteBanner(self, ):
2213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2214 
    if mtype == TMessageType.EXCEPTION:
2215 
      x = TApplicationException()
2216 
      x.read(self._iprot)
2217 
      self._iprot.readMessageEnd()
2218 
      raise x
2219 
    result = deleteBanner_result()
2220 
    result.read(self._iprot)
2221 
    self._iprot.readMessageEnd()
2222 
    if result.success is not None:
2223 
      return result.success
2224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2225 
 
2226 
  def getBannerDetails(self, bannerName):
2227 
    """
2228 
    Parameters:
2229 
     - bannerName
2230 
    """
2231 
    self.send_getBannerDetails(bannerName)
2232 
    return self.recv_getBannerDetails()
2233 
 
2234 
  def send_getBannerDetails(self, bannerName):
2235 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2236 
    args = getBannerDetails_args()
2237 
    args.bannerName = bannerName
2238 
    args.write(self._oprot)
2239 
    self._oprot.writeMessageEnd()
2240 
    self._oprot.trans.flush()
2241 
 
2242 
  def recv_getBannerDetails(self, ):
2243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2244 
    if mtype == TMessageType.EXCEPTION:
2245 
      x = TApplicationException()
2246 
      x.read(self._iprot)
2247 
      self._iprot.readMessageEnd()
2248 
      raise x
2249 
    result = getBannerDetails_result()
2250 
    result.read(self._iprot)
2251 
    self._iprot.readMessageEnd()
2252 
    if result.success is not None:
2253 
      return result.success
2254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2255 
 
2256 
  def getActiveBanners(self, ):
2257 
    self.send_getActiveBanners()
2258 
    return self.recv_getActiveBanners()
2259 
 
2260 
  def send_getActiveBanners(self, ):
2261 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2262 
    args = getActiveBanners_args()
2263 
    args.write(self._oprot)
2264 
    self._oprot.writeMessageEnd()
2265 
    self._oprot.trans.flush()
2266 
 
2267 
  def recv_getActiveBanners(self, ):
2268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2269 
    if mtype == TMessageType.EXCEPTION:
2270 
      x = TApplicationException()
2271 
      x.read(self._iprot)
2272 
      self._iprot.readMessageEnd()
2273 
      raise x
2274 
    result = getActiveBanners_result()
2275 
    result.read(self._iprot)
2276 
    self._iprot.readMessageEnd()
2277 
    if result.success is not None:
2278 
      return result.success
2279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2280 
 
6849 kshitij.so 2281 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2282 
    """
2283 
    Parameters:
2284 
     - bannerName
2285 
     - mapLink
2286 
     - coordinates
2287 
    """
2288 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2289 
    return self.recv_addBannerMap()
2290 
 
2291 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2292 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2293 
    args = addBannerMap_args()
2294 
    args.bannerName = bannerName
2295 
    args.mapLink = mapLink
2296 
    args.coordinates = coordinates
2297 
    args.write(self._oprot)
2298 
    self._oprot.writeMessageEnd()
2299 
    self._oprot.trans.flush()
2300 
 
2301 
  def recv_addBannerMap(self, ):
2302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2303 
    if mtype == TMessageType.EXCEPTION:
2304 
      x = TApplicationException()
2305 
      x.read(self._iprot)
2306 
      self._iprot.readMessageEnd()
2307 
      raise x
2308 
    result = addBannerMap_result()
2309 
    result.read(self._iprot)
2310 
    self._iprot.readMessageEnd()
2311 
    if result.success is not None:
2312 
      return result.success
2313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2314 
 
2315 
  def deleteBannerMap(self, bannerName):
2316 
    """
2317 
    Parameters:
2318 
     - bannerName
2319 
    """
2320 
    self.send_deleteBannerMap(bannerName)
2321 
    return self.recv_deleteBannerMap()
2322 
 
2323 
  def send_deleteBannerMap(self, bannerName):
2324 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2325 
    args = deleteBannerMap_args()
2326 
    args.bannerName = bannerName
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2331 
  def recv_deleteBannerMap(self, ):
2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2338 
    result = deleteBannerMap_result()
2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
2341 
    if result.success is not None:
2342 
      return result.success
2343 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2344 
 
2345 
  def getBannerMapDetails(self, bannerName):
2346 
    """
2347 
    Parameters:
2348 
     - bannerName
2349 
    """
2350 
    self.send_getBannerMapDetails(bannerName)
2351 
    return self.recv_getBannerMapDetails()
2352 
 
2353 
  def send_getBannerMapDetails(self, bannerName):
2354 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2355 
    args = getBannerMapDetails_args()
2356 
    args.bannerName = bannerName
2357 
    args.write(self._oprot)
2358 
    self._oprot.writeMessageEnd()
2359 
    self._oprot.trans.flush()
2360 
 
2361 
  def recv_getBannerMapDetails(self, ):
2362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2363 
    if mtype == TMessageType.EXCEPTION:
2364 
      x = TApplicationException()
2365 
      x.read(self._iprot)
2366 
      self._iprot.readMessageEnd()
2367 
      raise x
2368 
    result = getBannerMapDetails_result()
2369 
    result.read(self._iprot)
2370 
    self._iprot.readMessageEnd()
2371 
    if result.success is not None:
2372 
      return result.success
2373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2374 
 
5944 mandeep.dh 2375 
  def deleteSimilarItem(self, itemId, catalogItemId):
2376 
    """
2377 
    Delete similar item.
2378 
 
2379 
    Parameters:
2380 
     - itemId
2381 
     - catalogItemId
2382 
    """
2383 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2384 
    return self.recv_deleteSimilarItem()
2385 
 
2386 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2387 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2388 
    args = deleteSimilarItem_args()
2389 
    args.itemId = itemId
2390 
    args.catalogItemId = catalogItemId
2391 
    args.write(self._oprot)
2392 
    self._oprot.writeMessageEnd()
2393 
    self._oprot.trans.flush()
2394 
 
2395 
  def recv_deleteSimilarItem(self, ):
2396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2397 
    if mtype == TMessageType.EXCEPTION:
2398 
      x = TApplicationException()
2399 
      x.read(self._iprot)
2400 
      self._iprot.readMessageEnd()
2401 
      raise x
2402 
    result = deleteSimilarItem_result()
2403 
    result.read(self._iprot)
2404 
    self._iprot.readMessageEnd()
2405 
    if result.success is not None:
2406 
      return result.success
2407 
    if result.cex is not None:
2408 
      raise result.cex
2409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2410 
 
2411 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2412 
    """
2413 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2414 
    If yes, returns the itemId else returns 0
2415 
 
2416 
    Parameters:
2417 
     - brand
2418 
     - modelNumber
2419 
     - modelName
2420 
     - color
2421 
    """
2422 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2423 
    return self.recv_checkSimilarItem()
2424 
 
2425 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2426 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2427 
    args = checkSimilarItem_args()
2428 
    args.brand = brand
2429 
    args.modelNumber = modelNumber
2430 
    args.modelName = modelName
2431 
    args.color = color
2432 
    args.write(self._oprot)
2433 
    self._oprot.writeMessageEnd()
2434 
    self._oprot.trans.flush()
2435 
 
2436 
  def recv_checkSimilarItem(self, ):
2437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2438 
    if mtype == TMessageType.EXCEPTION:
2439 
      x = TApplicationException()
2440 
      x.read(self._iprot)
2441 
      self._iprot.readMessageEnd()
2442 
      raise x
2443 
    result = checkSimilarItem_result()
2444 
    result.read(self._iprot)
2445 
    self._iprot.readMessageEnd()
2446 
    if result.success is not None:
2447 
      return result.success
2448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2449 
 
2450 
  def validateRiskyStatus(self, itemId):
2451 
    """
2452 
    Check wether item is risky and change status if inventory is not available for risky items
2453 
 
2454 
    Parameters:
2455 
     - itemId
2456 
    """
2457 
    self.send_validateRiskyStatus(itemId)
2458 
    self.recv_validateRiskyStatus()
2459 
 
2460 
  def send_validateRiskyStatus(self, itemId):
2461 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2462 
    args = validateRiskyStatus_args()
2463 
    args.itemId = itemId
2464 
    args.write(self._oprot)
2465 
    self._oprot.writeMessageEnd()
2466 
    self._oprot.trans.flush()
2467 
 
2468 
  def recv_validateRiskyStatus(self, ):
2469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2470 
    if mtype == TMessageType.EXCEPTION:
2471 
      x = TApplicationException()
2472 
      x.read(self._iprot)
2473 
      self._iprot.readMessageEnd()
2474 
      raise x
2475 
    result = validateRiskyStatus_result()
2476 
    result.read(self._iprot)
2477 
    self._iprot.readMessageEnd()
2478 
    return
2479 
 
2480 
  def changeItemRiskyFlag(self, itemId, risky):
2481 
    """
2482 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2483 
 
2484 
    Parameters:
2485 
     - itemId
2486 
     - risky
2487 
    """
2488 
    self.send_changeItemRiskyFlag(itemId, risky)
2489 
    self.recv_changeItemRiskyFlag()
2490 
 
2491 
  def send_changeItemRiskyFlag(self, itemId, risky):
2492 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2493 
    args = changeItemRiskyFlag_args()
2494 
    args.itemId = itemId
2495 
    args.risky = risky
2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
2500 
  def recv_changeItemRiskyFlag(self, ):
2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
2507 
    result = changeItemRiskyFlag_result()
2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
2510 
    return
2511 
 
2512 
  def getItemsByRiskyFlag(self, ):
2513 
    """
2514 
    Returns list of items marked as risky.
2515 
    """
2516 
    self.send_getItemsByRiskyFlag()
2517 
    return self.recv_getItemsByRiskyFlag()
2518 
 
2519 
  def send_getItemsByRiskyFlag(self, ):
2520 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2521 
    args = getItemsByRiskyFlag_args()
2522 
    args.write(self._oprot)
2523 
    self._oprot.writeMessageEnd()
2524 
    self._oprot.trans.flush()
2525 
 
2526 
  def recv_getItemsByRiskyFlag(self, ):
2527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2528 
    if mtype == TMessageType.EXCEPTION:
2529 
      x = TApplicationException()
2530 
      x.read(self._iprot)
2531 
      self._iprot.readMessageEnd()
2532 
      raise x
2533 
    result = getItemsByRiskyFlag_result()
2534 
    result.read(self._iprot)
2535 
    self._iprot.readMessageEnd()
2536 
    if result.success is not None:
2537 
      return result.success
2538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2539 
 
2540 
  def getItemsForMasterSheet(self, category, brand):
2541 
    """
2542 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2543 
 
2544 
    Parameters:
2545 
     - category
2546 
     - brand
2547 
    """
2548 
    self.send_getItemsForMasterSheet(category, brand)
2549 
    return self.recv_getItemsForMasterSheet()
2550 
 
2551 
  def send_getItemsForMasterSheet(self, category, brand):
2552 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2553 
    args = getItemsForMasterSheet_args()
2554 
    args.category = category
2555 
    args.brand = brand
2556 
    args.write(self._oprot)
2557 
    self._oprot.writeMessageEnd()
2558 
    self._oprot.trans.flush()
2559 
 
2560 
  def recv_getItemsForMasterSheet(self, ):
2561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2562 
    if mtype == TMessageType.EXCEPTION:
2563 
      x = TApplicationException()
2564 
      x.read(self._iprot)
2565 
      self._iprot.readMessageEnd()
2566 
      raise x
2567 
    result = getItemsForMasterSheet_result()
2568 
    result.read(self._iprot)
2569 
    self._iprot.readMessageEnd()
2570 
    if result.success is not None:
2571 
      return result.success
2572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2573 
 
2574 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2575 
    """
2576 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2577 
 
2578 
    Parameters:
2579 
     - beginIndex
2580 
     - totalItems
2581 
     - itemId
2582 
    """
2583 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2584 
    return self.recv_getSimilarItemsCatalogIds()
2585 
 
2586 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2587 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2588 
    args = getSimilarItemsCatalogIds_args()
2589 
    args.beginIndex = beginIndex
2590 
    args.totalItems = totalItems
2591 
    args.itemId = itemId
2592 
    args.write(self._oprot)
2593 
    self._oprot.writeMessageEnd()
2594 
    self._oprot.trans.flush()
2595 
 
2596 
  def recv_getSimilarItemsCatalogIds(self, ):
2597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2598 
    if mtype == TMessageType.EXCEPTION:
2599 
      x = TApplicationException()
2600 
      x.read(self._iprot)
2601 
      self._iprot.readMessageEnd()
2602 
      raise x
2603 
    result = getSimilarItemsCatalogIds_result()
2604 
    result.read(self._iprot)
2605 
    self._iprot.readMessageEnd()
2606 
    if result.success is not None:
2607 
      return result.success
2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2609 
 
2610 
  def addProductNotification(self, itemId, email):
2611 
    """
2612 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2613 
 
2614 
    Parameters:
2615 
     - itemId
2616 
     - email
2617 
    """
2618 
    self.send_addProductNotification(itemId, email)
2619 
    return self.recv_addProductNotification()
2620 
 
2621 
  def send_addProductNotification(self, itemId, email):
2622 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2623 
    args = addProductNotification_args()
2624 
    args.itemId = itemId
2625 
    args.email = email
2626 
    args.write(self._oprot)
2627 
    self._oprot.writeMessageEnd()
2628 
    self._oprot.trans.flush()
2629 
 
2630 
  def recv_addProductNotification(self, ):
2631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2632 
    if mtype == TMessageType.EXCEPTION:
2633 
      x = TApplicationException()
2634 
      x.read(self._iprot)
2635 
      self._iprot.readMessageEnd()
2636 
      raise x
2637 
    result = addProductNotification_result()
2638 
    result.read(self._iprot)
2639 
    self._iprot.readMessageEnd()
2640 
    if result.success is not None:
2641 
      return result.success
2642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2643 
 
2644 
  def sendProductNotifications(self, ):
2645 
    """
2646 
    Send the product notifications to the users for items which has stock.
2647 
    """
2648 
    self.send_sendProductNotifications()
2649 
    return self.recv_sendProductNotifications()
2650 
 
2651 
  def send_sendProductNotifications(self, ):
2652 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2653 
    args = sendProductNotifications_args()
2654 
    args.write(self._oprot)
2655 
    self._oprot.writeMessageEnd()
2656 
    self._oprot.trans.flush()
2657 
 
2658 
  def recv_sendProductNotifications(self, ):
2659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2660 
    if mtype == TMessageType.EXCEPTION:
2661 
      x = TApplicationException()
2662 
      x.read(self._iprot)
2663 
      self._iprot.readMessageEnd()
2664 
      raise x
2665 
    result = sendProductNotifications_result()
2666 
    result.read(self._iprot)
2667 
    self._iprot.readMessageEnd()
2668 
    if result.success is not None:
2669 
      return result.success
2670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2671 
 
2672 
  def getAllBrandsByCategory(self, categoryId):
2673 
    """
2674 
    Returns list of brand names for a given category Id
2675 
 
2676 
    Parameters:
2677 
     - categoryId
2678 
    """
2679 
    self.send_getAllBrandsByCategory(categoryId)
2680 
    return self.recv_getAllBrandsByCategory()
2681 
 
2682 
  def send_getAllBrandsByCategory(self, categoryId):
2683 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2684 
    args = getAllBrandsByCategory_args()
2685 
    args.categoryId = categoryId
2686 
    args.write(self._oprot)
2687 
    self._oprot.writeMessageEnd()
2688 
    self._oprot.trans.flush()
2689 
 
2690 
  def recv_getAllBrandsByCategory(self, ):
2691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2692 
    if mtype == TMessageType.EXCEPTION:
2693 
      x = TApplicationException()
2694 
      x.read(self._iprot)
2695 
      self._iprot.readMessageEnd()
2696 
      raise x
2697 
    result = getAllBrandsByCategory_result()
2698 
    result.read(self._iprot)
2699 
    self._iprot.readMessageEnd()
2700 
    if result.success is not None:
2701 
      return result.success
2702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2703 
 
2704 
  def getAllBrands(self, ):
2705 
    """
2706 
    Returns list of brand names
2707 
    """
2708 
    self.send_getAllBrands()
2709 
    return self.recv_getAllBrands()
2710 
 
2711 
  def send_getAllBrands(self, ):
2712 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2713 
    args = getAllBrands_args()
2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
2718 
  def recv_getAllBrands(self, ):
2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
2725 
    result = getAllBrands_result()
2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
2728 
    if result.success is not None:
2729 
      return result.success
2730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2731 
 
2732 
  def getAllSources(self, ):
2733 
    """
2734 
    Return list of all sources
2735 
    """
2736 
    self.send_getAllSources()
2737 
    return self.recv_getAllSources()
2738 
 
2739 
  def send_getAllSources(self, ):
2740 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2741 
    args = getAllSources_args()
2742 
    args.write(self._oprot)
2743 
    self._oprot.writeMessageEnd()
2744 
    self._oprot.trans.flush()
2745 
 
2746 
  def recv_getAllSources(self, ):
2747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2748 
    if mtype == TMessageType.EXCEPTION:
2749 
      x = TApplicationException()
2750 
      x.read(self._iprot)
2751 
      self._iprot.readMessageEnd()
2752 
      raise x
2753 
    result = getAllSources_result()
2754 
    result.read(self._iprot)
2755 
    self._iprot.readMessageEnd()
2756 
    if result.success is not None:
2757 
      return result.success
2758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2759 
 
2760 
  def getItemPricingBySource(self, itemId, sourceId):
2761 
    """
2762 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2763 
 
2764 
    Parameters:
2765 
     - itemId
2766 
     - sourceId
2767 
    """
2768 
    self.send_getItemPricingBySource(itemId, sourceId)
2769 
    return self.recv_getItemPricingBySource()
2770 
 
2771 
  def send_getItemPricingBySource(self, itemId, sourceId):
2772 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2773 
    args = getItemPricingBySource_args()
2774 
    args.itemId = itemId
2775 
    args.sourceId = sourceId
2776 
    args.write(self._oprot)
2777 
    self._oprot.writeMessageEnd()
2778 
    self._oprot.trans.flush()
2779 
 
2780 
  def recv_getItemPricingBySource(self, ):
2781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2782 
    if mtype == TMessageType.EXCEPTION:
2783 
      x = TApplicationException()
2784 
      x.read(self._iprot)
2785 
      self._iprot.readMessageEnd()
2786 
      raise x
2787 
    result = getItemPricingBySource_result()
2788 
    result.read(self._iprot)
2789 
    self._iprot.readMessageEnd()
2790 
    if result.success is not None:
2791 
      return result.success
2792 
    if result.cex is not None:
2793 
      raise result.cex
2794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2795 
 
2796 
  def addSourceItemPricing(self, sourceItemPricing):
2797 
    """
2798 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2799 
    If item is not found or source is not found, it will throw exception.
2800 
 
2801 
    Parameters:
2802 
     - sourceItemPricing
2803 
    """
2804 
    self.send_addSourceItemPricing(sourceItemPricing)
2805 
    self.recv_addSourceItemPricing()
2806 
 
2807 
  def send_addSourceItemPricing(self, sourceItemPricing):
2808 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2809 
    args = addSourceItemPricing_args()
2810 
    args.sourceItemPricing = sourceItemPricing
2811 
    args.write(self._oprot)
2812 
    self._oprot.writeMessageEnd()
2813 
    self._oprot.trans.flush()
2814 
 
2815 
  def recv_addSourceItemPricing(self, ):
2816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2817 
    if mtype == TMessageType.EXCEPTION:
2818 
      x = TApplicationException()
2819 
      x.read(self._iprot)
2820 
      self._iprot.readMessageEnd()
2821 
      raise x
2822 
    result = addSourceItemPricing_result()
2823 
    result.read(self._iprot)
2824 
    self._iprot.readMessageEnd()
2825 
    if result.cex is not None:
2826 
      raise result.cex
2827 
    return
2828 
 
2829 
  def getAllSourcePricing(self, itemId):
2830 
    """
2831 
    Returns the list of source pricing information of an item.
2832 
    Raises an exception if item not found corresponding to itemId
2833 
 
2834 
    Parameters:
2835 
     - itemId
2836 
    """
2837 
    self.send_getAllSourcePricing(itemId)
2838 
    return self.recv_getAllSourcePricing()
2839 
 
2840 
  def send_getAllSourcePricing(self, itemId):
2841 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2842 
    args = getAllSourcePricing_args()
2843 
    args.itemId = itemId
2844 
    args.write(self._oprot)
2845 
    self._oprot.writeMessageEnd()
2846 
    self._oprot.trans.flush()
2847 
 
2848 
  def recv_getAllSourcePricing(self, ):
2849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2850 
    if mtype == TMessageType.EXCEPTION:
2851 
      x = TApplicationException()
2852 
      x.read(self._iprot)
2853 
      self._iprot.readMessageEnd()
2854 
      raise x
2855 
    result = getAllSourcePricing_result()
2856 
    result.read(self._iprot)
2857 
    self._iprot.readMessageEnd()
2858 
    if result.success is not None:
2859 
      return result.success
2860 
    if result.cex is not None:
2861 
      raise result.cex
2862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2863 
 
2864 
  def getItemForSource(self, item_id, sourceId):
2865 
    """
2866 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2867 
 
2868 
    Parameters:
2869 
     - item_id
2870 
     - sourceId
2871 
    """
2872 
    self.send_getItemForSource(item_id, sourceId)
2873 
    return self.recv_getItemForSource()
2874 
 
2875 
  def send_getItemForSource(self, item_id, sourceId):
2876 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2877 
    args = getItemForSource_args()
2878 
    args.item_id = item_id
2879 
    args.sourceId = sourceId
2880 
    args.write(self._oprot)
2881 
    self._oprot.writeMessageEnd()
2882 
    self._oprot.trans.flush()
2883 
 
2884 
  def recv_getItemForSource(self, ):
2885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2886 
    if mtype == TMessageType.EXCEPTION:
2887 
      x = TApplicationException()
2888 
      x.read(self._iprot)
2889 
      self._iprot.readMessageEnd()
2890 
      raise x
2891 
    result = getItemForSource_result()
2892 
    result.read(self._iprot)
2893 
    self._iprot.readMessageEnd()
2894 
    if result.success is not None:
2895 
      return result.success
2896 
    if result.cex is not None:
2897 
      raise result.cex
2898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2899 
 
2900 
  def searchItemsInRange(self, searchTerms, offset, limit):
2901 
    """
2902 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2903 
 
2904 
    Parameters:
2905 
     - searchTerms
2906 
     - offset
2907 
     - limit
2908 
    """
2909 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2910 
    return self.recv_searchItemsInRange()
2911 
 
2912 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2913 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2914 
    args = searchItemsInRange_args()
2915 
    args.searchTerms = searchTerms
2916 
    args.offset = offset
2917 
    args.limit = limit
2918 
    args.write(self._oprot)
2919 
    self._oprot.writeMessageEnd()
2920 
    self._oprot.trans.flush()
2921 
 
2922 
  def recv_searchItemsInRange(self, ):
2923 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2924 
    if mtype == TMessageType.EXCEPTION:
2925 
      x = TApplicationException()
2926 
      x.read(self._iprot)
2927 
      self._iprot.readMessageEnd()
2928 
      raise x
2929 
    result = searchItemsInRange_result()
2930 
    result.read(self._iprot)
2931 
    self._iprot.readMessageEnd()
2932 
    if result.success is not None:
2933 
      return result.success
2934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2935 
 
2936 
  def getSearchResultCount(self, searchTerms):
2937 
    """
2938 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2939 
 
2940 
    Parameters:
2941 
     - searchTerms
2942 
    """
2943 
    self.send_getSearchResultCount(searchTerms)
2944 
    return self.recv_getSearchResultCount()
2945 
 
2946 
  def send_getSearchResultCount(self, searchTerms):
2947 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2948 
    args = getSearchResultCount_args()
2949 
    args.searchTerms = searchTerms
2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
2954 
  def recv_getSearchResultCount(self, ):
2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
2961 
    result = getSearchResultCount_result()
2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
2964 
    if result.success is not None:
2965 
      return result.success
2966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2967 
 
2968 
  def getProductNotifications(self, startDateTime):
2969 
    """
2970 
    Returns a list of product notifications added after a supplied datetime
2971 
 
2972 
    Parameters:
2973 
     - startDateTime
2974 
    """
2975 
    self.send_getProductNotifications(startDateTime)
2976 
    return self.recv_getProductNotifications()
2977 
 
2978 
  def send_getProductNotifications(self, startDateTime):
2979 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2980 
    args = getProductNotifications_args()
2981 
    args.startDateTime = startDateTime
2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
2986 
  def recv_getProductNotifications(self, ):
2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
2993 
    result = getProductNotifications_result()
2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
2996 
    if result.success is not None:
2997 
      return result.success
2998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2999 
 
7897 amar.kumar 3000 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3001 
    """
3002 
    Returns a list of count of requests for product notification against each item
3003 
 
3004 
    Parameters:
3005 
     - startDateTime
7897 amar.kumar 3006 
     - categoryId
5944 mandeep.dh 3007 
    """
7897 amar.kumar 3008 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3009 
    return self.recv_getProductNotificationRequestCount()
3010 
 
7897 amar.kumar 3011 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3012 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3013 
    args = getProductNotificationRequestCount_args()
3014 
    args.startDateTime = startDateTime
7897 amar.kumar 3015 
    args.categoryId = categoryId
5944 mandeep.dh 3016 
    args.write(self._oprot)
3017 
    self._oprot.writeMessageEnd()
3018 
    self._oprot.trans.flush()
3019 
 
3020 
  def recv_getProductNotificationRequestCount(self, ):
3021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3022 
    if mtype == TMessageType.EXCEPTION:
3023 
      x = TApplicationException()
3024 
      x.read(self._iprot)
3025 
      self._iprot.readMessageEnd()
3026 
      raise x
3027 
    result = getProductNotificationRequestCount_result()
3028 
    result.read(self._iprot)
3029 
    self._iprot.readMessageEnd()
3030 
    if result.success is not None:
3031 
      return result.success
3032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3033 
 
3034 
  def addAuthorizationLog(self, itemId, username, reason):
3035 
    """
3036 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3037 
 
3038 
    Parameters:
3039 
     - itemId
3040 
     - username
3041 
     - reason
3042 
    """
3043 
    self.send_addAuthorizationLog(itemId, username, reason)
3044 
    return self.recv_addAuthorizationLog()
3045 
 
3046 
  def send_addAuthorizationLog(self, itemId, username, reason):
3047 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3048 
    args = addAuthorizationLog_args()
3049 
    args.itemId = itemId
3050 
    args.username = username
3051 
    args.reason = reason
3052 
    args.write(self._oprot)
3053 
    self._oprot.writeMessageEnd()
3054 
    self._oprot.trans.flush()
3055 
 
3056 
  def recv_addAuthorizationLog(self, ):
3057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3058 
    if mtype == TMessageType.EXCEPTION:
3059 
      x = TApplicationException()
3060 
      x.read(self._iprot)
3061 
      self._iprot.readMessageEnd()
3062 
      raise x
3063 
    result = addAuthorizationLog_result()
3064 
    result.read(self._iprot)
3065 
    self._iprot.readMessageEnd()
3066 
    if result.success is not None:
3067 
      return result.success
3068 
    if result.cex is not None:
3069 
      raise result.cex
3070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3071 
 
3072 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3073 
    """
3074 
    Parameters:
3075 
     - catalog_item_id
3076 
     - voucherType
3077 
     - voucherAmount
3078 
    """
3079 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3080 
    return self.recv_addupdateVoucherForItem()
3081 
 
3082 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3083 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3084 
    args = addupdateVoucherForItem_args()
3085 
    args.catalog_item_id = catalog_item_id
3086 
    args.voucherType = voucherType
3087 
    args.voucherAmount = voucherAmount
3088 
    args.write(self._oprot)
3089 
    self._oprot.writeMessageEnd()
3090 
    self._oprot.trans.flush()
3091 
 
3092 
  def recv_addupdateVoucherForItem(self, ):
3093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3094 
    if mtype == TMessageType.EXCEPTION:
3095 
      x = TApplicationException()
3096 
      x.read(self._iprot)
3097 
      self._iprot.readMessageEnd()
3098 
      raise x
3099 
    result = addupdateVoucherForItem_result()
3100 
    result.read(self._iprot)
3101 
    self._iprot.readMessageEnd()
3102 
    if result.success is not None:
3103 
      return result.success
3104 
    if result.cex is not None:
3105 
      raise result.cex
3106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3107 
 
3108 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3109 
    """
3110 
    Parameters:
3111 
     - catalog_item_id
3112 
     - voucherType
3113 
    """
3114 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3115 
    return self.recv_deleteVoucherForItem()
3116 
 
3117 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3118 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3119 
    args = deleteVoucherForItem_args()
3120 
    args.catalog_item_id = catalog_item_id
3121 
    args.voucherType = voucherType
3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_deleteVoucherForItem(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = deleteVoucherForItem_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    if result.success is not None:
3137 
      return result.success
3138 
    if result.cex is not None:
3139 
      raise result.cex
3140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3141 
 
3142 
  def getVoucherAmount(self, itemId, voucherType):
3143 
    """
3144 
    Parameters:
3145 
     - itemId
3146 
     - voucherType
3147 
    """
3148 
    self.send_getVoucherAmount(itemId, voucherType)
3149 
    return self.recv_getVoucherAmount()
3150 
 
3151 
  def send_getVoucherAmount(self, itemId, voucherType):
3152 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3153 
    args = getVoucherAmount_args()
3154 
    args.itemId = itemId
3155 
    args.voucherType = voucherType
3156 
    args.write(self._oprot)
3157 
    self._oprot.writeMessageEnd()
3158 
    self._oprot.trans.flush()
3159 
 
3160 
  def recv_getVoucherAmount(self, ):
3161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3162 
    if mtype == TMessageType.EXCEPTION:
3163 
      x = TApplicationException()
3164 
      x.read(self._iprot)
3165 
      self._iprot.readMessageEnd()
3166 
      raise x
3167 
    result = getVoucherAmount_result()
3168 
    result.read(self._iprot)
3169 
    self._iprot.readMessageEnd()
3170 
    if result.success is not None:
3171 
      return result.success
3172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3173 
 
3174 
  def getAllItemVouchers(self, itemId):
3175 
    """
3176 
    Parameters:
3177 
     - itemId
3178 
    """
3179 
    self.send_getAllItemVouchers(itemId)
3180 
    return self.recv_getAllItemVouchers()
3181 
 
3182 
  def send_getAllItemVouchers(self, itemId):
3183 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3184 
    args = getAllItemVouchers_args()
3185 
    args.itemId = itemId
3186 
    args.write(self._oprot)
3187 
    self._oprot.writeMessageEnd()
3188 
    self._oprot.trans.flush()
3189 
 
3190 
  def recv_getAllItemVouchers(self, ):
3191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3192 
    if mtype == TMessageType.EXCEPTION:
3193 
      x = TApplicationException()
3194 
      x.read(self._iprot)
3195 
      self._iprot.readMessageEnd()
3196 
      raise x
3197 
    result = getAllItemVouchers_result()
3198 
    result.read(self._iprot)
3199 
    self._iprot.readMessageEnd()
3200 
    if result.success is not None:
3201 
      return result.success
3202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3203 
 
3204 
  def isValidCatalogItemId(self, catalog_item_id):
3205 
    """
3206 
    Parameters:
3207 
     - catalog_item_id
3208 
    """
3209 
    self.send_isValidCatalogItemId(catalog_item_id)
3210 
    return self.recv_isValidCatalogItemId()
3211 
 
3212 
  def send_isValidCatalogItemId(self, catalog_item_id):
3213 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3214 
    args = isValidCatalogItemId_args()
3215 
    args.catalog_item_id = catalog_item_id
3216 
    args.write(self._oprot)
3217 
    self._oprot.writeMessageEnd()
3218 
    self._oprot.trans.flush()
3219 
 
3220 
  def recv_isValidCatalogItemId(self, ):
3221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3222 
    if mtype == TMessageType.EXCEPTION:
3223 
      x = TApplicationException()
3224 
      x.read(self._iprot)
3225 
      self._iprot.readMessageEnd()
3226 
      raise x
3227 
    result = isValidCatalogItemId_result()
3228 
    result.read(self._iprot)
3229 
    self._iprot.readMessageEnd()
3230 
    if result.success is not None:
3231 
      return result.success
3232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3233 
 
7330 amit.gupta 3234 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3235 
    """
3236 
    Parameters:
3237 
     - itemId
7330 amit.gupta 3238 
     - stateId
6039 amit.gupta 3239 
     - price
3240 
    """
7330 amit.gupta 3241 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3242 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3243 
 
7330 amit.gupta 3244 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3245 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3246 
    args = getVatPercentageForItem_args()
3247 
    args.itemId = itemId
7330 amit.gupta 3248 
    args.stateId = stateId
6039 amit.gupta 3249 
    args.price = price
3250 
    args.write(self._oprot)
3251 
    self._oprot.writeMessageEnd()
3252 
    self._oprot.trans.flush()
3253 
 
3254 
  def recv_getVatPercentageForItem(self, ):
3255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3256 
    if mtype == TMessageType.EXCEPTION:
3257 
      x = TApplicationException()
3258 
      x.read(self._iprot)
3259 
      self._iprot.readMessageEnd()
3260 
      raise x
3261 
    result = getVatPercentageForItem_result()
3262 
    result.read(self._iprot)
3263 
    self._iprot.readMessageEnd()
3264 
    if result.success is not None:
3265 
      return result.success
7340 amit.gupta 3266 
    if result.cex is not None:
3267 
      raise result.cex
6039 amit.gupta 3268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3269 
 
3270 
  def getVatAmountForItem(self, itemId, price):
3271 
    """
3272 
    Parameters:
3273 
     - itemId
3274 
     - price
3275 
    """
3276 
    self.send_getVatAmountForItem(itemId, price)
3277 
    return self.recv_getVatAmountForItem()
3278 
 
3279 
  def send_getVatAmountForItem(self, itemId, price):
3280 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3281 
    args = getVatAmountForItem_args()
3282 
    args.itemId = itemId
3283 
    args.price = price
3284 
    args.write(self._oprot)
3285 
    self._oprot.writeMessageEnd()
3286 
    self._oprot.trans.flush()
3287 
 
3288 
  def recv_getVatAmountForItem(self, ):
3289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3290 
    if mtype == TMessageType.EXCEPTION:
3291 
      x = TApplicationException()
3292 
      x.read(self._iprot)
3293 
      self._iprot.readMessageEnd()
3294 
      raise x
3295 
    result = getVatAmountForItem_result()
3296 
    result.read(self._iprot)
3297 
    self._iprot.readMessageEnd()
3298 
    if result.success is not None:
3299 
      return result.success
3300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3301 
 
6531 vikram.rag 3302 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3303 
    """
3304 
    Parameters:
3305 
     - offset
3306 
     - limit
3307 
    """
3308 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3309 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3310 
 
6531 vikram.rag 3311 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3312 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3313 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3314 
    args.offset = offset
3315 
    args.limit = limit
3316 
    args.write(self._oprot)
3317 
    self._oprot.writeMessageEnd()
3318 
    self._oprot.trans.flush()
3319 
 
3320 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3322 
    if mtype == TMessageType.EXCEPTION:
3323 
      x = TApplicationException()
3324 
      x.read(self._iprot)
3325 
      self._iprot.readMessageEnd()
3326 
      raise x
3327 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3328 
    result.read(self._iprot)
3329 
    self._iprot.readMessageEnd()
3330 
    if result.success is not None:
3331 
      return result.success
3332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3333 
 
6821 amar.kumar 3334 
  def getAllAliveItems(self, ):
3335 
    self.send_getAllAliveItems()
3336 
    return self.recv_getAllAliveItems()
3337 
 
3338 
  def send_getAllAliveItems(self, ):
3339 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3340 
    args = getAllAliveItems_args()
3341 
    args.write(self._oprot)
3342 
    self._oprot.writeMessageEnd()
3343 
    self._oprot.trans.flush()
3344 
 
3345 
  def recv_getAllAliveItems(self, ):
3346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3347 
    if mtype == TMessageType.EXCEPTION:
3348 
      x = TApplicationException()
3349 
      x.read(self._iprot)
3350 
      self._iprot.readMessageEnd()
3351 
      raise x
3352 
    result = getAllAliveItems_result()
3353 
    result.read(self._iprot)
3354 
    self._iprot.readMessageEnd()
3355 
    if result.success is not None:
3356 
      return result.success
3357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3358 
 
6921 anupam.sin 3359 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3360 
    """
3361 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3362 
 
6805 anupam.sin 3363 
    Parameters:
3364 
     - itemId
6921 anupam.sin 3365 
     - price
6805 anupam.sin 3366 
     - insurerId
3367 
     - quantity
3368 
    """
6921 anupam.sin 3369 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3370 
    return self.recv_getInsuranceAmount()
3371 
 
6921 anupam.sin 3372 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3373 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3374 
    args = getInsuranceAmount_args()
3375 
    args.itemId = itemId
6921 anupam.sin 3376 
    args.price = price
6805 anupam.sin 3377 
    args.insurerId = insurerId
3378 
    args.quantity = quantity
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_getInsuranceAmount(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = getInsuranceAmount_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3396 
 
3397 
  def getInsurer(self, insurerId):
3398 
    """
3399 
    Parameters:
3400 
     - insurerId
3401 
    """
3402 
    self.send_getInsurer(insurerId)
3403 
    return self.recv_getInsurer()
3404 
 
3405 
  def send_getInsurer(self, insurerId):
3406 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3407 
    args = getInsurer_args()
3408 
    args.insurerId = insurerId
3409 
    args.write(self._oprot)
3410 
    self._oprot.writeMessageEnd()
3411 
    self._oprot.trans.flush()
3412 
 
3413 
  def recv_getInsurer(self, ):
3414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3415 
    if mtype == TMessageType.EXCEPTION:
3416 
      x = TApplicationException()
3417 
      x.read(self._iprot)
3418 
      self._iprot.readMessageEnd()
3419 
      raise x
3420 
    result = getInsurer_result()
3421 
    result.read(self._iprot)
3422 
    self._iprot.readMessageEnd()
3423 
    if result.success is not None:
3424 
      return result.success
3425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3426 
 
6838 vikram.rag 3427 
  def getAllInsurers(self, ):
3428 
    self.send_getAllInsurers()
3429 
    return self.recv_getAllInsurers()
6805 anupam.sin 3430 
 
6838 vikram.rag 3431 
  def send_getAllInsurers(self, ):
3432 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3433 
    args = getAllInsurers_args()
3434 
    args.write(self._oprot)
3435 
    self._oprot.writeMessageEnd()
3436 
    self._oprot.trans.flush()
3437 
 
3438 
  def recv_getAllInsurers(self, ):
3439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3440 
    if mtype == TMessageType.EXCEPTION:
3441 
      x = TApplicationException()
3442 
      x.read(self._iprot)
3443 
      self._iprot.readMessageEnd()
3444 
      raise x
3445 
    result = getAllInsurers_result()
3446 
    result.read(self._iprot)
3447 
    self._iprot.readMessageEnd()
3448 
    if result.success is not None:
3449 
      return result.success
3450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3451 
 
6962 rajveer 3452 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3453 
    """
3454 
    Parameters:
3455 
     - insurerId
3456 
     - amount
3457 
    """
3458 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3459 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3460 
 
6962 rajveer 3461 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3462 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3463 
    args = updateInsuranceDeclaredAmount_args()
3464 
    args.insurerId = insurerId
3465 
    args.amount = amount
3466 
    args.write(self._oprot)
3467 
    self._oprot.writeMessageEnd()
3468 
    self._oprot.trans.flush()
3469 
 
3470 
  def recv_updateInsuranceDeclaredAmount(self, ):
3471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3472 
    if mtype == TMessageType.EXCEPTION:
3473 
      x = TApplicationException()
3474 
      x.read(self._iprot)
3475 
      self._iprot.readMessageEnd()
3476 
      raise x
3477 
    result = updateInsuranceDeclaredAmount_result()
3478 
    result.read(self._iprot)
3479 
    self._iprot.readMessageEnd()
3480 
    return
3481 
 
7190 amar.kumar 3482 
  def getFreebieForItem(self, itemId):
3483 
    """
3484 
    Parameters:
3485 
     - itemId
3486 
    """
3487 
    self.send_getFreebieForItem(itemId)
3488 
    return self.recv_getFreebieForItem()
6962 rajveer 3489 
 
7190 amar.kumar 3490 
  def send_getFreebieForItem(self, itemId):
3491 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3492 
    args = getFreebieForItem_args()
3493 
    args.itemId = itemId
3494 
    args.write(self._oprot)
3495 
    self._oprot.writeMessageEnd()
3496 
    self._oprot.trans.flush()
3497 
 
3498 
  def recv_getFreebieForItem(self, ):
3499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3500 
    if mtype == TMessageType.EXCEPTION:
3501 
      x = TApplicationException()
3502 
      x.read(self._iprot)
3503 
      self._iprot.readMessageEnd()
3504 
      raise x
3505 
    result = getFreebieForItem_result()
3506 
    result.read(self._iprot)
3507 
    self._iprot.readMessageEnd()
3508 
    if result.success is not None:
3509 
      return result.success
3510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3511 
 
3512 
  def addOrUpdateFreebieForItem(self, freebieItem):
3513 
    """
3514 
    Parameters:
3515 
     - freebieItem
3516 
    """
3517 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3518 
    self.recv_addOrUpdateFreebieForItem()
3519 
 
3520 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3521 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3522 
    args = addOrUpdateFreebieForItem_args()
3523 
    args.freebieItem = freebieItem
3524 
    args.write(self._oprot)
3525 
    self._oprot.writeMessageEnd()
3526 
    self._oprot.trans.flush()
3527 
 
3528 
  def recv_addOrUpdateFreebieForItem(self, ):
3529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3530 
    if mtype == TMessageType.EXCEPTION:
3531 
      x = TApplicationException()
3532 
      x.read(self._iprot)
3533 
      self._iprot.readMessageEnd()
3534 
      raise x
3535 
    result = addOrUpdateFreebieForItem_result()
3536 
    result.read(self._iprot)
3537 
    self._iprot.readMessageEnd()
3538 
    return
3539 
 
7272 amit.gupta 3540 
  def addOrUpdateBrandInfo(self, brandInfo):
3541 
    """
3542 
    Parameters:
3543 
     - brandInfo
3544 
    """
3545 
    self.send_addOrUpdateBrandInfo(brandInfo)
3546 
    self.recv_addOrUpdateBrandInfo()
3547 
 
3548 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3549 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3550 
    args = addOrUpdateBrandInfo_args()
3551 
    args.brandInfo = brandInfo
3552 
    args.write(self._oprot)
3553 
    self._oprot.writeMessageEnd()
3554 
    self._oprot.trans.flush()
3555 
 
3556 
  def recv_addOrUpdateBrandInfo(self, ):
3557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3558 
    if mtype == TMessageType.EXCEPTION:
3559 
      x = TApplicationException()
3560 
      x.read(self._iprot)
3561 
      self._iprot.readMessageEnd()
3562 
      raise x
3563 
    result = addOrUpdateBrandInfo_result()
3564 
    result.read(self._iprot)
3565 
    self._iprot.readMessageEnd()
3566 
    return
3567 
 
3568 
  def getBrandInfo(self, ):
3569 
    self.send_getBrandInfo()
3570 
    return self.recv_getBrandInfo()
3571 
 
3572 
  def send_getBrandInfo(self, ):
3573 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3574 
    args = getBrandInfo_args()
3575 
    args.write(self._oprot)
3576 
    self._oprot.writeMessageEnd()
3577 
    self._oprot.trans.flush()
3578 
 
3579 
  def recv_getBrandInfo(self, ):
3580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3581 
    if mtype == TMessageType.EXCEPTION:
3582 
      x = TApplicationException()
3583 
      x.read(self._iprot)
3584 
      self._iprot.readMessageEnd()
3585 
      raise x
3586 
    result = getBrandInfo_result()
3587 
    result.read(self._iprot)
3588 
    self._iprot.readMessageEnd()
3589 
    if result.success is not None:
3590 
      return result.success
3591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3592 
 
7256 rajveer 3593 
  def getStorePricing(self, itemId):
3594 
    """
3595 
    Parameters:
3596 
     - itemId
3597 
    """
3598 
    self.send_getStorePricing(itemId)
3599 
    return self.recv_getStorePricing()
7190 amar.kumar 3600 
 
7256 rajveer 3601 
  def send_getStorePricing(self, itemId):
3602 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3603 
    args = getStorePricing_args()
3604 
    args.itemId = itemId
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_getStorePricing(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = getStorePricing_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3619 
    if result.success is not None:
3620 
      return result.success
3621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3622 
 
7306 rajveer 3623 
  def getStorePricings(self, itemIds):
3624 
    """
3625 
    Parameters:
3626 
     - itemIds
3627 
    """
3628 
    self.send_getStorePricings(itemIds)
3629 
    return self.recv_getStorePricings()
3630 
 
3631 
  def send_getStorePricings(self, itemIds):
3632 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3633 
    args = getStorePricings_args()
3634 
    args.itemIds = itemIds
3635 
    args.write(self._oprot)
3636 
    self._oprot.writeMessageEnd()
3637 
    self._oprot.trans.flush()
3638 
 
3639 
  def recv_getStorePricings(self, ):
3640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3641 
    if mtype == TMessageType.EXCEPTION:
3642 
      x = TApplicationException()
3643 
      x.read(self._iprot)
3644 
      self._iprot.readMessageEnd()
3645 
      raise x
3646 
    result = getStorePricings_result()
3647 
    result.read(self._iprot)
3648 
    self._iprot.readMessageEnd()
3649 
    if result.success is not None:
3650 
      return result.success
3651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3652 
 
7382 rajveer 3653 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3654 
    """
3655 
    Parameters:
3656 
     - sp
7382 rajveer 3657 
     - allColors
7265 rajveer 3658 
    """
7382 rajveer 3659 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3660 
    self.recv_updateStorePricing()
7256 rajveer 3661 
 
7382 rajveer 3662 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3663 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3664 
    args = updateStorePricing_args()
3665 
    args.sp = sp
7382 rajveer 3666 
    args.allColors = allColors
7265 rajveer 3667 
    args.write(self._oprot)
3668 
    self._oprot.writeMessageEnd()
3669 
    self._oprot.trans.flush()
3670 
 
3671 
  def recv_updateStorePricing(self, ):
3672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3673 
    if mtype == TMessageType.EXCEPTION:
3674 
      x = TApplicationException()
3675 
      x.read(self._iprot)
3676 
      self._iprot.readMessageEnd()
3677 
      raise x
3678 
    result = updateStorePricing_result()
3679 
    result.read(self._iprot)
3680 
    self._iprot.readMessageEnd()
3681 
    return
3682 
 
7281 kshitij.so 3683 
  def getAllAmazonListedItems(self, ):
3684 
    self.send_getAllAmazonListedItems()
3685 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3686 
 
7281 kshitij.so 3687 
  def send_getAllAmazonListedItems(self, ):
3688 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3689 
    args = getAllAmazonListedItems_args()
3690 
    args.write(self._oprot)
3691 
    self._oprot.writeMessageEnd()
3692 
    self._oprot.trans.flush()
3693 
 
3694 
  def recv_getAllAmazonListedItems(self, ):
3695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3696 
    if mtype == TMessageType.EXCEPTION:
3697 
      x = TApplicationException()
3698 
      x.read(self._iprot)
3699 
      self._iprot.readMessageEnd()
3700 
      raise x
3701 
    result = getAllAmazonListedItems_result()
3702 
    result.read(self._iprot)
3703 
    self._iprot.readMessageEnd()
3704 
    if result.success is not None:
3705 
      return result.success
3706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3707 
 
3708 
  def getAmazonItemDetails(self, itemId):
3709 
    """
3710 
    Parameters:
3711 
     - itemId
3712 
    """
3713 
    self.send_getAmazonItemDetails(itemId)
3714 
    return self.recv_getAmazonItemDetails()
3715 
 
3716 
  def send_getAmazonItemDetails(self, itemId):
3717 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3718 
    args = getAmazonItemDetails_args()
3719 
    args.itemId = itemId
3720 
    args.write(self._oprot)
3721 
    self._oprot.writeMessageEnd()
3722 
    self._oprot.trans.flush()
3723 
 
3724 
  def recv_getAmazonItemDetails(self, ):
3725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3726 
    if mtype == TMessageType.EXCEPTION:
3727 
      x = TApplicationException()
3728 
      x.read(self._iprot)
3729 
      self._iprot.readMessageEnd()
3730 
      raise x
3731 
    result = getAmazonItemDetails_result()
3732 
    result.read(self._iprot)
3733 
    self._iprot.readMessageEnd()
3734 
    if result.success is not None:
3735 
      return result.success
3736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3737 
 
8168 kshitij.so 3738 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 3739 
    """
3740 
    Parameters:
8168 kshitij.so 3741 
     - amazonlisted
7281 kshitij.so 3742 
    """
8168 kshitij.so 3743 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 3744 
    self.recv_updateAmazonItemDetails()
3745 
 
8168 kshitij.so 3746 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 3747 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3748 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 3749 
    args.amazonlisted = amazonlisted
7281 kshitij.so 3750 
    args.write(self._oprot)
3751 
    self._oprot.writeMessageEnd()
3752 
    self._oprot.trans.flush()
3753 
 
3754 
  def recv_updateAmazonItemDetails(self, ):
3755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3756 
    if mtype == TMessageType.EXCEPTION:
3757 
      x = TApplicationException()
3758 
      x.read(self._iprot)
3759 
      self._iprot.readMessageEnd()
3760 
      raise x
3761 
    result = updateAmazonItemDetails_result()
3762 
    result.read(self._iprot)
3763 
    self._iprot.readMessageEnd()
3764 
    return
3765 
 
3766 
  def addAmazonItem(self, amazonlisted):
3767 
    """
3768 
    Parameters:
3769 
     - amazonlisted
3770 
    """
3771 
    self.send_addAmazonItem(amazonlisted)
3772 
    self.recv_addAmazonItem()
3773 
 
3774 
  def send_addAmazonItem(self, amazonlisted):
3775 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3776 
    args = addAmazonItem_args()
3777 
    args.amazonlisted = amazonlisted
3778 
    args.write(self._oprot)
3779 
    self._oprot.writeMessageEnd()
3780 
    self._oprot.trans.flush()
3781 
 
3782 
  def recv_addAmazonItem(self, ):
3783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3784 
    if mtype == TMessageType.EXCEPTION:
3785 
      x = TApplicationException()
3786 
      x.read(self._iprot)
3787 
      self._iprot.readMessageEnd()
3788 
      raise x
3789 
    result = addAmazonItem_result()
3790 
    result.read(self._iprot)
3791 
    self._iprot.readMessageEnd()
3792 
    return
3793 
 
7291 vikram.rag 3794 
  def getAsinItems(self, ):
3795 
    self.send_getAsinItems()
3796 
    return self.recv_getAsinItems()
7281 kshitij.so 3797 
 
7291 vikram.rag 3798 
  def send_getAsinItems(self, ):
3799 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3800 
    args = getAsinItems_args()
3801 
    args.write(self._oprot)
3802 
    self._oprot.writeMessageEnd()
3803 
    self._oprot.trans.flush()
3804 
 
3805 
  def recv_getAsinItems(self, ):
3806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3807 
    if mtype == TMessageType.EXCEPTION:
3808 
      x = TApplicationException()
3809 
      x.read(self._iprot)
3810 
      self._iprot.readMessageEnd()
3811 
      raise x
3812 
    result = getAsinItems_result()
3813 
    result.read(self._iprot)
3814 
    self._iprot.readMessageEnd()
3815 
    if result.success is not None:
3816 
      return result.success
3817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3818 
 
3819 
  def getAllFbaListedItems(self, ):
3820 
    self.send_getAllFbaListedItems()
3821 
    return self.recv_getAllFbaListedItems()
3822 
 
3823 
  def send_getAllFbaListedItems(self, ):
3824 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3825 
    args = getAllFbaListedItems_args()
3826 
    args.write(self._oprot)
3827 
    self._oprot.writeMessageEnd()
3828 
    self._oprot.trans.flush()
3829 
 
3830 
  def recv_getAllFbaListedItems(self, ):
3831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3832 
    if mtype == TMessageType.EXCEPTION:
3833 
      x = TApplicationException()
3834 
      x.read(self._iprot)
3835 
      self._iprot.readMessageEnd()
3836 
      raise x
3837 
    result = getAllFbaListedItems_result()
3838 
    result.read(self._iprot)
3839 
    self._iprot.readMessageEnd()
3840 
    if result.success is not None:
3841 
      return result.success
3842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3843 
 
3844 
  def getAllNonFbaListedItems(self, ):
3845 
    self.send_getAllNonFbaListedItems()
3846 
    return self.recv_getAllNonFbaListedItems()
3847 
 
3848 
  def send_getAllNonFbaListedItems(self, ):
3849 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3850 
    args = getAllNonFbaListedItems_args()
3851 
    args.write(self._oprot)
3852 
    self._oprot.writeMessageEnd()
3853 
    self._oprot.trans.flush()
3854 
 
3855 
  def recv_getAllNonFbaListedItems(self, ):
3856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3857 
    if mtype == TMessageType.EXCEPTION:
3858 
      x = TApplicationException()
3859 
      x.read(self._iprot)
3860 
      self._iprot.readMessageEnd()
3861 
      raise x
3862 
    result = getAllNonFbaListedItems_result()
3863 
    result.read(self._iprot)
3864 
    self._iprot.readMessageEnd()
3865 
    if result.success is not None:
3866 
      return result.success
3867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3868 
 
7460 kshitij.so 3869 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3870 
    """
3871 
    Parameters:
3872 
     - itemId
3873 
     - holdInventory
3874 
     - defaultInventory
3875 
    """
3876 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3877 
    return self.recv_updateItemInventory()
7291 vikram.rag 3878 
 
7460 kshitij.so 3879 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3880 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3881 
    args = updateItemInventory_args()
3882 
    args.itemId = itemId
3883 
    args.holdInventory = holdInventory
3884 
    args.defaultInventory = defaultInventory
3885 
    args.write(self._oprot)
3886 
    self._oprot.writeMessageEnd()
3887 
    self._oprot.trans.flush()
3888 
 
3889 
  def recv_updateItemInventory(self, ):
3890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3891 
    if mtype == TMessageType.EXCEPTION:
3892 
      x = TApplicationException()
3893 
      x.read(self._iprot)
3894 
      self._iprot.readMessageEnd()
3895 
      raise x
3896 
    result = updateItemInventory_result()
3897 
    result.read(self._iprot)
3898 
    self._iprot.readMessageEnd()
3899 
    if result.success is not None:
3900 
      return result.success
3901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3902 
 
7770 kshitij.so 3903 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3904 
    """
3905 
    Parameters:
3906 
     - type
3907 
     - sku
3908 
     - timestamp
3909 
    """
3910 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
3911 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 3912 
 
7770 kshitij.so 3913 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3914 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
3915 
    args = updateTimestampForAmazonFeeds_args()
3916 
    args.type = type
3917 
    args.sku = sku
3918 
    args.timestamp = timestamp
3919 
    args.write(self._oprot)
3920 
    self._oprot.writeMessageEnd()
3921 
    self._oprot.trans.flush()
3922 
 
3923 
  def recv_updateTimestampForAmazonFeeds(self, ):
3924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3925 
    if mtype == TMessageType.EXCEPTION:
3926 
      x = TApplicationException()
3927 
      x.read(self._iprot)
3928 
      self._iprot.readMessageEnd()
3929 
      raise x
3930 
    result = updateTimestampForAmazonFeeds_result()
3931 
    result.read(self._iprot)
3932 
    self._iprot.readMessageEnd()
3933 
    if result.success is not None:
3934 
      return result.success
3935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
3936 
 
7897 amar.kumar 3937 
  def getAllParentCategories(self, ):
3938 
    self.send_getAllParentCategories()
3939 
    return self.recv_getAllParentCategories()
7770 kshitij.so 3940 
 
7897 amar.kumar 3941 
  def send_getAllParentCategories(self, ):
3942 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
3943 
    args = getAllParentCategories_args()
3944 
    args.write(self._oprot)
3945 
    self._oprot.writeMessageEnd()
3946 
    self._oprot.trans.flush()
3947 
 
3948 
  def recv_getAllParentCategories(self, ):
3949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3950 
    if mtype == TMessageType.EXCEPTION:
3951 
      x = TApplicationException()
3952 
      x.read(self._iprot)
3953 
      self._iprot.readMessageEnd()
3954 
      raise x
3955 
    result = getAllParentCategories_result()
3956 
    result.read(self._iprot)
3957 
    self._iprot.readMessageEnd()
3958 
    if result.success is not None:
3959 
      return result.success
3960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
3961 
 
7977 kshitij.so 3962 
  def addPageViewEvent(self, pageViewEvents):
3963 
    """
3964 
    Parameters:
3965 
     - pageViewEvents
3966 
    """
3967 
    self.send_addPageViewEvent(pageViewEvents)
3968 
    self.recv_addPageViewEvent()
7897 amar.kumar 3969 
 
7977 kshitij.so 3970 
  def send_addPageViewEvent(self, pageViewEvents):
3971 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
3972 
    args = addPageViewEvent_args()
3973 
    args.pageViewEvents = pageViewEvents
3974 
    args.write(self._oprot)
3975 
    self._oprot.writeMessageEnd()
3976 
    self._oprot.trans.flush()
3977 
 
3978 
  def recv_addPageViewEvent(self, ):
3979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3980 
    if mtype == TMessageType.EXCEPTION:
3981 
      x = TApplicationException()
3982 
      x.read(self._iprot)
3983 
      self._iprot.readMessageEnd()
3984 
      raise x
3985 
    result = addPageViewEvent_result()
3986 
    result.read(self._iprot)
3987 
    self._iprot.readMessageEnd()
3988 
    return
3989 
 
3990 
  def addCartEvent(self, cartEvents):
3991 
    """
3992 
    Parameters:
3993 
     - cartEvents
3994 
    """
3995 
    self.send_addCartEvent(cartEvents)
3996 
    self.recv_addCartEvent()
3997 
 
3998 
  def send_addCartEvent(self, cartEvents):
3999 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4000 
    args = addCartEvent_args()
4001 
    args.cartEvents = cartEvents
4002 
    args.write(self._oprot)
4003 
    self._oprot.writeMessageEnd()
4004 
    self._oprot.trans.flush()
4005 
 
4006 
  def recv_addCartEvent(self, ):
4007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4008 
    if mtype == TMessageType.EXCEPTION:
4009 
      x = TApplicationException()
4010 
      x.read(self._iprot)
4011 
      self._iprot.readMessageEnd()
4012 
      raise x
4013 
    result = addCartEvent_result()
4014 
    result.read(self._iprot)
4015 
    self._iprot.readMessageEnd()
4016 
    return
4017 
 
8182 amar.kumar 4018 
  def addEbayItem(self, ebayItem):
4019 
    """
4020 
    Parameters:
4021 
     - ebayItem
4022 
    """
4023 
    self.send_addEbayItem(ebayItem)
4024 
    self.recv_addEbayItem()
4025 
 
4026 
  def send_addEbayItem(self, ebayItem):
4027 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4028 
    args = addEbayItem_args()
4029 
    args.ebayItem = ebayItem
4030 
    args.write(self._oprot)
4031 
    self._oprot.writeMessageEnd()
4032 
    self._oprot.trans.flush()
4033 
 
4034 
  def recv_addEbayItem(self, ):
4035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4036 
    if mtype == TMessageType.EXCEPTION:
4037 
      x = TApplicationException()
4038 
      x.read(self._iprot)
4039 
      self._iprot.readMessageEnd()
4040 
      raise x
4041 
    result = addEbayItem_result()
4042 
    result.read(self._iprot)
4043 
    self._iprot.readMessageEnd()
4044 
    return
4045 
 
4046 
  def getEbayItem(self, listingId):
4047 
    """
4048 
    Parameters:
4049 
     - listingId
4050 
    """
4051 
    self.send_getEbayItem(listingId)
4052 
    return self.recv_getEbayItem()
4053 
 
4054 
  def send_getEbayItem(self, listingId):
4055 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4056 
    args = getEbayItem_args()
4057 
    args.listingId = listingId
4058 
    args.write(self._oprot)
4059 
    self._oprot.writeMessageEnd()
4060 
    self._oprot.trans.flush()
4061 
 
4062 
  def recv_getEbayItem(self, ):
4063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4064 
    if mtype == TMessageType.EXCEPTION:
4065 
      x = TApplicationException()
4066 
      x.read(self._iprot)
4067 
      self._iprot.readMessageEnd()
4068 
      raise x
4069 
    result = getEbayItem_result()
4070 
    result.read(self._iprot)
4071 
    self._iprot.readMessageEnd()
4072 
    if result.success is not None:
4073 
      return result.success
4074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4075 
 
4076 
  def updateEbayItem(self, ebayItem):
4077 
    """
4078 
    Parameters:
4079 
     - ebayItem
4080 
    """
4081 
    self.send_updateEbayItem(ebayItem)
4082 
    self.recv_updateEbayItem()
4083 
 
4084 
  def send_updateEbayItem(self, ebayItem):
4085 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4086 
    args = updateEbayItem_args()
4087 
    args.ebayItem = ebayItem
4088 
    args.write(self._oprot)
4089 
    self._oprot.writeMessageEnd()
4090 
    self._oprot.trans.flush()
4091 
 
4092 
  def recv_updateEbayItem(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 = updateEbayItem_result()
4100 
    result.read(self._iprot)
4101 
    self._iprot.readMessageEnd()
4102 
    return
4103 
 
8139 kshitij.so 4104 
  def getAmazonListedItems(self, offset, limit):
4105 
    """
4106 
    Parameters:
4107 
     - offset
4108 
     - limit
4109 
    """
4110 
    self.send_getAmazonListedItems(offset, limit)
4111 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4112 
 
8139 kshitij.so 4113 
  def send_getAmazonListedItems(self, offset, limit):
4114 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4115 
    args = getAmazonListedItems_args()
4116 
    args.offset = offset
4117 
    args.limit = limit
4118 
    args.write(self._oprot)
4119 
    self._oprot.writeMessageEnd()
4120 
    self._oprot.trans.flush()
4121 
 
4122 
  def recv_getAmazonListedItems(self, ):
4123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4124 
    if mtype == TMessageType.EXCEPTION:
4125 
      x = TApplicationException()
4126 
      x.read(self._iprot)
4127 
      self._iprot.readMessageEnd()
4128 
      raise x
4129 
    result = getAmazonListedItems_result()
4130 
    result.read(self._iprot)
4131 
    self._iprot.readMessageEnd()
4132 
    if result.success is not None:
4133 
      return result.success
4134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4135 
 
8168 kshitij.so 4136 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4137 
    """
4138 
    Parameters:
4139 
     - amazonlisted
4140 
    """
4141 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4142 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4143 
 
8168 kshitij.so 4144 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4145 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4146 
    args = updateAmazonAttributesInBulk_args()
4147 
    args.amazonlisted = amazonlisted
4148 
    args.write(self._oprot)
4149 
    self._oprot.writeMessageEnd()
4150 
    self._oprot.trans.flush()
4151 
 
4152 
  def recv_updateAmazonAttributesInBulk(self, ):
4153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4154 
    if mtype == TMessageType.EXCEPTION:
4155 
      x = TApplicationException()
4156 
      x.read(self._iprot)
4157 
      self._iprot.readMessageEnd()
4158 
      raise x
4159 
    result = updateAmazonAttributesInBulk_result()
4160 
    result.read(self._iprot)
4161 
    self._iprot.readMessageEnd()
4162 
    if result.success is not None:
4163 
      return result.success
4164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4165 
 
8379 vikram.rag 4166 
  def getAllItemstoListOnFba(self, ):
4167 
    self.send_getAllItemstoListOnFba()
4168 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4169 
 
8379 vikram.rag 4170 
  def send_getAllItemstoListOnFba(self, ):
4171 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4172 
    args = getAllItemstoListOnFba_args()
4173 
    args.write(self._oprot)
4174 
    self._oprot.writeMessageEnd()
4175 
    self._oprot.trans.flush()
4176 
 
4177 
  def recv_getAllItemstoListOnFba(self, ):
4178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4179 
    if mtype == TMessageType.EXCEPTION:
4180 
      x = TApplicationException()
4181 
      x.read(self._iprot)
4182 
      self._iprot.readMessageEnd()
4183 
      raise x
4184 
    result = getAllItemstoListOnFba_result()
4185 
    result.read(self._iprot)
4186 
    self._iprot.readMessageEnd()
4187 
    if result.success is not None:
4188 
      return result.success
4189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4190 
 
4191 
  def getAllItemstoListOnNonFba(self, ):
4192 
    self.send_getAllItemstoListOnNonFba()
4193 
    return self.recv_getAllItemstoListOnNonFba()
4194 
 
4195 
  def send_getAllItemstoListOnNonFba(self, ):
4196 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4197 
    args = getAllItemstoListOnNonFba_args()
4198 
    args.write(self._oprot)
4199 
    self._oprot.writeMessageEnd()
4200 
    self._oprot.trans.flush()
4201 
 
4202 
  def recv_getAllItemstoListOnNonFba(self, ):
4203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4204 
    if mtype == TMessageType.EXCEPTION:
4205 
      x = TApplicationException()
4206 
      x.read(self._iprot)
4207 
      self._iprot.readMessageEnd()
4208 
      raise x
4209 
    result = getAllItemstoListOnNonFba_result()
4210 
    result.read(self._iprot)
4211 
    self._iprot.readMessageEnd()
4212 
    if result.success is not None:
4213 
      return result.success
4214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4215 
 
4216 
 
5944 mandeep.dh 4217 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4218 
  def __init__(self, handler):
4219 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4220 
    self._processMap["addItem"] = Processor.process_addItem
4221 
    self._processMap["updateItem"] = Processor.process_updateItem
4222 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4223 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4224 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4225 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4226 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4227 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4228 
    self._processMap["getItem"] = Processor.process_getItem
4229 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4230 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4231 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4232 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4233 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4234 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4235 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4236 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4237 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4238 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4239 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4240 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4241 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4242 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4243 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4244 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4245 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4246 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4247 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4248 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4249 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4250 
    self._processMap["addCategory"] = Processor.process_addCategory
4251 
    self._processMap["getCategory"] = Processor.process_getCategory
4252 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4253 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4254 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4255 
    self._processMap["addTag"] = Processor.process_addTag
4256 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4257 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4258 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4259 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4260 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4261 
    self._processMap["addBanner"] = Processor.process_addBanner
4262 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4263 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4264 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4265 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4266 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
4267 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4268 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 4269 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4270 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4271 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4272 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4273 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4274 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4275 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4276 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4277 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4278 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4279 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4280 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4281 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4282 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4283 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4284 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4285 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4286 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4287 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4288 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4289 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4290 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4291 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4292 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4293 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4294 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4295 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4296 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4297 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4298 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4299 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4300 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4301 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4302 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4303 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4304 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4305 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4306 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4307 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4308 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4309 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4310 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4311 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4312 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4313 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4314 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4315 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4316 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4317 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4318 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4319 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4320 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4321 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4322 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4323 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4324 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4325 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4326 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 4327 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
4328 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
5944 mandeep.dh 4329 
 
4330 
  def process(self, iprot, oprot):
4331 
    (name, type, seqid) = iprot.readMessageBegin()
4332 
    if name not in self._processMap:
4333 
      iprot.skip(TType.STRUCT)
4334 
      iprot.readMessageEnd()
4335 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4336 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4337 
      x.write(oprot)
4338 
      oprot.writeMessageEnd()
4339 
      oprot.trans.flush()
4340 
      return
4341 
    else:
4342 
      self._processMap[name](self, seqid, iprot, oprot)
4343 
    return True
4344 
 
4345 
  def process_addItem(self, seqid, iprot, oprot):
4346 
    args = addItem_args()
4347 
    args.read(iprot)
4348 
    iprot.readMessageEnd()
4349 
    result = addItem_result()
4350 
    try:
4351 
      result.success = self._handler.addItem(args.item)
4352 
    except CatalogServiceException, cex:
4353 
      result.cex = cex
4354 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4355 
    result.write(oprot)
4356 
    oprot.writeMessageEnd()
4357 
    oprot.trans.flush()
4358 
 
4359 
  def process_updateItem(self, seqid, iprot, oprot):
4360 
    args = updateItem_args()
4361 
    args.read(iprot)
4362 
    iprot.readMessageEnd()
4363 
    result = updateItem_result()
4364 
    try:
4365 
      result.success = self._handler.updateItem(args.item)
4366 
    except CatalogServiceException, cex:
4367 
      result.cex = cex
4368 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4369 
    result.write(oprot)
4370 
    oprot.writeMessageEnd()
4371 
    oprot.trans.flush()
4372 
 
4373 
  def process_isActive(self, seqid, iprot, oprot):
4374 
    args = isActive_args()
4375 
    args.read(iprot)
4376 
    iprot.readMessageEnd()
4377 
    result = isActive_result()
4378 
    try:
4379 
      result.success = self._handler.isActive(args.itemId)
4380 
    except CatalogServiceException, isex:
4381 
      result.isex = isex
4382 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4383 
    result.write(oprot)
4384 
    oprot.writeMessageEnd()
4385 
    oprot.trans.flush()
4386 
 
7438 amit.gupta 4387 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4388 
    args = getItemsStatus_args()
4389 
    args.read(iprot)
4390 
    iprot.readMessageEnd()
4391 
    result = getItemsStatus_result()
4392 
    try:
4393 
      result.success = self._handler.getItemsStatus(args.itemIds)
4394 
    except CatalogServiceException, isex:
4395 
      result.isex = isex
4396 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4397 
    result.write(oprot)
4398 
    oprot.writeMessageEnd()
4399 
    oprot.trans.flush()
4400 
 
5944 mandeep.dh 4401 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4402 
    args = getItemStatusDescription_args()
4403 
    args.read(iprot)
4404 
    iprot.readMessageEnd()
4405 
    result = getItemStatusDescription_result()
4406 
    try:
4407 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4408 
    except CatalogServiceException, isex:
4409 
      result.isex = isex
4410 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4411 
    result.write(oprot)
4412 
    oprot.writeMessageEnd()
4413 
    oprot.trans.flush()
4414 
 
4415 
  def process_startItemOn(self, seqid, iprot, oprot):
4416 
    args = startItemOn_args()
4417 
    args.read(iprot)
4418 
    iprot.readMessageEnd()
4419 
    result = startItemOn_result()
4420 
    try:
4421 
      self._handler.startItemOn(args.item_id, args.timestamp)
4422 
    except CatalogServiceException, cex:
4423 
      result.cex = cex
4424 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
4429 
  def process_retireItemOn(self, seqid, iprot, oprot):
4430 
    args = retireItemOn_args()
4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
4433 
    result = retireItemOn_result()
4434 
    try:
4435 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4436 
    except CatalogServiceException, cex:
4437 
      result.cex = cex
4438 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
4442 
 
4443 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4444 
    args = changeItemStatus_args()
4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
4447 
    result = changeItemStatus_result()
4448 
    try:
4449 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4450 
    except CatalogServiceException, cex:
4451 
      result.cex = cex
4452 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4453 
    result.write(oprot)
4454 
    oprot.writeMessageEnd()
4455 
    oprot.trans.flush()
4456 
 
4457 
  def process_getItem(self, seqid, iprot, oprot):
4458 
    args = getItem_args()
4459 
    args.read(iprot)
4460 
    iprot.readMessageEnd()
4461 
    result = getItem_result()
4462 
    try:
4463 
      result.success = self._handler.getItem(args.item_id)
4464 
    except CatalogServiceException, cex:
4465 
      result.cex = cex
4466 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4467 
    result.write(oprot)
4468 
    oprot.writeMessageEnd()
4469 
    oprot.trans.flush()
4470 
 
4471 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4472 
    args = getItemsByCatalogId_args()
4473 
    args.read(iprot)
4474 
    iprot.readMessageEnd()
4475 
    result = getItemsByCatalogId_result()
4476 
    try:
4477 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4478 
    except CatalogServiceException, cex:
4479 
      result.cex = cex
4480 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
4484 
 
4485 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4486 
    args = getValidItemsByCatalogId_args()
4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
4489 
    result = getValidItemsByCatalogId_result()
4490 
    try:
4491 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4492 
    except CatalogServiceException, cex:
4493 
      result.cex = cex
4494 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
4499 
  def process_getAllItems(self, seqid, iprot, oprot):
4500 
    args = getAllItems_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = getAllItems_result()
4504 
    try:
4505 
      result.success = self._handler.getAllItems(args.isActive)
4506 
    except CatalogServiceException, cex:
4507 
      result.cex = cex
4508 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4509 
    result.write(oprot)
4510 
    oprot.writeMessageEnd()
4511 
    oprot.trans.flush()
4512 
 
4513 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4514 
    args = getAllItemsByStatus_args()
4515 
    args.read(iprot)
4516 
    iprot.readMessageEnd()
4517 
    result = getAllItemsByStatus_result()
4518 
    try:
4519 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4520 
    except CatalogServiceException, cex:
4521 
      result.cex = cex
4522 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4523 
    result.write(oprot)
4524 
    oprot.writeMessageEnd()
4525 
    oprot.trans.flush()
4526 
 
4527 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4528 
    args = markItemAsContentComplete_args()
4529 
    args.read(iprot)
4530 
    iprot.readMessageEnd()
4531 
    result = markItemAsContentComplete_result()
4532 
    try:
4533 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4534 
    except CatalogServiceException, cex:
4535 
      result.cex = cex
4536 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4537 
    result.write(oprot)
4538 
    oprot.writeMessageEnd()
4539 
    oprot.trans.flush()
4540 
 
4541 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4542 
    args = getAllItemsInRange_args()
4543 
    args.read(iprot)
4544 
    iprot.readMessageEnd()
4545 
    result = getAllItemsInRange_result()
4546 
    try:
4547 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4548 
    except CatalogServiceException, cex:
4549 
      result.cex = cex
4550 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4551 
    result.write(oprot)
4552 
    oprot.writeMessageEnd()
4553 
    oprot.trans.flush()
4554 
 
4555 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4556 
    args = getAllItemsByStatusInRange_args()
4557 
    args.read(iprot)
4558 
    iprot.readMessageEnd()
4559 
    result = getAllItemsByStatusInRange_result()
4560 
    try:
4561 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4562 
    except CatalogServiceException, cex:
4563 
      result.cex = cex
4564 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4565 
    result.write(oprot)
4566 
    oprot.writeMessageEnd()
4567 
    oprot.trans.flush()
4568 
 
4569 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4570 
    args = getItemCountByStatus_args()
4571 
    args.read(iprot)
4572 
    iprot.readMessageEnd()
4573 
    result = getItemCountByStatus_result()
4574 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4575 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4576 
    result.write(oprot)
4577 
    oprot.writeMessageEnd()
4578 
    oprot.trans.flush()
4579 
 
4580 
  def process_getBestSellers(self, seqid, iprot, oprot):
4581 
    args = getBestSellers_args()
4582 
    args.read(iprot)
4583 
    iprot.readMessageEnd()
4584 
    result = getBestSellers_result()
4585 
    try:
4586 
      result.success = self._handler.getBestSellers()
4587 
    except CatalogServiceException, isex:
4588 
      result.isex = isex
4589 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4590 
    result.write(oprot)
4591 
    oprot.writeMessageEnd()
4592 
    oprot.trans.flush()
4593 
 
4594 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4595 
    args = getBestSellersCatalogIds_args()
4596 
    args.read(iprot)
4597 
    iprot.readMessageEnd()
4598 
    result = getBestSellersCatalogIds_result()
4599 
    try:
4600 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4601 
    except CatalogServiceException, cex:
4602 
      result.cex = cex
4603 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4604 
    result.write(oprot)
4605 
    oprot.writeMessageEnd()
4606 
    oprot.trans.flush()
4607 
 
4608 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4609 
    args = getBestSellersCount_args()
4610 
    args.read(iprot)
4611 
    iprot.readMessageEnd()
4612 
    result = getBestSellersCount_result()
4613 
    try:
4614 
      result.success = self._handler.getBestSellersCount()
4615 
    except CatalogServiceException, cex:
4616 
      result.cex = cex
4617 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
4622 
  def process_getBestDeals(self, seqid, iprot, oprot):
4623 
    args = getBestDeals_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = getBestDeals_result()
4627 
    try:
4628 
      result.success = self._handler.getBestDeals()
4629 
    except CatalogServiceException, isex:
4630 
      result.isex = isex
4631 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4632 
    result.write(oprot)
4633 
    oprot.writeMessageEnd()
4634 
    oprot.trans.flush()
4635 
 
4636 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4637 
    args = getBestDealsCatalogIds_args()
4638 
    args.read(iprot)
4639 
    iprot.readMessageEnd()
4640 
    result = getBestDealsCatalogIds_result()
4641 
    try:
4642 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4643 
    except CatalogServiceException, cex:
4644 
      result.cex = cex
4645 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4646 
    result.write(oprot)
4647 
    oprot.writeMessageEnd()
4648 
    oprot.trans.flush()
4649 
 
4650 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4651 
    args = getBestDealsCount_args()
4652 
    args.read(iprot)
4653 
    iprot.readMessageEnd()
4654 
    result = getBestDealsCount_result()
4655 
    try:
4656 
      result.success = self._handler.getBestDealsCount()
4657 
    except CatalogServiceException, cex:
4658 
      result.cex = cex
4659 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4660 
    result.write(oprot)
4661 
    oprot.writeMessageEnd()
4662 
    oprot.trans.flush()
4663 
 
4664 
  def process_getComingSoon(self, seqid, iprot, oprot):
4665 
    args = getComingSoon_args()
4666 
    args.read(iprot)
4667 
    iprot.readMessageEnd()
4668 
    result = getComingSoon_result()
4669 
    try:
4670 
      result.success = self._handler.getComingSoon()
4671 
    except CatalogServiceException, isex:
4672 
      result.isex = isex
4673 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4674 
    result.write(oprot)
4675 
    oprot.writeMessageEnd()
4676 
    oprot.trans.flush()
4677 
 
4678 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4679 
    args = getComingSoonCatalogIds_args()
4680 
    args.read(iprot)
4681 
    iprot.readMessageEnd()
4682 
    result = getComingSoonCatalogIds_result()
4683 
    try:
4684 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4685 
    except CatalogServiceException, cex:
4686 
      result.cex = cex
4687 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4688 
    result.write(oprot)
4689 
    oprot.writeMessageEnd()
4690 
    oprot.trans.flush()
4691 
 
4692 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4693 
    args = getComingSoonCount_args()
4694 
    args.read(iprot)
4695 
    iprot.readMessageEnd()
4696 
    result = getComingSoonCount_result()
4697 
    try:
4698 
      result.success = self._handler.getComingSoonCount()
4699 
    except CatalogServiceException, cex:
4700 
      result.cex = cex
4701 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4702 
    result.write(oprot)
4703 
    oprot.writeMessageEnd()
4704 
    oprot.trans.flush()
4705 
 
4706 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4707 
    args = getLatestArrivals_args()
4708 
    args.read(iprot)
4709 
    iprot.readMessageEnd()
4710 
    result = getLatestArrivals_result()
4711 
    try:
4712 
      result.success = self._handler.getLatestArrivals()
4713 
    except CatalogServiceException, isex:
4714 
      result.isex = isex
4715 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
4720 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4721 
    args = getLatestArrivalsCatalogIds_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getLatestArrivalsCatalogIds_result()
4725 
    try:
4726 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4727 
    except CatalogServiceException, cex:
4728 
      result.cex = cex
4729 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
4734 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4735 
    args = getLatestArrivalsCount_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = getLatestArrivalsCount_result()
4739 
    try:
4740 
      result.success = self._handler.getLatestArrivalsCount()
4741 
    except CatalogServiceException, cex:
4742 
      result.cex = cex
4743 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
4748 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4749 
    args = generateNewEntityID_args()
4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
4752 
    result = generateNewEntityID_result()
4753 
    result.success = self._handler.generateNewEntityID()
4754 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
4758 
 
4759 
  def process_addCategory(self, seqid, iprot, oprot):
4760 
    args = addCategory_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = addCategory_result()
4764 
    result.success = self._handler.addCategory(args.category)
4765 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4766 
    result.write(oprot)
4767 
    oprot.writeMessageEnd()
4768 
    oprot.trans.flush()
4769 
 
4770 
  def process_getCategory(self, seqid, iprot, oprot):
4771 
    args = getCategory_args()
4772 
    args.read(iprot)
4773 
    iprot.readMessageEnd()
4774 
    result = getCategory_result()
4775 
    result.success = self._handler.getCategory(args.id)
4776 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4777 
    result.write(oprot)
4778 
    oprot.writeMessageEnd()
4779 
    oprot.trans.flush()
4780 
 
4781 
  def process_getAllCategories(self, seqid, iprot, oprot):
4782 
    args = getAllCategories_args()
4783 
    args.read(iprot)
4784 
    iprot.readMessageEnd()
4785 
    result = getAllCategories_result()
4786 
    result.success = self._handler.getAllCategories()
4787 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4788 
    result.write(oprot)
4789 
    oprot.writeMessageEnd()
4790 
    oprot.trans.flush()
4791 
 
4792 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4793 
    args = getAllSimilarItems_args()
4794 
    args.read(iprot)
4795 
    iprot.readMessageEnd()
4796 
    result = getAllSimilarItems_result()
4797 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4798 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4799 
    result.write(oprot)
4800 
    oprot.writeMessageEnd()
4801 
    oprot.trans.flush()
4802 
 
4803 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4804 
    args = addSimilarItem_args()
4805 
    args.read(iprot)
4806 
    iprot.readMessageEnd()
4807 
    result = addSimilarItem_result()
4808 
    try:
4809 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4810 
    except CatalogServiceException, cex:
4811 
      result.cex = cex
4812 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4813 
    result.write(oprot)
4814 
    oprot.writeMessageEnd()
4815 
    oprot.trans.flush()
4816 
 
6512 kshitij.so 4817 
  def process_addTag(self, seqid, iprot, oprot):
4818 
    args = addTag_args()
4819 
    args.read(iprot)
4820 
    iprot.readMessageEnd()
4821 
    result = addTag_result()
4822 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4823 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4824 
    result.write(oprot)
4825 
    oprot.writeMessageEnd()
4826 
    oprot.trans.flush()
4827 
 
4828 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4829 
    args = deleteEntityTag_args()
4830 
    args.read(iprot)
4831 
    iprot.readMessageEnd()
4832 
    result = deleteEntityTag_result()
4833 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4834 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4835 
    result.write(oprot)
4836 
    oprot.writeMessageEnd()
4837 
    oprot.trans.flush()
4838 
 
4839 
  def process_deleteTag(self, seqid, iprot, oprot):
4840 
    args = deleteTag_args()
4841 
    args.read(iprot)
4842 
    iprot.readMessageEnd()
4843 
    result = deleteTag_result()
4844 
    result.success = self._handler.deleteTag(args.displayName)
4845 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4846 
    result.write(oprot)
4847 
    oprot.writeMessageEnd()
4848 
    oprot.trans.flush()
4849 
 
4850 
  def process_getAllTags(self, seqid, iprot, oprot):
4851 
    args = getAllTags_args()
4852 
    args.read(iprot)
4853 
    iprot.readMessageEnd()
4854 
    result = getAllTags_result()
4855 
    result.success = self._handler.getAllTags()
4856 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4857 
    result.write(oprot)
4858 
    oprot.writeMessageEnd()
4859 
    oprot.trans.flush()
4860 
 
4861 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4862 
    args = getAllEntitiesByTagName_args()
4863 
    args.read(iprot)
4864 
    iprot.readMessageEnd()
4865 
    result = getAllEntitiesByTagName_result()
4866 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4867 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4868 
    result.write(oprot)
4869 
    oprot.writeMessageEnd()
4870 
    oprot.trans.flush()
4871 
 
6845 amit.gupta 4872 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4873 
    args = getAllEntityTags_args()
4874 
    args.read(iprot)
4875 
    iprot.readMessageEnd()
4876 
    result = getAllEntityTags_result()
4877 
    result.success = self._handler.getAllEntityTags()
4878 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4879 
    result.write(oprot)
4880 
    oprot.writeMessageEnd()
4881 
    oprot.trans.flush()
4882 
 
6850 kshitij.so 4883 
  def process_addBanner(self, seqid, iprot, oprot):
4884 
    args = addBanner_args()
4885 
    args.read(iprot)
4886 
    iprot.readMessageEnd()
4887 
    result = addBanner_result()
4888 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4889 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4890 
    result.write(oprot)
4891 
    oprot.writeMessageEnd()
4892 
    oprot.trans.flush()
4893 
 
4894 
  def process_getAllBanners(self, seqid, iprot, oprot):
4895 
    args = getAllBanners_args()
4896 
    args.read(iprot)
4897 
    iprot.readMessageEnd()
4898 
    result = getAllBanners_result()
4899 
    result.success = self._handler.getAllBanners()
4900 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4901 
    result.write(oprot)
4902 
    oprot.writeMessageEnd()
4903 
    oprot.trans.flush()
4904 
 
4905 
  def process_deleteBanner(self, seqid, iprot, oprot):
4906 
    args = deleteBanner_args()
4907 
    args.read(iprot)
4908 
    iprot.readMessageEnd()
4909 
    result = deleteBanner_result()
4910 
    result.success = self._handler.deleteBanner(args.bannerName)
4911 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4912 
    result.write(oprot)
4913 
    oprot.writeMessageEnd()
4914 
    oprot.trans.flush()
4915 
 
4916 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4917 
    args = getBannerDetails_args()
4918 
    args.read(iprot)
4919 
    iprot.readMessageEnd()
4920 
    result = getBannerDetails_result()
4921 
    result.success = self._handler.getBannerDetails(args.bannerName)
4922 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4923 
    result.write(oprot)
4924 
    oprot.writeMessageEnd()
4925 
    oprot.trans.flush()
4926 
 
4927 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4928 
    args = getActiveBanners_args()
4929 
    args.read(iprot)
4930 
    iprot.readMessageEnd()
4931 
    result = getActiveBanners_result()
4932 
    result.success = self._handler.getActiveBanners()
4933 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4934 
    result.write(oprot)
4935 
    oprot.writeMessageEnd()
4936 
    oprot.trans.flush()
4937 
 
6849 kshitij.so 4938 
  def process_addBannerMap(self, seqid, iprot, oprot):
4939 
    args = addBannerMap_args()
4940 
    args.read(iprot)
4941 
    iprot.readMessageEnd()
4942 
    result = addBannerMap_result()
4943 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4944 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
4948 
 
4949 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4950 
    args = deleteBannerMap_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = deleteBannerMap_result()
4954 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4955 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4956 
    result.write(oprot)
4957 
    oprot.writeMessageEnd()
4958 
    oprot.trans.flush()
4959 
 
4960 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4961 
    args = getBannerMapDetails_args()
4962 
    args.read(iprot)
4963 
    iprot.readMessageEnd()
4964 
    result = getBannerMapDetails_result()
4965 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4966 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4967 
    result.write(oprot)
4968 
    oprot.writeMessageEnd()
4969 
    oprot.trans.flush()
4970 
 
5944 mandeep.dh 4971 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4972 
    args = deleteSimilarItem_args()
4973 
    args.read(iprot)
4974 
    iprot.readMessageEnd()
4975 
    result = deleteSimilarItem_result()
4976 
    try:
4977 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4978 
    except CatalogServiceException, cex:
4979 
      result.cex = cex
4980 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4981 
    result.write(oprot)
4982 
    oprot.writeMessageEnd()
4983 
    oprot.trans.flush()
4984 
 
4985 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4986 
    args = checkSimilarItem_args()
4987 
    args.read(iprot)
4988 
    iprot.readMessageEnd()
4989 
    result = checkSimilarItem_result()
4990 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4991 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4992 
    result.write(oprot)
4993 
    oprot.writeMessageEnd()
4994 
    oprot.trans.flush()
4995 
 
4996 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4997 
    args = validateRiskyStatus_args()
4998 
    args.read(iprot)
4999 
    iprot.readMessageEnd()
5000 
    result = validateRiskyStatus_result()
5001 
    self._handler.validateRiskyStatus(args.itemId)
5002 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
5007 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5008 
    args = changeItemRiskyFlag_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = changeItemRiskyFlag_result()
5012 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5013 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5014 
    result.write(oprot)
5015 
    oprot.writeMessageEnd()
5016 
    oprot.trans.flush()
5017 
 
5018 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5019 
    args = getItemsByRiskyFlag_args()
5020 
    args.read(iprot)
5021 
    iprot.readMessageEnd()
5022 
    result = getItemsByRiskyFlag_result()
5023 
    result.success = self._handler.getItemsByRiskyFlag()
5024 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5025 
    result.write(oprot)
5026 
    oprot.writeMessageEnd()
5027 
    oprot.trans.flush()
5028 
 
5029 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5030 
    args = getItemsForMasterSheet_args()
5031 
    args.read(iprot)
5032 
    iprot.readMessageEnd()
5033 
    result = getItemsForMasterSheet_result()
5034 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5035 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5036 
    result.write(oprot)
5037 
    oprot.writeMessageEnd()
5038 
    oprot.trans.flush()
5039 
 
5040 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5041 
    args = getSimilarItemsCatalogIds_args()
5042 
    args.read(iprot)
5043 
    iprot.readMessageEnd()
5044 
    result = getSimilarItemsCatalogIds_result()
5045 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5046 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5047 
    result.write(oprot)
5048 
    oprot.writeMessageEnd()
5049 
    oprot.trans.flush()
5050 
 
5051 
  def process_addProductNotification(self, seqid, iprot, oprot):
5052 
    args = addProductNotification_args()
5053 
    args.read(iprot)
5054 
    iprot.readMessageEnd()
5055 
    result = addProductNotification_result()
5056 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5057 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5058 
    result.write(oprot)
5059 
    oprot.writeMessageEnd()
5060 
    oprot.trans.flush()
5061 
 
5062 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5063 
    args = sendProductNotifications_args()
5064 
    args.read(iprot)
5065 
    iprot.readMessageEnd()
5066 
    result = sendProductNotifications_result()
5067 
    result.success = self._handler.sendProductNotifications()
5068 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5069 
    result.write(oprot)
5070 
    oprot.writeMessageEnd()
5071 
    oprot.trans.flush()
5072 
 
5073 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5074 
    args = getAllBrandsByCategory_args()
5075 
    args.read(iprot)
5076 
    iprot.readMessageEnd()
5077 
    result = getAllBrandsByCategory_result()
5078 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5079 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5080 
    result.write(oprot)
5081 
    oprot.writeMessageEnd()
5082 
    oprot.trans.flush()
5083 
 
5084 
  def process_getAllBrands(self, seqid, iprot, oprot):
5085 
    args = getAllBrands_args()
5086 
    args.read(iprot)
5087 
    iprot.readMessageEnd()
5088 
    result = getAllBrands_result()
5089 
    result.success = self._handler.getAllBrands()
5090 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5091 
    result.write(oprot)
5092 
    oprot.writeMessageEnd()
5093 
    oprot.trans.flush()
5094 
 
5095 
  def process_getAllSources(self, seqid, iprot, oprot):
5096 
    args = getAllSources_args()
5097 
    args.read(iprot)
5098 
    iprot.readMessageEnd()
5099 
    result = getAllSources_result()
5100 
    result.success = self._handler.getAllSources()
5101 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5102 
    result.write(oprot)
5103 
    oprot.writeMessageEnd()
5104 
    oprot.trans.flush()
5105 
 
5106 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5107 
    args = getItemPricingBySource_args()
5108 
    args.read(iprot)
5109 
    iprot.readMessageEnd()
5110 
    result = getItemPricingBySource_result()
5111 
    try:
5112 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5113 
    except CatalogServiceException, cex:
5114 
      result.cex = cex
5115 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5116 
    result.write(oprot)
5117 
    oprot.writeMessageEnd()
5118 
    oprot.trans.flush()
5119 
 
5120 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5121 
    args = addSourceItemPricing_args()
5122 
    args.read(iprot)
5123 
    iprot.readMessageEnd()
5124 
    result = addSourceItemPricing_result()
5125 
    try:
5126 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5127 
    except CatalogServiceException, cex:
5128 
      result.cex = cex
5129 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5130 
    result.write(oprot)
5131 
    oprot.writeMessageEnd()
5132 
    oprot.trans.flush()
5133 
 
5134 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5135 
    args = getAllSourcePricing_args()
5136 
    args.read(iprot)
5137 
    iprot.readMessageEnd()
5138 
    result = getAllSourcePricing_result()
5139 
    try:
5140 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5141 
    except CatalogServiceException, cex:
5142 
      result.cex = cex
5143 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5144 
    result.write(oprot)
5145 
    oprot.writeMessageEnd()
5146 
    oprot.trans.flush()
5147 
 
5148 
  def process_getItemForSource(self, seqid, iprot, oprot):
5149 
    args = getItemForSource_args()
5150 
    args.read(iprot)
5151 
    iprot.readMessageEnd()
5152 
    result = getItemForSource_result()
5153 
    try:
5154 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5155 
    except CatalogServiceException, cex:
5156 
      result.cex = cex
5157 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5158 
    result.write(oprot)
5159 
    oprot.writeMessageEnd()
5160 
    oprot.trans.flush()
5161 
 
5162 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5163 
    args = searchItemsInRange_args()
5164 
    args.read(iprot)
5165 
    iprot.readMessageEnd()
5166 
    result = searchItemsInRange_result()
5167 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5168 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5169 
    result.write(oprot)
5170 
    oprot.writeMessageEnd()
5171 
    oprot.trans.flush()
5172 
 
5173 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5174 
    args = getSearchResultCount_args()
5175 
    args.read(iprot)
5176 
    iprot.readMessageEnd()
5177 
    result = getSearchResultCount_result()
5178 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5179 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5180 
    result.write(oprot)
5181 
    oprot.writeMessageEnd()
5182 
    oprot.trans.flush()
5183 
 
5184 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5185 
    args = getProductNotifications_args()
5186 
    args.read(iprot)
5187 
    iprot.readMessageEnd()
5188 
    result = getProductNotifications_result()
5189 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5190 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5191 
    result.write(oprot)
5192 
    oprot.writeMessageEnd()
5193 
    oprot.trans.flush()
5194 
 
5195 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5196 
    args = getProductNotificationRequestCount_args()
5197 
    args.read(iprot)
5198 
    iprot.readMessageEnd()
5199 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5200 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5201 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5202 
    result.write(oprot)
5203 
    oprot.writeMessageEnd()
5204 
    oprot.trans.flush()
5205 
 
5206 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5207 
    args = addAuthorizationLog_args()
5208 
    args.read(iprot)
5209 
    iprot.readMessageEnd()
5210 
    result = addAuthorizationLog_result()
5211 
    try:
5212 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5213 
    except CatalogServiceException, cex:
5214 
      result.cex = cex
5215 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5216 
    result.write(oprot)
5217 
    oprot.writeMessageEnd()
5218 
    oprot.trans.flush()
5219 
 
5220 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5221 
    args = addupdateVoucherForItem_args()
5222 
    args.read(iprot)
5223 
    iprot.readMessageEnd()
5224 
    result = addupdateVoucherForItem_result()
5225 
    try:
5226 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5227 
    except CatalogServiceException, cex:
5228 
      result.cex = cex
5229 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5230 
    result.write(oprot)
5231 
    oprot.writeMessageEnd()
5232 
    oprot.trans.flush()
5233 
 
5234 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5235 
    args = deleteVoucherForItem_args()
5236 
    args.read(iprot)
5237 
    iprot.readMessageEnd()
5238 
    result = deleteVoucherForItem_result()
5239 
    try:
5240 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5241 
    except CatalogServiceException, cex:
5242 
      result.cex = cex
5243 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5244 
    result.write(oprot)
5245 
    oprot.writeMessageEnd()
5246 
    oprot.trans.flush()
5247 
 
5248 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5249 
    args = getVoucherAmount_args()
5250 
    args.read(iprot)
5251 
    iprot.readMessageEnd()
5252 
    result = getVoucherAmount_result()
5253 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5254 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5255 
    result.write(oprot)
5256 
    oprot.writeMessageEnd()
5257 
    oprot.trans.flush()
5258 
 
5259 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5260 
    args = getAllItemVouchers_args()
5261 
    args.read(iprot)
5262 
    iprot.readMessageEnd()
5263 
    result = getAllItemVouchers_result()
5264 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5265 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5266 
    result.write(oprot)
5267 
    oprot.writeMessageEnd()
5268 
    oprot.trans.flush()
5269 
 
5270 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5271 
    args = isValidCatalogItemId_args()
5272 
    args.read(iprot)
5273 
    iprot.readMessageEnd()
5274 
    result = isValidCatalogItemId_result()
5275 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5276 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5277 
    result.write(oprot)
5278 
    oprot.writeMessageEnd()
5279 
    oprot.trans.flush()
5280 
 
6039 amit.gupta 5281 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5282 
    args = getVatPercentageForItem_args()
5283 
    args.read(iprot)
5284 
    iprot.readMessageEnd()
5285 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5286 
    try:
5287 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5288 
    except CatalogServiceException, cex:
5289 
      result.cex = cex
6039 amit.gupta 5290 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5291 
    result.write(oprot)
5292 
    oprot.writeMessageEnd()
5293 
    oprot.trans.flush()
5944 mandeep.dh 5294 
 
6039 amit.gupta 5295 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5296 
    args = getVatAmountForItem_args()
5297 
    args.read(iprot)
5298 
    iprot.readMessageEnd()
5299 
    result = getVatAmountForItem_result()
5300 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5301 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5302 
    result.write(oprot)
5303 
    oprot.writeMessageEnd()
5304 
    oprot.trans.flush()
5305 
 
6531 vikram.rag 5306 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5307 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5308 
    args.read(iprot)
5309 
    iprot.readMessageEnd()
5310 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5311 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5312 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5313 
    result.write(oprot)
5314 
    oprot.writeMessageEnd()
5315 
    oprot.trans.flush()
6039 amit.gupta 5316 
 
6821 amar.kumar 5317 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5318 
    args = getAllAliveItems_args()
5319 
    args.read(iprot)
5320 
    iprot.readMessageEnd()
5321 
    result = getAllAliveItems_result()
5322 
    result.success = self._handler.getAllAliveItems()
5323 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5324 
    result.write(oprot)
5325 
    oprot.writeMessageEnd()
5326 
    oprot.trans.flush()
5327 
 
6805 anupam.sin 5328 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5329 
    args = getInsuranceAmount_args()
5330 
    args.read(iprot)
5331 
    iprot.readMessageEnd()
5332 
    result = getInsuranceAmount_result()
6921 anupam.sin 5333 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5334 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5335 
    result.write(oprot)
5336 
    oprot.writeMessageEnd()
5337 
    oprot.trans.flush()
6531 vikram.rag 5338 
 
6805 anupam.sin 5339 
  def process_getInsurer(self, seqid, iprot, oprot):
5340 
    args = getInsurer_args()
5341 
    args.read(iprot)
5342 
    iprot.readMessageEnd()
5343 
    result = getInsurer_result()
5344 
    result.success = self._handler.getInsurer(args.insurerId)
5345 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5346 
    result.write(oprot)
5347 
    oprot.writeMessageEnd()
5348 
    oprot.trans.flush()
5349 
 
6838 vikram.rag 5350 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5351 
    args = getAllInsurers_args()
5352 
    args.read(iprot)
5353 
    iprot.readMessageEnd()
5354 
    result = getAllInsurers_result()
5355 
    result.success = self._handler.getAllInsurers()
5356 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5357 
    result.write(oprot)
5358 
    oprot.writeMessageEnd()
5359 
    oprot.trans.flush()
6805 anupam.sin 5360 
 
6962 rajveer 5361 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5362 
    args = updateInsuranceDeclaredAmount_args()
5363 
    args.read(iprot)
5364 
    iprot.readMessageEnd()
5365 
    result = updateInsuranceDeclaredAmount_result()
5366 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5367 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5368 
    result.write(oprot)
5369 
    oprot.writeMessageEnd()
5370 
    oprot.trans.flush()
6838 vikram.rag 5371 
 
7190 amar.kumar 5372 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5373 
    args = getFreebieForItem_args()
5374 
    args.read(iprot)
5375 
    iprot.readMessageEnd()
5376 
    result = getFreebieForItem_result()
5377 
    result.success = self._handler.getFreebieForItem(args.itemId)
5378 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5379 
    result.write(oprot)
5380 
    oprot.writeMessageEnd()
5381 
    oprot.trans.flush()
6962 rajveer 5382 
 
7190 amar.kumar 5383 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5384 
    args = addOrUpdateFreebieForItem_args()
5385 
    args.read(iprot)
5386 
    iprot.readMessageEnd()
5387 
    result = addOrUpdateFreebieForItem_result()
5388 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5389 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5390 
    result.write(oprot)
5391 
    oprot.writeMessageEnd()
5392 
    oprot.trans.flush()
5393 
 
7272 amit.gupta 5394 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5395 
    args = addOrUpdateBrandInfo_args()
5396 
    args.read(iprot)
5397 
    iprot.readMessageEnd()
5398 
    result = addOrUpdateBrandInfo_result()
5399 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5400 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5401 
    result.write(oprot)
5402 
    oprot.writeMessageEnd()
5403 
    oprot.trans.flush()
5404 
 
5405 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5406 
    args = getBrandInfo_args()
5407 
    args.read(iprot)
5408 
    iprot.readMessageEnd()
5409 
    result = getBrandInfo_result()
5410 
    result.success = self._handler.getBrandInfo()
5411 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5412 
    result.write(oprot)
5413 
    oprot.writeMessageEnd()
5414 
    oprot.trans.flush()
5415 
 
7256 rajveer 5416 
  def process_getStorePricing(self, seqid, iprot, oprot):
5417 
    args = getStorePricing_args()
5418 
    args.read(iprot)
5419 
    iprot.readMessageEnd()
5420 
    result = getStorePricing_result()
5421 
    result.success = self._handler.getStorePricing(args.itemId)
5422 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5423 
    result.write(oprot)
5424 
    oprot.writeMessageEnd()
5425 
    oprot.trans.flush()
7190 amar.kumar 5426 
 
7306 rajveer 5427 
  def process_getStorePricings(self, seqid, iprot, oprot):
5428 
    args = getStorePricings_args()
5429 
    args.read(iprot)
5430 
    iprot.readMessageEnd()
5431 
    result = getStorePricings_result()
5432 
    result.success = self._handler.getStorePricings(args.itemIds)
5433 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5434 
    result.write(oprot)
5435 
    oprot.writeMessageEnd()
5436 
    oprot.trans.flush()
5437 
 
7265 rajveer 5438 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5439 
    args = updateStorePricing_args()
5440 
    args.read(iprot)
5441 
    iprot.readMessageEnd()
5442 
    result = updateStorePricing_result()
7382 rajveer 5443 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5444 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5445 
    result.write(oprot)
5446 
    oprot.writeMessageEnd()
5447 
    oprot.trans.flush()
7256 rajveer 5448 
 
7281 kshitij.so 5449 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5450 
    args = getAllAmazonListedItems_args()
5451 
    args.read(iprot)
5452 
    iprot.readMessageEnd()
5453 
    result = getAllAmazonListedItems_result()
5454 
    result.success = self._handler.getAllAmazonListedItems()
5455 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5456 
    result.write(oprot)
5457 
    oprot.writeMessageEnd()
5458 
    oprot.trans.flush()
7265 rajveer 5459 
 
7281 kshitij.so 5460 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5461 
    args = getAmazonItemDetails_args()
5462 
    args.read(iprot)
5463 
    iprot.readMessageEnd()
5464 
    result = getAmazonItemDetails_result()
5465 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5466 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5467 
    result.write(oprot)
5468 
    oprot.writeMessageEnd()
5469 
    oprot.trans.flush()
5470 
 
5471 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5472 
    args = updateAmazonItemDetails_args()
5473 
    args.read(iprot)
5474 
    iprot.readMessageEnd()
5475 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 5476 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 5477 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5478 
    result.write(oprot)
5479 
    oprot.writeMessageEnd()
5480 
    oprot.trans.flush()
5481 
 
5482 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5483 
    args = addAmazonItem_args()
5484 
    args.read(iprot)
5485 
    iprot.readMessageEnd()
5486 
    result = addAmazonItem_result()
5487 
    self._handler.addAmazonItem(args.amazonlisted)
5488 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5489 
    result.write(oprot)
5490 
    oprot.writeMessageEnd()
5491 
    oprot.trans.flush()
5492 
 
7291 vikram.rag 5493 
  def process_getAsinItems(self, seqid, iprot, oprot):
5494 
    args = getAsinItems_args()
5495 
    args.read(iprot)
5496 
    iprot.readMessageEnd()
5497 
    result = getAsinItems_result()
5498 
    result.success = self._handler.getAsinItems()
5499 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5500 
    result.write(oprot)
5501 
    oprot.writeMessageEnd()
5502 
    oprot.trans.flush()
7281 kshitij.so 5503 
 
7291 vikram.rag 5504 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5505 
    args = getAllFbaListedItems_args()
5506 
    args.read(iprot)
5507 
    iprot.readMessageEnd()
5508 
    result = getAllFbaListedItems_result()
5509 
    result.success = self._handler.getAllFbaListedItems()
5510 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5511 
    result.write(oprot)
5512 
    oprot.writeMessageEnd()
5513 
    oprot.trans.flush()
5514 
 
5515 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5516 
    args = getAllNonFbaListedItems_args()
5517 
    args.read(iprot)
5518 
    iprot.readMessageEnd()
5519 
    result = getAllNonFbaListedItems_result()
5520 
    result.success = self._handler.getAllNonFbaListedItems()
5521 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5522 
    result.write(oprot)
5523 
    oprot.writeMessageEnd()
5524 
    oprot.trans.flush()
5525 
 
7460 kshitij.so 5526 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5527 
    args = updateItemInventory_args()
5528 
    args.read(iprot)
5529 
    iprot.readMessageEnd()
5530 
    result = updateItemInventory_result()
5531 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5532 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5533 
    result.write(oprot)
5534 
    oprot.writeMessageEnd()
5535 
    oprot.trans.flush()
7291 vikram.rag 5536 
 
7770 kshitij.so 5537 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5538 
    args = updateTimestampForAmazonFeeds_args()
5539 
    args.read(iprot)
5540 
    iprot.readMessageEnd()
5541 
    result = updateTimestampForAmazonFeeds_result()
5542 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5543 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5544 
    result.write(oprot)
5545 
    oprot.writeMessageEnd()
5546 
    oprot.trans.flush()
7460 kshitij.so 5547 
 
7897 amar.kumar 5548 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5549 
    args = getAllParentCategories_args()
5550 
    args.read(iprot)
5551 
    iprot.readMessageEnd()
5552 
    result = getAllParentCategories_result()
5553 
    result.success = self._handler.getAllParentCategories()
5554 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5555 
    result.write(oprot)
5556 
    oprot.writeMessageEnd()
5557 
    oprot.trans.flush()
7770 kshitij.so 5558 
 
7977 kshitij.so 5559 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5560 
    args = addPageViewEvent_args()
5561 
    args.read(iprot)
5562 
    iprot.readMessageEnd()
5563 
    result = addPageViewEvent_result()
5564 
    self._handler.addPageViewEvent(args.pageViewEvents)
5565 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5566 
    result.write(oprot)
5567 
    oprot.writeMessageEnd()
5568 
    oprot.trans.flush()
7897 amar.kumar 5569 
 
7977 kshitij.so 5570 
  def process_addCartEvent(self, seqid, iprot, oprot):
5571 
    args = addCartEvent_args()
5572 
    args.read(iprot)
5573 
    iprot.readMessageEnd()
5574 
    result = addCartEvent_result()
5575 
    self._handler.addCartEvent(args.cartEvents)
5576 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5577 
    result.write(oprot)
5578 
    oprot.writeMessageEnd()
5579 
    oprot.trans.flush()
5580 
 
8182 amar.kumar 5581 
  def process_addEbayItem(self, seqid, iprot, oprot):
5582 
    args = addEbayItem_args()
5583 
    args.read(iprot)
5584 
    iprot.readMessageEnd()
5585 
    result = addEbayItem_result()
5586 
    self._handler.addEbayItem(args.ebayItem)
5587 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
5588 
    result.write(oprot)
5589 
    oprot.writeMessageEnd()
5590 
    oprot.trans.flush()
5591 
 
5592 
  def process_getEbayItem(self, seqid, iprot, oprot):
5593 
    args = getEbayItem_args()
5594 
    args.read(iprot)
5595 
    iprot.readMessageEnd()
5596 
    result = getEbayItem_result()
5597 
    result.success = self._handler.getEbayItem(args.listingId)
5598 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
5599 
    result.write(oprot)
5600 
    oprot.writeMessageEnd()
5601 
    oprot.trans.flush()
5602 
 
5603 
  def process_updateEbayItem(self, seqid, iprot, oprot):
5604 
    args = updateEbayItem_args()
5605 
    args.read(iprot)
5606 
    iprot.readMessageEnd()
5607 
    result = updateEbayItem_result()
5608 
    self._handler.updateEbayItem(args.ebayItem)
5609 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
5610 
    result.write(oprot)
5611 
    oprot.writeMessageEnd()
5612 
    oprot.trans.flush()
5613 
 
8139 kshitij.so 5614 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
5615 
    args = getAmazonListedItems_args()
5616 
    args.read(iprot)
5617 
    iprot.readMessageEnd()
5618 
    result = getAmazonListedItems_result()
5619 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
5620 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
5621 
    result.write(oprot)
5622 
    oprot.writeMessageEnd()
5623 
    oprot.trans.flush()
7977 kshitij.so 5624 
 
8168 kshitij.so 5625 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
5626 
    args = updateAmazonAttributesInBulk_args()
5627 
    args.read(iprot)
5628 
    iprot.readMessageEnd()
5629 
    result = updateAmazonAttributesInBulk_result()
5630 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
5631 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
5632 
    result.write(oprot)
5633 
    oprot.writeMessageEnd()
5634 
    oprot.trans.flush()
8139 kshitij.so 5635 
 
8379 vikram.rag 5636 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
5637 
    args = getAllItemstoListOnFba_args()
5638 
    args.read(iprot)
5639 
    iprot.readMessageEnd()
5640 
    result = getAllItemstoListOnFba_result()
5641 
    result.success = self._handler.getAllItemstoListOnFba()
5642 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
5643 
    result.write(oprot)
5644 
    oprot.writeMessageEnd()
5645 
    oprot.trans.flush()
8168 kshitij.so 5646 
 
8379 vikram.rag 5647 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
5648 
    args = getAllItemstoListOnNonFba_args()
5649 
    args.read(iprot)
5650 
    iprot.readMessageEnd()
5651 
    result = getAllItemstoListOnNonFba_result()
5652 
    result.success = self._handler.getAllItemstoListOnNonFba()
5653 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
5654 
    result.write(oprot)
5655 
    oprot.writeMessageEnd()
5656 
    oprot.trans.flush()
5657 
 
5658 
 
5944 mandeep.dh 5659 
# HELPER FUNCTIONS AND STRUCTURES
5660 
 
5661 
class addItem_args:
5662 
  """
5663 
  Attributes:
5664 
   - item
5665 
  """
5666 
 
5667 
  thrift_spec = (
5668 
    None, # 0
5669 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5670 
  )
5671 
 
5672 
  def __init__(self, item=None,):
5673 
    self.item = item
5674 
 
5675 
  def read(self, iprot):
5676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5678 
      return
5679 
    iprot.readStructBegin()
5680 
    while True:
5681 
      (fname, ftype, fid) = iprot.readFieldBegin()
5682 
      if ftype == TType.STOP:
5683 
        break
5684 
      if fid == 1:
5685 
        if ftype == TType.STRUCT:
5686 
          self.item = Item()
5687 
          self.item.read(iprot)
5688 
        else:
5689 
          iprot.skip(ftype)
5690 
      else:
5691 
        iprot.skip(ftype)
5692 
      iprot.readFieldEnd()
5693 
    iprot.readStructEnd()
5694 
 
5695 
  def write(self, oprot):
5696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5698 
      return
5699 
    oprot.writeStructBegin('addItem_args')
5700 
    if self.item is not None:
5701 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5702 
      self.item.write(oprot)
5703 
      oprot.writeFieldEnd()
5704 
    oprot.writeFieldStop()
5705 
    oprot.writeStructEnd()
5706 
 
5707 
  def validate(self):
5708 
    return
5709 
 
5710 
 
5711 
  def __repr__(self):
5712 
    L = ['%s=%r' % (key, value)
5713 
      for key, value in self.__dict__.iteritems()]
5714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5715 
 
5716 
  def __eq__(self, other):
5717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5718 
 
5719 
  def __ne__(self, other):
5720 
    return not (self == other)
5721 
 
5722 
class addItem_result:
5723 
  """
5724 
  Attributes:
5725 
   - success
5726 
   - cex
5727 
  """
5728 
 
5729 
  thrift_spec = (
5730 
    (0, TType.I64, 'success', None, None, ), # 0
5731 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5732 
  )
5733 
 
5734 
  def __init__(self, success=None, cex=None,):
5735 
    self.success = success
5736 
    self.cex = cex
5737 
 
5738 
  def read(self, iprot):
5739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5741 
      return
5742 
    iprot.readStructBegin()
5743 
    while True:
5744 
      (fname, ftype, fid) = iprot.readFieldBegin()
5745 
      if ftype == TType.STOP:
5746 
        break
5747 
      if fid == 0:
5748 
        if ftype == TType.I64:
5749 
          self.success = iprot.readI64();
5750 
        else:
5751 
          iprot.skip(ftype)
5752 
      elif fid == 1:
5753 
        if ftype == TType.STRUCT:
5754 
          self.cex = CatalogServiceException()
5755 
          self.cex.read(iprot)
5756 
        else:
5757 
          iprot.skip(ftype)
5758 
      else:
5759 
        iprot.skip(ftype)
5760 
      iprot.readFieldEnd()
5761 
    iprot.readStructEnd()
5762 
 
5763 
  def write(self, oprot):
5764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5766 
      return
5767 
    oprot.writeStructBegin('addItem_result')
5768 
    if self.success is not None:
5769 
      oprot.writeFieldBegin('success', TType.I64, 0)
5770 
      oprot.writeI64(self.success)
5771 
      oprot.writeFieldEnd()
5772 
    if self.cex is not None:
5773 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5774 
      self.cex.write(oprot)
5775 
      oprot.writeFieldEnd()
5776 
    oprot.writeFieldStop()
5777 
    oprot.writeStructEnd()
5778 
 
5779 
  def validate(self):
5780 
    return
5781 
 
5782 
 
5783 
  def __repr__(self):
5784 
    L = ['%s=%r' % (key, value)
5785 
      for key, value in self.__dict__.iteritems()]
5786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5787 
 
5788 
  def __eq__(self, other):
5789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5790 
 
5791 
  def __ne__(self, other):
5792 
    return not (self == other)
5793 
 
5794 
class updateItem_args:
5795 
  """
5796 
  Attributes:
5797 
   - item
5798 
  """
5799 
 
5800 
  thrift_spec = (
5801 
    None, # 0
5802 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5803 
  )
5804 
 
5805 
  def __init__(self, item=None,):
5806 
    self.item = item
5807 
 
5808 
  def read(self, iprot):
5809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5811 
      return
5812 
    iprot.readStructBegin()
5813 
    while True:
5814 
      (fname, ftype, fid) = iprot.readFieldBegin()
5815 
      if ftype == TType.STOP:
5816 
        break
5817 
      if fid == 1:
5818 
        if ftype == TType.STRUCT:
5819 
          self.item = Item()
5820 
          self.item.read(iprot)
5821 
        else:
5822 
          iprot.skip(ftype)
5823 
      else:
5824 
        iprot.skip(ftype)
5825 
      iprot.readFieldEnd()
5826 
    iprot.readStructEnd()
5827 
 
5828 
  def write(self, oprot):
5829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5831 
      return
5832 
    oprot.writeStructBegin('updateItem_args')
5833 
    if self.item is not None:
5834 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5835 
      self.item.write(oprot)
5836 
      oprot.writeFieldEnd()
5837 
    oprot.writeFieldStop()
5838 
    oprot.writeStructEnd()
5839 
 
5840 
  def validate(self):
5841 
    return
5842 
 
5843 
 
5844 
  def __repr__(self):
5845 
    L = ['%s=%r' % (key, value)
5846 
      for key, value in self.__dict__.iteritems()]
5847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5848 
 
5849 
  def __eq__(self, other):
5850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5851 
 
5852 
  def __ne__(self, other):
5853 
    return not (self == other)
5854 
 
5855 
class updateItem_result:
5856 
  """
5857 
  Attributes:
5858 
   - success
5859 
   - cex
5860 
  """
5861 
 
5862 
  thrift_spec = (
5863 
    (0, TType.I64, 'success', None, None, ), # 0
5864 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5865 
  )
5866 
 
5867 
  def __init__(self, success=None, cex=None,):
5868 
    self.success = success
5869 
    self.cex = cex
5870 
 
5871 
  def read(self, iprot):
5872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5874 
      return
5875 
    iprot.readStructBegin()
5876 
    while True:
5877 
      (fname, ftype, fid) = iprot.readFieldBegin()
5878 
      if ftype == TType.STOP:
5879 
        break
5880 
      if fid == 0:
5881 
        if ftype == TType.I64:
5882 
          self.success = iprot.readI64();
5883 
        else:
5884 
          iprot.skip(ftype)
5885 
      elif fid == 1:
5886 
        if ftype == TType.STRUCT:
5887 
          self.cex = CatalogServiceException()
5888 
          self.cex.read(iprot)
5889 
        else:
5890 
          iprot.skip(ftype)
5891 
      else:
5892 
        iprot.skip(ftype)
5893 
      iprot.readFieldEnd()
5894 
    iprot.readStructEnd()
5895 
 
5896 
  def write(self, oprot):
5897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5899 
      return
5900 
    oprot.writeStructBegin('updateItem_result')
5901 
    if self.success is not None:
5902 
      oprot.writeFieldBegin('success', TType.I64, 0)
5903 
      oprot.writeI64(self.success)
5904 
      oprot.writeFieldEnd()
5905 
    if self.cex is not None:
5906 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5907 
      self.cex.write(oprot)
5908 
      oprot.writeFieldEnd()
5909 
    oprot.writeFieldStop()
5910 
    oprot.writeStructEnd()
5911 
 
5912 
  def validate(self):
5913 
    return
5914 
 
5915 
 
5916 
  def __repr__(self):
5917 
    L = ['%s=%r' % (key, value)
5918 
      for key, value in self.__dict__.iteritems()]
5919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5920 
 
5921 
  def __eq__(self, other):
5922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5923 
 
5924 
  def __ne__(self, other):
5925 
    return not (self == other)
5926 
 
5927 
class isActive_args:
5928 
  """
5929 
  Attributes:
5930 
   - itemId
5931 
  """
5932 
 
5933 
  thrift_spec = (
5934 
    None, # 0
5935 
    (1, TType.I64, 'itemId', None, None, ), # 1
5936 
  )
5937 
 
5938 
  def __init__(self, itemId=None,):
5939 
    self.itemId = itemId
5940 
 
5941 
  def read(self, iprot):
5942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5944 
      return
5945 
    iprot.readStructBegin()
5946 
    while True:
5947 
      (fname, ftype, fid) = iprot.readFieldBegin()
5948 
      if ftype == TType.STOP:
5949 
        break
5950 
      if fid == 1:
5951 
        if ftype == TType.I64:
5952 
          self.itemId = iprot.readI64();
5953 
        else:
5954 
          iprot.skip(ftype)
5955 
      else:
5956 
        iprot.skip(ftype)
5957 
      iprot.readFieldEnd()
5958 
    iprot.readStructEnd()
5959 
 
5960 
  def write(self, oprot):
5961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5963 
      return
5964 
    oprot.writeStructBegin('isActive_args')
5965 
    if self.itemId is not None:
5966 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5967 
      oprot.writeI64(self.itemId)
5968 
      oprot.writeFieldEnd()
5969 
    oprot.writeFieldStop()
5970 
    oprot.writeStructEnd()
5971 
 
5972 
  def validate(self):
5973 
    return
5974 
 
5975 
 
5976 
  def __repr__(self):
5977 
    L = ['%s=%r' % (key, value)
5978 
      for key, value in self.__dict__.iteritems()]
5979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5980 
 
5981 
  def __eq__(self, other):
5982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5983 
 
5984 
  def __ne__(self, other):
5985 
    return not (self == other)
5986 
 
5987 
class isActive_result:
5988 
  """
5989 
  Attributes:
5990 
   - success
5991 
   - isex
5992 
  """
5993 
 
5994 
  thrift_spec = (
5995 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5996 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5997 
  )
5998 
 
5999 
  def __init__(self, success=None, isex=None,):
6000 
    self.success = success
6001 
    self.isex = isex
6002 
 
6003 
  def read(self, iprot):
6004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6006 
      return
6007 
    iprot.readStructBegin()
6008 
    while True:
6009 
      (fname, ftype, fid) = iprot.readFieldBegin()
6010 
      if ftype == TType.STOP:
6011 
        break
6012 
      if fid == 0:
6013 
        if ftype == TType.STRUCT:
6014 
          self.success = ItemShippingInfo()
6015 
          self.success.read(iprot)
6016 
        else:
6017 
          iprot.skip(ftype)
6018 
      elif fid == 1:
6019 
        if ftype == TType.STRUCT:
6020 
          self.isex = CatalogServiceException()
6021 
          self.isex.read(iprot)
6022 
        else:
6023 
          iprot.skip(ftype)
6024 
      else:
6025 
        iprot.skip(ftype)
6026 
      iprot.readFieldEnd()
6027 
    iprot.readStructEnd()
6028 
 
6029 
  def write(self, oprot):
6030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6032 
      return
6033 
    oprot.writeStructBegin('isActive_result')
6034 
    if self.success is not None:
6035 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6036 
      self.success.write(oprot)
6037 
      oprot.writeFieldEnd()
6038 
    if self.isex is not None:
6039 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6040 
      self.isex.write(oprot)
6041 
      oprot.writeFieldEnd()
6042 
    oprot.writeFieldStop()
6043 
    oprot.writeStructEnd()
6044 
 
6045 
  def validate(self):
6046 
    return
6047 
 
6048 
 
6049 
  def __repr__(self):
6050 
    L = ['%s=%r' % (key, value)
6051 
      for key, value in self.__dict__.iteritems()]
6052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6053 
 
6054 
  def __eq__(self, other):
6055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6056 
 
6057 
  def __ne__(self, other):
6058 
    return not (self == other)
6059 
 
7438 amit.gupta 6060 
class getItemsStatus_args:
6061 
  """
6062 
  Attributes:
6063 
   - itemIds
6064 
  """
6065 
 
6066 
  thrift_spec = (
6067 
    None, # 0
6068 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
6069 
  )
6070 
 
6071 
  def __init__(self, itemIds=None,):
6072 
    self.itemIds = itemIds
6073 
 
6074 
  def read(self, iprot):
6075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6077 
      return
6078 
    iprot.readStructBegin()
6079 
    while True:
6080 
      (fname, ftype, fid) = iprot.readFieldBegin()
6081 
      if ftype == TType.STOP:
6082 
        break
6083 
      if fid == 1:
6084 
        if ftype == TType.LIST:
6085 
          self.itemIds = []
6086 
          (_etype19, _size16) = iprot.readListBegin()
6087 
          for _i20 in xrange(_size16):
6088 
            _elem21 = iprot.readI64();
6089 
            self.itemIds.append(_elem21)
6090 
          iprot.readListEnd()
6091 
        else:
6092 
          iprot.skip(ftype)
6093 
      else:
6094 
        iprot.skip(ftype)
6095 
      iprot.readFieldEnd()
6096 
    iprot.readStructEnd()
6097 
 
6098 
  def write(self, oprot):
6099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6101 
      return
6102 
    oprot.writeStructBegin('getItemsStatus_args')
6103 
    if self.itemIds is not None:
6104 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6105 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6106 
      for iter22 in self.itemIds:
6107 
        oprot.writeI64(iter22)
6108 
      oprot.writeListEnd()
6109 
      oprot.writeFieldEnd()
6110 
    oprot.writeFieldStop()
6111 
    oprot.writeStructEnd()
6112 
 
6113 
  def validate(self):
6114 
    return
6115 
 
6116 
 
6117 
  def __repr__(self):
6118 
    L = ['%s=%r' % (key, value)
6119 
      for key, value in self.__dict__.iteritems()]
6120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6121 
 
6122 
  def __eq__(self, other):
6123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6124 
 
6125 
  def __ne__(self, other):
6126 
    return not (self == other)
6127 
 
6128 
class getItemsStatus_result:
6129 
  """
6130 
  Attributes:
6131 
   - success
6132 
   - isex
6133 
  """
6134 
 
6135 
  thrift_spec = (
6136 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6137 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6138 
  )
6139 
 
6140 
  def __init__(self, success=None, isex=None,):
6141 
    self.success = success
6142 
    self.isex = isex
6143 
 
6144 
  def read(self, iprot):
6145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6147 
      return
6148 
    iprot.readStructBegin()
6149 
    while True:
6150 
      (fname, ftype, fid) = iprot.readFieldBegin()
6151 
      if ftype == TType.STOP:
6152 
        break
6153 
      if fid == 0:
6154 
        if ftype == TType.MAP:
6155 
          self.success = {}
6156 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
6157 
          for _i27 in xrange(_size23):
6158 
            _key28 = iprot.readI64();
6159 
            _val29 = iprot.readBool();
6160 
            self.success[_key28] = _val29
6161 
          iprot.readMapEnd()
6162 
        else:
6163 
          iprot.skip(ftype)
6164 
      elif fid == 1:
6165 
        if ftype == TType.STRUCT:
6166 
          self.isex = CatalogServiceException()
6167 
          self.isex.read(iprot)
6168 
        else:
6169 
          iprot.skip(ftype)
6170 
      else:
6171 
        iprot.skip(ftype)
6172 
      iprot.readFieldEnd()
6173 
    iprot.readStructEnd()
6174 
 
6175 
  def write(self, oprot):
6176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6178 
      return
6179 
    oprot.writeStructBegin('getItemsStatus_result')
6180 
    if self.success is not None:
6181 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6182 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
6183 
      for kiter30,viter31 in self.success.items():
6184 
        oprot.writeI64(kiter30)
6185 
        oprot.writeBool(viter31)
6186 
      oprot.writeMapEnd()
6187 
      oprot.writeFieldEnd()
6188 
    if self.isex is not None:
6189 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6190 
      self.isex.write(oprot)
6191 
      oprot.writeFieldEnd()
6192 
    oprot.writeFieldStop()
6193 
    oprot.writeStructEnd()
6194 
 
6195 
  def validate(self):
6196 
    return
6197 
 
6198 
 
6199 
  def __repr__(self):
6200 
    L = ['%s=%r' % (key, value)
6201 
      for key, value in self.__dict__.iteritems()]
6202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6203 
 
6204 
  def __eq__(self, other):
6205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6206 
 
6207 
  def __ne__(self, other):
6208 
    return not (self == other)
6209 
 
5944 mandeep.dh 6210 
class getItemStatusDescription_args:
6211 
  """
6212 
  Attributes:
6213 
   - itemId
6214 
  """
6215 
 
6216 
  thrift_spec = (
6217 
    None, # 0
6218 
    (1, TType.I64, 'itemId', None, None, ), # 1
6219 
  )
6220 
 
6221 
  def __init__(self, itemId=None,):
6222 
    self.itemId = itemId
6223 
 
6224 
  def read(self, iprot):
6225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6227 
      return
6228 
    iprot.readStructBegin()
6229 
    while True:
6230 
      (fname, ftype, fid) = iprot.readFieldBegin()
6231 
      if ftype == TType.STOP:
6232 
        break
6233 
      if fid == 1:
6234 
        if ftype == TType.I64:
6235 
          self.itemId = iprot.readI64();
6236 
        else:
6237 
          iprot.skip(ftype)
6238 
      else:
6239 
        iprot.skip(ftype)
6240 
      iprot.readFieldEnd()
6241 
    iprot.readStructEnd()
6242 
 
6243 
  def write(self, oprot):
6244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6246 
      return
6247 
    oprot.writeStructBegin('getItemStatusDescription_args')
6248 
    if self.itemId is not None:
6249 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6250 
      oprot.writeI64(self.itemId)
6251 
      oprot.writeFieldEnd()
6252 
    oprot.writeFieldStop()
6253 
    oprot.writeStructEnd()
6254 
 
6255 
  def validate(self):
6256 
    return
6257 
 
6258 
 
6259 
  def __repr__(self):
6260 
    L = ['%s=%r' % (key, value)
6261 
      for key, value in self.__dict__.iteritems()]
6262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6263 
 
6264 
  def __eq__(self, other):
6265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6266 
 
6267 
  def __ne__(self, other):
6268 
    return not (self == other)
6269 
 
6270 
class getItemStatusDescription_result:
6271 
  """
6272 
  Attributes:
6273 
   - success
6274 
   - isex
6275 
  """
6276 
 
6277 
  thrift_spec = (
6278 
    (0, TType.STRING, 'success', None, None, ), # 0
6279 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6280 
  )
6281 
 
6282 
  def __init__(self, success=None, isex=None,):
6283 
    self.success = success
6284 
    self.isex = isex
6285 
 
6286 
  def read(self, iprot):
6287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6289 
      return
6290 
    iprot.readStructBegin()
6291 
    while True:
6292 
      (fname, ftype, fid) = iprot.readFieldBegin()
6293 
      if ftype == TType.STOP:
6294 
        break
6295 
      if fid == 0:
6296 
        if ftype == TType.STRING:
6297 
          self.success = iprot.readString();
6298 
        else:
6299 
          iprot.skip(ftype)
6300 
      elif fid == 1:
6301 
        if ftype == TType.STRUCT:
6302 
          self.isex = CatalogServiceException()
6303 
          self.isex.read(iprot)
6304 
        else:
6305 
          iprot.skip(ftype)
6306 
      else:
6307 
        iprot.skip(ftype)
6308 
      iprot.readFieldEnd()
6309 
    iprot.readStructEnd()
6310 
 
6311 
  def write(self, oprot):
6312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6314 
      return
6315 
    oprot.writeStructBegin('getItemStatusDescription_result')
6316 
    if self.success is not None:
6317 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6318 
      oprot.writeString(self.success)
6319 
      oprot.writeFieldEnd()
6320 
    if self.isex is not None:
6321 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6322 
      self.isex.write(oprot)
6323 
      oprot.writeFieldEnd()
6324 
    oprot.writeFieldStop()
6325 
    oprot.writeStructEnd()
6326 
 
6327 
  def validate(self):
6328 
    return
6329 
 
6330 
 
6331 
  def __repr__(self):
6332 
    L = ['%s=%r' % (key, value)
6333 
      for key, value in self.__dict__.iteritems()]
6334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6335 
 
6336 
  def __eq__(self, other):
6337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6338 
 
6339 
  def __ne__(self, other):
6340 
    return not (self == other)
6341 
 
6342 
class startItemOn_args:
6343 
  """
6344 
  Attributes:
6345 
   - item_id
6346 
   - timestamp
6347 
  """
6348 
 
6349 
  thrift_spec = (
6350 
    None, # 0
6351 
    (1, TType.I64, 'item_id', None, None, ), # 1
6352 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6353 
  )
6354 
 
6355 
  def __init__(self, item_id=None, timestamp=None,):
6356 
    self.item_id = item_id
6357 
    self.timestamp = timestamp
6358 
 
6359 
  def read(self, iprot):
6360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6362 
      return
6363 
    iprot.readStructBegin()
6364 
    while True:
6365 
      (fname, ftype, fid) = iprot.readFieldBegin()
6366 
      if ftype == TType.STOP:
6367 
        break
6368 
      if fid == 1:
6369 
        if ftype == TType.I64:
6370 
          self.item_id = iprot.readI64();
6371 
        else:
6372 
          iprot.skip(ftype)
6373 
      elif fid == 2:
6374 
        if ftype == TType.I64:
6375 
          self.timestamp = iprot.readI64();
6376 
        else:
6377 
          iprot.skip(ftype)
6378 
      else:
6379 
        iprot.skip(ftype)
6380 
      iprot.readFieldEnd()
6381 
    iprot.readStructEnd()
6382 
 
6383 
  def write(self, oprot):
6384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6386 
      return
6387 
    oprot.writeStructBegin('startItemOn_args')
6388 
    if self.item_id is not None:
6389 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6390 
      oprot.writeI64(self.item_id)
6391 
      oprot.writeFieldEnd()
6392 
    if self.timestamp is not None:
6393 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6394 
      oprot.writeI64(self.timestamp)
6395 
      oprot.writeFieldEnd()
6396 
    oprot.writeFieldStop()
6397 
    oprot.writeStructEnd()
6398 
 
6399 
  def validate(self):
6400 
    return
6401 
 
6402 
 
6403 
  def __repr__(self):
6404 
    L = ['%s=%r' % (key, value)
6405 
      for key, value in self.__dict__.iteritems()]
6406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6407 
 
6408 
  def __eq__(self, other):
6409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6410 
 
6411 
  def __ne__(self, other):
6412 
    return not (self == other)
6413 
 
6414 
class startItemOn_result:
6415 
  """
6416 
  Attributes:
6417 
   - cex
6418 
  """
6419 
 
6420 
  thrift_spec = (
6421 
    None, # 0
6422 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6423 
  )
6424 
 
6425 
  def __init__(self, cex=None,):
6426 
    self.cex = cex
6427 
 
6428 
  def read(self, iprot):
6429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6431 
      return
6432 
    iprot.readStructBegin()
6433 
    while True:
6434 
      (fname, ftype, fid) = iprot.readFieldBegin()
6435 
      if ftype == TType.STOP:
6436 
        break
6437 
      if fid == 1:
6438 
        if ftype == TType.STRUCT:
6439 
          self.cex = CatalogServiceException()
6440 
          self.cex.read(iprot)
6441 
        else:
6442 
          iprot.skip(ftype)
6443 
      else:
6444 
        iprot.skip(ftype)
6445 
      iprot.readFieldEnd()
6446 
    iprot.readStructEnd()
6447 
 
6448 
  def write(self, oprot):
6449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6451 
      return
6452 
    oprot.writeStructBegin('startItemOn_result')
6453 
    if self.cex is not None:
6454 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6455 
      self.cex.write(oprot)
6456 
      oprot.writeFieldEnd()
6457 
    oprot.writeFieldStop()
6458 
    oprot.writeStructEnd()
6459 
 
6460 
  def validate(self):
6461 
    return
6462 
 
6463 
 
6464 
  def __repr__(self):
6465 
    L = ['%s=%r' % (key, value)
6466 
      for key, value in self.__dict__.iteritems()]
6467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6468 
 
6469 
  def __eq__(self, other):
6470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6471 
 
6472 
  def __ne__(self, other):
6473 
    return not (self == other)
6474 
 
6475 
class retireItemOn_args:
6476 
  """
6477 
  Attributes:
6478 
   - item_id
6479 
   - timestamp
6480 
  """
6481 
 
6482 
  thrift_spec = (
6483 
    None, # 0
6484 
    (1, TType.I64, 'item_id', None, None, ), # 1
6485 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6486 
  )
6487 
 
6488 
  def __init__(self, item_id=None, timestamp=None,):
6489 
    self.item_id = item_id
6490 
    self.timestamp = timestamp
6491 
 
6492 
  def read(self, iprot):
6493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6495 
      return
6496 
    iprot.readStructBegin()
6497 
    while True:
6498 
      (fname, ftype, fid) = iprot.readFieldBegin()
6499 
      if ftype == TType.STOP:
6500 
        break
6501 
      if fid == 1:
6502 
        if ftype == TType.I64:
6503 
          self.item_id = iprot.readI64();
6504 
        else:
6505 
          iprot.skip(ftype)
6506 
      elif fid == 2:
6507 
        if ftype == TType.I64:
6508 
          self.timestamp = iprot.readI64();
6509 
        else:
6510 
          iprot.skip(ftype)
6511 
      else:
6512 
        iprot.skip(ftype)
6513 
      iprot.readFieldEnd()
6514 
    iprot.readStructEnd()
6515 
 
6516 
  def write(self, oprot):
6517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6519 
      return
6520 
    oprot.writeStructBegin('retireItemOn_args')
6521 
    if self.item_id is not None:
6522 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6523 
      oprot.writeI64(self.item_id)
6524 
      oprot.writeFieldEnd()
6525 
    if self.timestamp is not None:
6526 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6527 
      oprot.writeI64(self.timestamp)
6528 
      oprot.writeFieldEnd()
6529 
    oprot.writeFieldStop()
6530 
    oprot.writeStructEnd()
6531 
 
6532 
  def validate(self):
6533 
    return
6534 
 
6535 
 
6536 
  def __repr__(self):
6537 
    L = ['%s=%r' % (key, value)
6538 
      for key, value in self.__dict__.iteritems()]
6539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6540 
 
6541 
  def __eq__(self, other):
6542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6543 
 
6544 
  def __ne__(self, other):
6545 
    return not (self == other)
6546 
 
6547 
class retireItemOn_result:
6548 
  """
6549 
  Attributes:
6550 
   - cex
6551 
  """
6552 
 
6553 
  thrift_spec = (
6554 
    None, # 0
6555 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6556 
  )
6557 
 
6558 
  def __init__(self, cex=None,):
6559 
    self.cex = cex
6560 
 
6561 
  def read(self, iprot):
6562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6564 
      return
6565 
    iprot.readStructBegin()
6566 
    while True:
6567 
      (fname, ftype, fid) = iprot.readFieldBegin()
6568 
      if ftype == TType.STOP:
6569 
        break
6570 
      if fid == 1:
6571 
        if ftype == TType.STRUCT:
6572 
          self.cex = CatalogServiceException()
6573 
          self.cex.read(iprot)
6574 
        else:
6575 
          iprot.skip(ftype)
6576 
      else:
6577 
        iprot.skip(ftype)
6578 
      iprot.readFieldEnd()
6579 
    iprot.readStructEnd()
6580 
 
6581 
  def write(self, oprot):
6582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6584 
      return
6585 
    oprot.writeStructBegin('retireItemOn_result')
6586 
    if self.cex is not None:
6587 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6588 
      self.cex.write(oprot)
6589 
      oprot.writeFieldEnd()
6590 
    oprot.writeFieldStop()
6591 
    oprot.writeStructEnd()
6592 
 
6593 
  def validate(self):
6594 
    return
6595 
 
6596 
 
6597 
  def __repr__(self):
6598 
    L = ['%s=%r' % (key, value)
6599 
      for key, value in self.__dict__.iteritems()]
6600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6601 
 
6602 
  def __eq__(self, other):
6603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6604 
 
6605 
  def __ne__(self, other):
6606 
    return not (self == other)
6607 
 
6608 
class changeItemStatus_args:
6609 
  """
6610 
  Attributes:
6611 
   - item_id
6612 
   - timestamp
6613 
   - newstatus
6614 
  """
6615 
 
6616 
  thrift_spec = (
6617 
    None, # 0
6618 
    (1, TType.I64, 'item_id', None, None, ), # 1
6619 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6620 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6621 
  )
6622 
 
6623 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6624 
    self.item_id = item_id
6625 
    self.timestamp = timestamp
6626 
    self.newstatus = newstatus
6627 
 
6628 
  def read(self, iprot):
6629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6631 
      return
6632 
    iprot.readStructBegin()
6633 
    while True:
6634 
      (fname, ftype, fid) = iprot.readFieldBegin()
6635 
      if ftype == TType.STOP:
6636 
        break
6637 
      if fid == 1:
6638 
        if ftype == TType.I64:
6639 
          self.item_id = iprot.readI64();
6640 
        else:
6641 
          iprot.skip(ftype)
6642 
      elif fid == 2:
6643 
        if ftype == TType.I64:
6644 
          self.timestamp = iprot.readI64();
6645 
        else:
6646 
          iprot.skip(ftype)
6647 
      elif fid == 3:
6648 
        if ftype == TType.I32:
6649 
          self.newstatus = iprot.readI32();
6650 
        else:
6651 
          iprot.skip(ftype)
6652 
      else:
6653 
        iprot.skip(ftype)
6654 
      iprot.readFieldEnd()
6655 
    iprot.readStructEnd()
6656 
 
6657 
  def write(self, oprot):
6658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6660 
      return
6661 
    oprot.writeStructBegin('changeItemStatus_args')
6662 
    if self.item_id is not None:
6663 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6664 
      oprot.writeI64(self.item_id)
6665 
      oprot.writeFieldEnd()
6666 
    if self.timestamp is not None:
6667 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6668 
      oprot.writeI64(self.timestamp)
6669 
      oprot.writeFieldEnd()
6670 
    if self.newstatus is not None:
6671 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6672 
      oprot.writeI32(self.newstatus)
6673 
      oprot.writeFieldEnd()
6674 
    oprot.writeFieldStop()
6675 
    oprot.writeStructEnd()
6676 
 
6677 
  def validate(self):
6678 
    return
6679 
 
6680 
 
6681 
  def __repr__(self):
6682 
    L = ['%s=%r' % (key, value)
6683 
      for key, value in self.__dict__.iteritems()]
6684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6685 
 
6686 
  def __eq__(self, other):
6687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6688 
 
6689 
  def __ne__(self, other):
6690 
    return not (self == other)
6691 
 
6692 
class changeItemStatus_result:
6693 
  """
6694 
  Attributes:
6695 
   - cex
6696 
  """
6697 
 
6698 
  thrift_spec = (
6699 
    None, # 0
6700 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6701 
  )
6702 
 
6703 
  def __init__(self, cex=None,):
6704 
    self.cex = cex
6705 
 
6706 
  def read(self, iprot):
6707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6709 
      return
6710 
    iprot.readStructBegin()
6711 
    while True:
6712 
      (fname, ftype, fid) = iprot.readFieldBegin()
6713 
      if ftype == TType.STOP:
6714 
        break
6715 
      if fid == 1:
6716 
        if ftype == TType.STRUCT:
6717 
          self.cex = CatalogServiceException()
6718 
          self.cex.read(iprot)
6719 
        else:
6720 
          iprot.skip(ftype)
6721 
      else:
6722 
        iprot.skip(ftype)
6723 
      iprot.readFieldEnd()
6724 
    iprot.readStructEnd()
6725 
 
6726 
  def write(self, oprot):
6727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6729 
      return
6730 
    oprot.writeStructBegin('changeItemStatus_result')
6731 
    if self.cex is not None:
6732 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6733 
      self.cex.write(oprot)
6734 
      oprot.writeFieldEnd()
6735 
    oprot.writeFieldStop()
6736 
    oprot.writeStructEnd()
6737 
 
6738 
  def validate(self):
6739 
    return
6740 
 
6741 
 
6742 
  def __repr__(self):
6743 
    L = ['%s=%r' % (key, value)
6744 
      for key, value in self.__dict__.iteritems()]
6745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6746 
 
6747 
  def __eq__(self, other):
6748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6749 
 
6750 
  def __ne__(self, other):
6751 
    return not (self == other)
6752 
 
6753 
class getItem_args:
6754 
  """
6755 
  Attributes:
6756 
   - item_id
6757 
  """
6758 
 
6759 
  thrift_spec = (
6760 
    None, # 0
6761 
    (1, TType.I64, 'item_id', None, None, ), # 1
6762 
  )
6763 
 
6764 
  def __init__(self, item_id=None,):
6765 
    self.item_id = item_id
6766 
 
6767 
  def read(self, iprot):
6768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6770 
      return
6771 
    iprot.readStructBegin()
6772 
    while True:
6773 
      (fname, ftype, fid) = iprot.readFieldBegin()
6774 
      if ftype == TType.STOP:
6775 
        break
6776 
      if fid == 1:
6777 
        if ftype == TType.I64:
6778 
          self.item_id = iprot.readI64();
6779 
        else:
6780 
          iprot.skip(ftype)
6781 
      else:
6782 
        iprot.skip(ftype)
6783 
      iprot.readFieldEnd()
6784 
    iprot.readStructEnd()
6785 
 
6786 
  def write(self, oprot):
6787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6789 
      return
6790 
    oprot.writeStructBegin('getItem_args')
6791 
    if self.item_id is not None:
6792 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6793 
      oprot.writeI64(self.item_id)
6794 
      oprot.writeFieldEnd()
6795 
    oprot.writeFieldStop()
6796 
    oprot.writeStructEnd()
6797 
 
6798 
  def validate(self):
6799 
    return
6800 
 
6801 
 
6802 
  def __repr__(self):
6803 
    L = ['%s=%r' % (key, value)
6804 
      for key, value in self.__dict__.iteritems()]
6805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6806 
 
6807 
  def __eq__(self, other):
6808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6809 
 
6810 
  def __ne__(self, other):
6811 
    return not (self == other)
6812 
 
6813 
class getItem_result:
6814 
  """
6815 
  Attributes:
6816 
   - success
6817 
   - cex
6818 
  """
6819 
 
6820 
  thrift_spec = (
6821 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6822 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6823 
  )
6824 
 
6825 
  def __init__(self, success=None, cex=None,):
6826 
    self.success = success
6827 
    self.cex = cex
6828 
 
6829 
  def read(self, iprot):
6830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6832 
      return
6833 
    iprot.readStructBegin()
6834 
    while True:
6835 
      (fname, ftype, fid) = iprot.readFieldBegin()
6836 
      if ftype == TType.STOP:
6837 
        break
6838 
      if fid == 0:
6839 
        if ftype == TType.STRUCT:
6840 
          self.success = Item()
6841 
          self.success.read(iprot)
6842 
        else:
6843 
          iprot.skip(ftype)
6844 
      elif fid == 1:
6845 
        if ftype == TType.STRUCT:
6846 
          self.cex = CatalogServiceException()
6847 
          self.cex.read(iprot)
6848 
        else:
6849 
          iprot.skip(ftype)
6850 
      else:
6851 
        iprot.skip(ftype)
6852 
      iprot.readFieldEnd()
6853 
    iprot.readStructEnd()
6854 
 
6855 
  def write(self, oprot):
6856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6858 
      return
6859 
    oprot.writeStructBegin('getItem_result')
6860 
    if self.success is not None:
6861 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6862 
      self.success.write(oprot)
6863 
      oprot.writeFieldEnd()
6864 
    if self.cex is not None:
6865 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6866 
      self.cex.write(oprot)
6867 
      oprot.writeFieldEnd()
6868 
    oprot.writeFieldStop()
6869 
    oprot.writeStructEnd()
6870 
 
6871 
  def validate(self):
6872 
    return
6873 
 
6874 
 
6875 
  def __repr__(self):
6876 
    L = ['%s=%r' % (key, value)
6877 
      for key, value in self.__dict__.iteritems()]
6878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6879 
 
6880 
  def __eq__(self, other):
6881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6882 
 
6883 
  def __ne__(self, other):
6884 
    return not (self == other)
6885 
 
6886 
class getItemsByCatalogId_args:
6887 
  """
6888 
  Attributes:
6889 
   - catalog_item_id
6890 
  """
6891 
 
6892 
  thrift_spec = (
6893 
    None, # 0
6894 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6895 
  )
6896 
 
6897 
  def __init__(self, catalog_item_id=None,):
6898 
    self.catalog_item_id = catalog_item_id
6899 
 
6900 
  def read(self, iprot):
6901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6903 
      return
6904 
    iprot.readStructBegin()
6905 
    while True:
6906 
      (fname, ftype, fid) = iprot.readFieldBegin()
6907 
      if ftype == TType.STOP:
6908 
        break
6909 
      if fid == 1:
6910 
        if ftype == TType.I64:
6911 
          self.catalog_item_id = iprot.readI64();
6912 
        else:
6913 
          iprot.skip(ftype)
6914 
      else:
6915 
        iprot.skip(ftype)
6916 
      iprot.readFieldEnd()
6917 
    iprot.readStructEnd()
6918 
 
6919 
  def write(self, oprot):
6920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6922 
      return
6923 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6924 
    if self.catalog_item_id is not None:
6925 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6926 
      oprot.writeI64(self.catalog_item_id)
6927 
      oprot.writeFieldEnd()
6928 
    oprot.writeFieldStop()
6929 
    oprot.writeStructEnd()
6930 
 
6931 
  def validate(self):
6932 
    return
6933 
 
6934 
 
6935 
  def __repr__(self):
6936 
    L = ['%s=%r' % (key, value)
6937 
      for key, value in self.__dict__.iteritems()]
6938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6939 
 
6940 
  def __eq__(self, other):
6941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6942 
 
6943 
  def __ne__(self, other):
6944 
    return not (self == other)
6945 
 
6946 
class getItemsByCatalogId_result:
6947 
  """
6948 
  Attributes:
6949 
   - success
6950 
   - cex
6951 
  """
6952 
 
6953 
  thrift_spec = (
6954 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6955 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6956 
  )
6957 
 
6958 
  def __init__(self, success=None, cex=None,):
6959 
    self.success = success
6960 
    self.cex = cex
6961 
 
6962 
  def read(self, iprot):
6963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6965 
      return
6966 
    iprot.readStructBegin()
6967 
    while True:
6968 
      (fname, ftype, fid) = iprot.readFieldBegin()
6969 
      if ftype == TType.STOP:
6970 
        break
6971 
      if fid == 0:
6972 
        if ftype == TType.LIST:
6973 
          self.success = []
7438 amit.gupta 6974 
          (_etype35, _size32) = iprot.readListBegin()
6975 
          for _i36 in xrange(_size32):
6976 
            _elem37 = Item()
6977 
            _elem37.read(iprot)
6978 
            self.success.append(_elem37)
5944 mandeep.dh 6979 
          iprot.readListEnd()
6980 
        else:
6981 
          iprot.skip(ftype)
6982 
      elif fid == 1:
6983 
        if ftype == TType.STRUCT:
6984 
          self.cex = CatalogServiceException()
6985 
          self.cex.read(iprot)
6986 
        else:
6987 
          iprot.skip(ftype)
6988 
      else:
6989 
        iprot.skip(ftype)
6990 
      iprot.readFieldEnd()
6991 
    iprot.readStructEnd()
6992 
 
6993 
  def write(self, oprot):
6994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6996 
      return
6997 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6998 
    if self.success is not None:
6999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7001 
      for iter38 in self.success:
7002 
        iter38.write(oprot)
5944 mandeep.dh 7003 
      oprot.writeListEnd()
7004 
      oprot.writeFieldEnd()
7005 
    if self.cex is not None:
7006 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7007 
      self.cex.write(oprot)
7008 
      oprot.writeFieldEnd()
7009 
    oprot.writeFieldStop()
7010 
    oprot.writeStructEnd()
7011 
 
7012 
  def validate(self):
7013 
    return
7014 
 
7015 
 
7016 
  def __repr__(self):
7017 
    L = ['%s=%r' % (key, value)
7018 
      for key, value in self.__dict__.iteritems()]
7019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7020 
 
7021 
  def __eq__(self, other):
7022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7023 
 
7024 
  def __ne__(self, other):
7025 
    return not (self == other)
7026 
 
7027 
class getValidItemsByCatalogId_args:
7028 
  """
7029 
  Attributes:
7030 
   - catalog_item_id
7031 
  """
7032 
 
7033 
  thrift_spec = (
7034 
    None, # 0
7035 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7036 
  )
7037 
 
7038 
  def __init__(self, catalog_item_id=None,):
7039 
    self.catalog_item_id = catalog_item_id
7040 
 
7041 
  def read(self, iprot):
7042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7044 
      return
7045 
    iprot.readStructBegin()
7046 
    while True:
7047 
      (fname, ftype, fid) = iprot.readFieldBegin()
7048 
      if ftype == TType.STOP:
7049 
        break
7050 
      if fid == 1:
7051 
        if ftype == TType.I64:
7052 
          self.catalog_item_id = iprot.readI64();
7053 
        else:
7054 
          iprot.skip(ftype)
7055 
      else:
7056 
        iprot.skip(ftype)
7057 
      iprot.readFieldEnd()
7058 
    iprot.readStructEnd()
7059 
 
7060 
  def write(self, oprot):
7061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7063 
      return
7064 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
7065 
    if self.catalog_item_id is not None:
7066 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7067 
      oprot.writeI64(self.catalog_item_id)
7068 
      oprot.writeFieldEnd()
7069 
    oprot.writeFieldStop()
7070 
    oprot.writeStructEnd()
7071 
 
7072 
  def validate(self):
7073 
    return
7074 
 
7075 
 
7076 
  def __repr__(self):
7077 
    L = ['%s=%r' % (key, value)
7078 
      for key, value in self.__dict__.iteritems()]
7079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7080 
 
7081 
  def __eq__(self, other):
7082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7083 
 
7084 
  def __ne__(self, other):
7085 
    return not (self == other)
7086 
 
7087 
class getValidItemsByCatalogId_result:
7088 
  """
7089 
  Attributes:
7090 
   - success
7091 
   - cex
7092 
  """
7093 
 
7094 
  thrift_spec = (
7095 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7096 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7097 
  )
7098 
 
7099 
  def __init__(self, success=None, cex=None,):
7100 
    self.success = success
7101 
    self.cex = cex
7102 
 
7103 
  def read(self, iprot):
7104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7106 
      return
7107 
    iprot.readStructBegin()
7108 
    while True:
7109 
      (fname, ftype, fid) = iprot.readFieldBegin()
7110 
      if ftype == TType.STOP:
7111 
        break
7112 
      if fid == 0:
7113 
        if ftype == TType.LIST:
7114 
          self.success = []
7438 amit.gupta 7115 
          (_etype42, _size39) = iprot.readListBegin()
7116 
          for _i43 in xrange(_size39):
7117 
            _elem44 = Item()
7118 
            _elem44.read(iprot)
7119 
            self.success.append(_elem44)
5944 mandeep.dh 7120 
          iprot.readListEnd()
7121 
        else:
7122 
          iprot.skip(ftype)
7123 
      elif fid == 1:
7124 
        if ftype == TType.STRUCT:
7125 
          self.cex = CatalogServiceException()
7126 
          self.cex.read(iprot)
7127 
        else:
7128 
          iprot.skip(ftype)
7129 
      else:
7130 
        iprot.skip(ftype)
7131 
      iprot.readFieldEnd()
7132 
    iprot.readStructEnd()
7133 
 
7134 
  def write(self, oprot):
7135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7137 
      return
7138 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7139 
    if self.success is not None:
7140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7142 
      for iter45 in self.success:
7143 
        iter45.write(oprot)
5944 mandeep.dh 7144 
      oprot.writeListEnd()
7145 
      oprot.writeFieldEnd()
7146 
    if self.cex is not None:
7147 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7148 
      self.cex.write(oprot)
7149 
      oprot.writeFieldEnd()
7150 
    oprot.writeFieldStop()
7151 
    oprot.writeStructEnd()
7152 
 
7153 
  def validate(self):
7154 
    return
7155 
 
7156 
 
7157 
  def __repr__(self):
7158 
    L = ['%s=%r' % (key, value)
7159 
      for key, value in self.__dict__.iteritems()]
7160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7161 
 
7162 
  def __eq__(self, other):
7163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7164 
 
7165 
  def __ne__(self, other):
7166 
    return not (self == other)
7167 
 
7168 
class getAllItems_args:
7169 
  """
7170 
  Attributes:
7171 
   - isActive
7172 
  """
7173 
 
7174 
  thrift_spec = (
7175 
    None, # 0
7176 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7177 
  )
7178 
 
7179 
  def __init__(self, isActive=None,):
7180 
    self.isActive = isActive
7181 
 
7182 
  def read(self, iprot):
7183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7185 
      return
7186 
    iprot.readStructBegin()
7187 
    while True:
7188 
      (fname, ftype, fid) = iprot.readFieldBegin()
7189 
      if ftype == TType.STOP:
7190 
        break
7191 
      if fid == 1:
7192 
        if ftype == TType.BOOL:
7193 
          self.isActive = iprot.readBool();
7194 
        else:
7195 
          iprot.skip(ftype)
7196 
      else:
7197 
        iprot.skip(ftype)
7198 
      iprot.readFieldEnd()
7199 
    iprot.readStructEnd()
7200 
 
7201 
  def write(self, oprot):
7202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7204 
      return
7205 
    oprot.writeStructBegin('getAllItems_args')
7206 
    if self.isActive is not None:
7207 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7208 
      oprot.writeBool(self.isActive)
7209 
      oprot.writeFieldEnd()
7210 
    oprot.writeFieldStop()
7211 
    oprot.writeStructEnd()
7212 
 
7213 
  def validate(self):
7214 
    return
7215 
 
7216 
 
7217 
  def __repr__(self):
7218 
    L = ['%s=%r' % (key, value)
7219 
      for key, value in self.__dict__.iteritems()]
7220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7221 
 
7222 
  def __eq__(self, other):
7223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7224 
 
7225 
  def __ne__(self, other):
7226 
    return not (self == other)
7227 
 
7228 
class getAllItems_result:
7229 
  """
7230 
  Attributes:
7231 
   - success
7232 
   - cex
7233 
  """
7234 
 
7235 
  thrift_spec = (
7236 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7237 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7238 
  )
7239 
 
7240 
  def __init__(self, success=None, cex=None,):
7241 
    self.success = success
7242 
    self.cex = cex
7243 
 
7244 
  def read(self, iprot):
7245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7247 
      return
7248 
    iprot.readStructBegin()
7249 
    while True:
7250 
      (fname, ftype, fid) = iprot.readFieldBegin()
7251 
      if ftype == TType.STOP:
7252 
        break
7253 
      if fid == 0:
7254 
        if ftype == TType.LIST:
7255 
          self.success = []
7438 amit.gupta 7256 
          (_etype49, _size46) = iprot.readListBegin()
7257 
          for _i50 in xrange(_size46):
7258 
            _elem51 = Item()
7259 
            _elem51.read(iprot)
7260 
            self.success.append(_elem51)
5944 mandeep.dh 7261 
          iprot.readListEnd()
7262 
        else:
7263 
          iprot.skip(ftype)
7264 
      elif fid == 1:
7265 
        if ftype == TType.STRUCT:
7266 
          self.cex = CatalogServiceException()
7267 
          self.cex.read(iprot)
7268 
        else:
7269 
          iprot.skip(ftype)
7270 
      else:
7271 
        iprot.skip(ftype)
7272 
      iprot.readFieldEnd()
7273 
    iprot.readStructEnd()
7274 
 
7275 
  def write(self, oprot):
7276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7278 
      return
7279 
    oprot.writeStructBegin('getAllItems_result')
7280 
    if self.success is not None:
7281 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7282 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7283 
      for iter52 in self.success:
7284 
        iter52.write(oprot)
5944 mandeep.dh 7285 
      oprot.writeListEnd()
7286 
      oprot.writeFieldEnd()
7287 
    if self.cex is not None:
7288 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7289 
      self.cex.write(oprot)
7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
7294 
  def validate(self):
7295 
    return
7296 
 
7297 
 
7298 
  def __repr__(self):
7299 
    L = ['%s=%r' % (key, value)
7300 
      for key, value in self.__dict__.iteritems()]
7301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7302 
 
7303 
  def __eq__(self, other):
7304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7305 
 
7306 
  def __ne__(self, other):
7307 
    return not (self == other)
7308 
 
7309 
class getAllItemsByStatus_args:
7310 
  """
7311 
  Attributes:
7312 
   - itemStatus
7313 
  """
7314 
 
7315 
  thrift_spec = (
7316 
    None, # 0
7317 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7318 
  )
7319 
 
7320 
  def __init__(self, itemStatus=None,):
7321 
    self.itemStatus = itemStatus
7322 
 
7323 
  def read(self, iprot):
7324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7326 
      return
7327 
    iprot.readStructBegin()
7328 
    while True:
7329 
      (fname, ftype, fid) = iprot.readFieldBegin()
7330 
      if ftype == TType.STOP:
7331 
        break
7332 
      if fid == 1:
7333 
        if ftype == TType.I32:
7334 
          self.itemStatus = iprot.readI32();
7335 
        else:
7336 
          iprot.skip(ftype)
7337 
      else:
7338 
        iprot.skip(ftype)
7339 
      iprot.readFieldEnd()
7340 
    iprot.readStructEnd()
7341 
 
7342 
  def write(self, oprot):
7343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7345 
      return
7346 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7347 
    if self.itemStatus is not None:
7348 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7349 
      oprot.writeI32(self.itemStatus)
7350 
      oprot.writeFieldEnd()
7351 
    oprot.writeFieldStop()
7352 
    oprot.writeStructEnd()
7353 
 
7354 
  def validate(self):
7355 
    return
7356 
 
7357 
 
7358 
  def __repr__(self):
7359 
    L = ['%s=%r' % (key, value)
7360 
      for key, value in self.__dict__.iteritems()]
7361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7362 
 
7363 
  def __eq__(self, other):
7364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7365 
 
7366 
  def __ne__(self, other):
7367 
    return not (self == other)
7368 
 
7369 
class getAllItemsByStatus_result:
7370 
  """
7371 
  Attributes:
7372 
   - success
7373 
   - cex
7374 
  """
7375 
 
7376 
  thrift_spec = (
7377 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7378 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7379 
  )
7380 
 
7381 
  def __init__(self, success=None, cex=None,):
7382 
    self.success = success
7383 
    self.cex = cex
7384 
 
7385 
  def read(self, iprot):
7386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7388 
      return
7389 
    iprot.readStructBegin()
7390 
    while True:
7391 
      (fname, ftype, fid) = iprot.readFieldBegin()
7392 
      if ftype == TType.STOP:
7393 
        break
7394 
      if fid == 0:
7395 
        if ftype == TType.LIST:
7396 
          self.success = []
7438 amit.gupta 7397 
          (_etype56, _size53) = iprot.readListBegin()
7398 
          for _i57 in xrange(_size53):
7399 
            _elem58 = Item()
7400 
            _elem58.read(iprot)
7401 
            self.success.append(_elem58)
5944 mandeep.dh 7402 
          iprot.readListEnd()
7403 
        else:
7404 
          iprot.skip(ftype)
7405 
      elif fid == 1:
7406 
        if ftype == TType.STRUCT:
7407 
          self.cex = CatalogServiceException()
7408 
          self.cex.read(iprot)
7409 
        else:
7410 
          iprot.skip(ftype)
7411 
      else:
7412 
        iprot.skip(ftype)
7413 
      iprot.readFieldEnd()
7414 
    iprot.readStructEnd()
7415 
 
7416 
  def write(self, oprot):
7417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7419 
      return
7420 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7421 
    if self.success is not None:
7422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7423 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7424 
      for iter59 in self.success:
7425 
        iter59.write(oprot)
5944 mandeep.dh 7426 
      oprot.writeListEnd()
7427 
      oprot.writeFieldEnd()
7428 
    if self.cex is not None:
7429 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7430 
      self.cex.write(oprot)
7431 
      oprot.writeFieldEnd()
7432 
    oprot.writeFieldStop()
7433 
    oprot.writeStructEnd()
7434 
 
7435 
  def validate(self):
7436 
    return
7437 
 
7438 
 
7439 
  def __repr__(self):
7440 
    L = ['%s=%r' % (key, value)
7441 
      for key, value in self.__dict__.iteritems()]
7442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7443 
 
7444 
  def __eq__(self, other):
7445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7446 
 
7447 
  def __ne__(self, other):
7448 
    return not (self == other)
7449 
 
7450 
class markItemAsContentComplete_args:
7451 
  """
7452 
  Attributes:
7453 
   - entityId
7454 
   - category
7455 
   - brand
7456 
   - modelName
7457 
   - modelNumber
7458 
  """
7459 
 
7460 
  thrift_spec = (
7461 
    None, # 0
7462 
    (1, TType.I64, 'entityId', None, None, ), # 1
7463 
    (2, TType.I64, 'category', None, None, ), # 2
7464 
    (3, TType.STRING, 'brand', None, None, ), # 3
7465 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7466 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7467 
  )
7468 
 
7469 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7470 
    self.entityId = entityId
7471 
    self.category = category
7472 
    self.brand = brand
7473 
    self.modelName = modelName
7474 
    self.modelNumber = modelNumber
7475 
 
7476 
  def read(self, iprot):
7477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7479 
      return
7480 
    iprot.readStructBegin()
7481 
    while True:
7482 
      (fname, ftype, fid) = iprot.readFieldBegin()
7483 
      if ftype == TType.STOP:
7484 
        break
7485 
      if fid == 1:
7486 
        if ftype == TType.I64:
7487 
          self.entityId = iprot.readI64();
7488 
        else:
7489 
          iprot.skip(ftype)
7490 
      elif fid == 2:
7491 
        if ftype == TType.I64:
7492 
          self.category = iprot.readI64();
7493 
        else:
7494 
          iprot.skip(ftype)
7495 
      elif fid == 3:
7496 
        if ftype == TType.STRING:
7497 
          self.brand = iprot.readString();
7498 
        else:
7499 
          iprot.skip(ftype)
7500 
      elif fid == 4:
7501 
        if ftype == TType.STRING:
7502 
          self.modelName = iprot.readString();
7503 
        else:
7504 
          iprot.skip(ftype)
7505 
      elif fid == 5:
7506 
        if ftype == TType.STRING:
7507 
          self.modelNumber = iprot.readString();
7508 
        else:
7509 
          iprot.skip(ftype)
7510 
      else:
7511 
        iprot.skip(ftype)
7512 
      iprot.readFieldEnd()
7513 
    iprot.readStructEnd()
7514 
 
7515 
  def write(self, oprot):
7516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7518 
      return
7519 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7520 
    if self.entityId is not None:
7521 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7522 
      oprot.writeI64(self.entityId)
7523 
      oprot.writeFieldEnd()
7524 
    if self.category is not None:
7525 
      oprot.writeFieldBegin('category', TType.I64, 2)
7526 
      oprot.writeI64(self.category)
7527 
      oprot.writeFieldEnd()
7528 
    if self.brand is not None:
7529 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7530 
      oprot.writeString(self.brand)
7531 
      oprot.writeFieldEnd()
7532 
    if self.modelName is not None:
7533 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7534 
      oprot.writeString(self.modelName)
7535 
      oprot.writeFieldEnd()
7536 
    if self.modelNumber is not None:
7537 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7538 
      oprot.writeString(self.modelNumber)
7539 
      oprot.writeFieldEnd()
7540 
    oprot.writeFieldStop()
7541 
    oprot.writeStructEnd()
7542 
 
7543 
  def validate(self):
7544 
    return
7545 
 
7546 
 
7547 
  def __repr__(self):
7548 
    L = ['%s=%r' % (key, value)
7549 
      for key, value in self.__dict__.iteritems()]
7550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7551 
 
7552 
  def __eq__(self, other):
7553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7554 
 
7555 
  def __ne__(self, other):
7556 
    return not (self == other)
7557 
 
7558 
class markItemAsContentComplete_result:
7559 
  """
7560 
  Attributes:
7561 
   - success
7562 
   - cex
7563 
  """
7564 
 
7565 
  thrift_spec = (
7566 
    (0, TType.BOOL, 'success', None, None, ), # 0
7567 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7568 
  )
7569 
 
7570 
  def __init__(self, success=None, cex=None,):
7571 
    self.success = success
7572 
    self.cex = cex
7573 
 
7574 
  def read(self, iprot):
7575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7577 
      return
7578 
    iprot.readStructBegin()
7579 
    while True:
7580 
      (fname, ftype, fid) = iprot.readFieldBegin()
7581 
      if ftype == TType.STOP:
7582 
        break
7583 
      if fid == 0:
7584 
        if ftype == TType.BOOL:
7585 
          self.success = iprot.readBool();
7586 
        else:
7587 
          iprot.skip(ftype)
7588 
      elif fid == 1:
7589 
        if ftype == TType.STRUCT:
7590 
          self.cex = CatalogServiceException()
7591 
          self.cex.read(iprot)
7592 
        else:
7593 
          iprot.skip(ftype)
7594 
      else:
7595 
        iprot.skip(ftype)
7596 
      iprot.readFieldEnd()
7597 
    iprot.readStructEnd()
7598 
 
7599 
  def write(self, oprot):
7600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7602 
      return
7603 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7604 
    if self.success is not None:
7605 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7606 
      oprot.writeBool(self.success)
7607 
      oprot.writeFieldEnd()
7608 
    if self.cex is not None:
7609 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7610 
      self.cex.write(oprot)
7611 
      oprot.writeFieldEnd()
7612 
    oprot.writeFieldStop()
7613 
    oprot.writeStructEnd()
7614 
 
7615 
  def validate(self):
7616 
    return
7617 
 
7618 
 
7619 
  def __repr__(self):
7620 
    L = ['%s=%r' % (key, value)
7621 
      for key, value in self.__dict__.iteritems()]
7622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7623 
 
7624 
  def __eq__(self, other):
7625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7626 
 
7627 
  def __ne__(self, other):
7628 
    return not (self == other)
7629 
 
7630 
class getAllItemsInRange_args:
7631 
  """
7632 
  Attributes:
7633 
   - offset
7634 
   - limit
7635 
  """
7636 
 
7637 
  thrift_spec = (
7638 
    None, # 0
7639 
    (1, TType.I64, 'offset', None, None, ), # 1
7640 
    (2, TType.I64, 'limit', None, None, ), # 2
7641 
  )
7642 
 
7643 
  def __init__(self, offset=None, limit=None,):
7644 
    self.offset = offset
7645 
    self.limit = limit
7646 
 
7647 
  def read(self, iprot):
7648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7650 
      return
7651 
    iprot.readStructBegin()
7652 
    while True:
7653 
      (fname, ftype, fid) = iprot.readFieldBegin()
7654 
      if ftype == TType.STOP:
7655 
        break
7656 
      if fid == 1:
7657 
        if ftype == TType.I64:
7658 
          self.offset = iprot.readI64();
7659 
        else:
7660 
          iprot.skip(ftype)
7661 
      elif fid == 2:
7662 
        if ftype == TType.I64:
7663 
          self.limit = iprot.readI64();
7664 
        else:
7665 
          iprot.skip(ftype)
7666 
      else:
7667 
        iprot.skip(ftype)
7668 
      iprot.readFieldEnd()
7669 
    iprot.readStructEnd()
7670 
 
7671 
  def write(self, oprot):
7672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7674 
      return
7675 
    oprot.writeStructBegin('getAllItemsInRange_args')
7676 
    if self.offset is not None:
7677 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7678 
      oprot.writeI64(self.offset)
7679 
      oprot.writeFieldEnd()
7680 
    if self.limit is not None:
7681 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7682 
      oprot.writeI64(self.limit)
7683 
      oprot.writeFieldEnd()
7684 
    oprot.writeFieldStop()
7685 
    oprot.writeStructEnd()
7686 
 
7687 
  def validate(self):
7688 
    return
7689 
 
7690 
 
7691 
  def __repr__(self):
7692 
    L = ['%s=%r' % (key, value)
7693 
      for key, value in self.__dict__.iteritems()]
7694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7695 
 
7696 
  def __eq__(self, other):
7697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7698 
 
7699 
  def __ne__(self, other):
7700 
    return not (self == other)
7701 
 
7702 
class getAllItemsInRange_result:
7703 
  """
7704 
  Attributes:
7705 
   - success
7706 
   - cex
7707 
  """
7708 
 
7709 
  thrift_spec = (
7710 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7711 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7712 
  )
7713 
 
7714 
  def __init__(self, success=None, cex=None,):
7715 
    self.success = success
7716 
    self.cex = cex
7717 
 
7718 
  def read(self, iprot):
7719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7721 
      return
7722 
    iprot.readStructBegin()
7723 
    while True:
7724 
      (fname, ftype, fid) = iprot.readFieldBegin()
7725 
      if ftype == TType.STOP:
7726 
        break
7727 
      if fid == 0:
7728 
        if ftype == TType.LIST:
7729 
          self.success = []
7438 amit.gupta 7730 
          (_etype63, _size60) = iprot.readListBegin()
7731 
          for _i64 in xrange(_size60):
7732 
            _elem65 = Item()
7733 
            _elem65.read(iprot)
7734 
            self.success.append(_elem65)
5944 mandeep.dh 7735 
          iprot.readListEnd()
7736 
        else:
7737 
          iprot.skip(ftype)
7738 
      elif fid == 1:
7739 
        if ftype == TType.STRUCT:
7740 
          self.cex = CatalogServiceException()
7741 
          self.cex.read(iprot)
7742 
        else:
7743 
          iprot.skip(ftype)
7744 
      else:
7745 
        iprot.skip(ftype)
7746 
      iprot.readFieldEnd()
7747 
    iprot.readStructEnd()
7748 
 
7749 
  def write(self, oprot):
7750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7752 
      return
7753 
    oprot.writeStructBegin('getAllItemsInRange_result')
7754 
    if self.success is not None:
7755 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7756 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7757 
      for iter66 in self.success:
7758 
        iter66.write(oprot)
5944 mandeep.dh 7759 
      oprot.writeListEnd()
7760 
      oprot.writeFieldEnd()
7761 
    if self.cex is not None:
7762 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7763 
      self.cex.write(oprot)
7764 
      oprot.writeFieldEnd()
7765 
    oprot.writeFieldStop()
7766 
    oprot.writeStructEnd()
7767 
 
7768 
  def validate(self):
7769 
    return
7770 
 
7771 
 
7772 
  def __repr__(self):
7773 
    L = ['%s=%r' % (key, value)
7774 
      for key, value in self.__dict__.iteritems()]
7775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7776 
 
7777 
  def __eq__(self, other):
7778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7779 
 
7780 
  def __ne__(self, other):
7781 
    return not (self == other)
7782 
 
7783 
class getAllItemsByStatusInRange_args:
7784 
  """
7785 
  Attributes:
7786 
   - itemStatus
7787 
   - offset
7788 
   - limit
7789 
  """
7790 
 
7791 
  thrift_spec = (
7792 
    None, # 0
7793 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7794 
    (2, TType.I64, 'offset', None, None, ), # 2
7795 
    (3, TType.I64, 'limit', None, None, ), # 3
7796 
  )
7797 
 
7798 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7799 
    self.itemStatus = itemStatus
7800 
    self.offset = offset
7801 
    self.limit = limit
7802 
 
7803 
  def read(self, iprot):
7804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7806 
      return
7807 
    iprot.readStructBegin()
7808 
    while True:
7809 
      (fname, ftype, fid) = iprot.readFieldBegin()
7810 
      if ftype == TType.STOP:
7811 
        break
7812 
      if fid == 1:
7813 
        if ftype == TType.I32:
7814 
          self.itemStatus = iprot.readI32();
7815 
        else:
7816 
          iprot.skip(ftype)
7817 
      elif fid == 2:
7818 
        if ftype == TType.I64:
7819 
          self.offset = iprot.readI64();
7820 
        else:
7821 
          iprot.skip(ftype)
7822 
      elif fid == 3:
7823 
        if ftype == TType.I64:
7824 
          self.limit = iprot.readI64();
7825 
        else:
7826 
          iprot.skip(ftype)
7827 
      else:
7828 
        iprot.skip(ftype)
7829 
      iprot.readFieldEnd()
7830 
    iprot.readStructEnd()
7831 
 
7832 
  def write(self, oprot):
7833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7835 
      return
7836 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7837 
    if self.itemStatus is not None:
7838 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7839 
      oprot.writeI32(self.itemStatus)
7840 
      oprot.writeFieldEnd()
7841 
    if self.offset is not None:
7842 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7843 
      oprot.writeI64(self.offset)
7844 
      oprot.writeFieldEnd()
7845 
    if self.limit is not None:
7846 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7847 
      oprot.writeI64(self.limit)
7848 
      oprot.writeFieldEnd()
7849 
    oprot.writeFieldStop()
7850 
    oprot.writeStructEnd()
7851 
 
7852 
  def validate(self):
7853 
    return
7854 
 
7855 
 
7856 
  def __repr__(self):
7857 
    L = ['%s=%r' % (key, value)
7858 
      for key, value in self.__dict__.iteritems()]
7859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7860 
 
7861 
  def __eq__(self, other):
7862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7863 
 
7864 
  def __ne__(self, other):
7865 
    return not (self == other)
7866 
 
7867 
class getAllItemsByStatusInRange_result:
7868 
  """
7869 
  Attributes:
7870 
   - success
7871 
   - cex
7872 
  """
7873 
 
7874 
  thrift_spec = (
7875 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7876 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7877 
  )
7878 
 
7879 
  def __init__(self, success=None, cex=None,):
7880 
    self.success = success
7881 
    self.cex = cex
7882 
 
7883 
  def read(self, iprot):
7884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7886 
      return
7887 
    iprot.readStructBegin()
7888 
    while True:
7889 
      (fname, ftype, fid) = iprot.readFieldBegin()
7890 
      if ftype == TType.STOP:
7891 
        break
7892 
      if fid == 0:
7893 
        if ftype == TType.LIST:
7894 
          self.success = []
7438 amit.gupta 7895 
          (_etype70, _size67) = iprot.readListBegin()
7896 
          for _i71 in xrange(_size67):
7897 
            _elem72 = Item()
7898 
            _elem72.read(iprot)
7899 
            self.success.append(_elem72)
5944 mandeep.dh 7900 
          iprot.readListEnd()
7901 
        else:
7902 
          iprot.skip(ftype)
7903 
      elif fid == 1:
7904 
        if ftype == TType.STRUCT:
7905 
          self.cex = CatalogServiceException()
7906 
          self.cex.read(iprot)
7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      else:
7910 
        iprot.skip(ftype)
7911 
      iprot.readFieldEnd()
7912 
    iprot.readStructEnd()
7913 
 
7914 
  def write(self, oprot):
7915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7917 
      return
7918 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7919 
    if self.success is not None:
7920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7922 
      for iter73 in self.success:
7923 
        iter73.write(oprot)
5944 mandeep.dh 7924 
      oprot.writeListEnd()
7925 
      oprot.writeFieldEnd()
7926 
    if self.cex is not None:
7927 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7928 
      self.cex.write(oprot)
7929 
      oprot.writeFieldEnd()
7930 
    oprot.writeFieldStop()
7931 
    oprot.writeStructEnd()
7932 
 
7933 
  def validate(self):
7934 
    return
7935 
 
7936 
 
7937 
  def __repr__(self):
7938 
    L = ['%s=%r' % (key, value)
7939 
      for key, value in self.__dict__.iteritems()]
7940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7941 
 
7942 
  def __eq__(self, other):
7943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7944 
 
7945 
  def __ne__(self, other):
7946 
    return not (self == other)
7947 
 
7948 
class getItemCountByStatus_args:
7949 
  """
7950 
  Attributes:
7951 
   - useStatus
7952 
   - itemStatus
7953 
  """
7954 
 
7955 
  thrift_spec = (
7956 
    None, # 0
7957 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7958 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7959 
  )
7960 
 
7961 
  def __init__(self, useStatus=None, itemStatus=None,):
7962 
    self.useStatus = useStatus
7963 
    self.itemStatus = itemStatus
7964 
 
7965 
  def read(self, iprot):
7966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7968 
      return
7969 
    iprot.readStructBegin()
7970 
    while True:
7971 
      (fname, ftype, fid) = iprot.readFieldBegin()
7972 
      if ftype == TType.STOP:
7973 
        break
7974 
      if fid == 1:
7975 
        if ftype == TType.BOOL:
7976 
          self.useStatus = iprot.readBool();
7977 
        else:
7978 
          iprot.skip(ftype)
7979 
      elif fid == 2:
7980 
        if ftype == TType.I32:
7981 
          self.itemStatus = iprot.readI32();
7982 
        else:
7983 
          iprot.skip(ftype)
7984 
      else:
7985 
        iprot.skip(ftype)
7986 
      iprot.readFieldEnd()
7987 
    iprot.readStructEnd()
7988 
 
7989 
  def write(self, oprot):
7990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7992 
      return
7993 
    oprot.writeStructBegin('getItemCountByStatus_args')
7994 
    if self.useStatus is not None:
7995 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7996 
      oprot.writeBool(self.useStatus)
7997 
      oprot.writeFieldEnd()
7998 
    if self.itemStatus is not None:
7999 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8000 
      oprot.writeI32(self.itemStatus)
8001 
      oprot.writeFieldEnd()
8002 
    oprot.writeFieldStop()
8003 
    oprot.writeStructEnd()
8004 
 
8005 
  def validate(self):
8006 
    return
8007 
 
8008 
 
8009 
  def __repr__(self):
8010 
    L = ['%s=%r' % (key, value)
8011 
      for key, value in self.__dict__.iteritems()]
8012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8013 
 
8014 
  def __eq__(self, other):
8015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8016 
 
8017 
  def __ne__(self, other):
8018 
    return not (self == other)
8019 
 
8020 
class getItemCountByStatus_result:
8021 
  """
8022 
  Attributes:
8023 
   - success
8024 
  """
8025 
 
8026 
  thrift_spec = (
8027 
    (0, TType.I32, 'success', None, None, ), # 0
8028 
  )
8029 
 
8030 
  def __init__(self, success=None,):
8031 
    self.success = success
8032 
 
8033 
  def read(self, iprot):
8034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8036 
      return
8037 
    iprot.readStructBegin()
8038 
    while True:
8039 
      (fname, ftype, fid) = iprot.readFieldBegin()
8040 
      if ftype == TType.STOP:
8041 
        break
8042 
      if fid == 0:
8043 
        if ftype == TType.I32:
8044 
          self.success = iprot.readI32();
8045 
        else:
8046 
          iprot.skip(ftype)
8047 
      else:
8048 
        iprot.skip(ftype)
8049 
      iprot.readFieldEnd()
8050 
    iprot.readStructEnd()
8051 
 
8052 
  def write(self, oprot):
8053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8055 
      return
8056 
    oprot.writeStructBegin('getItemCountByStatus_result')
8057 
    if self.success is not None:
8058 
      oprot.writeFieldBegin('success', TType.I32, 0)
8059 
      oprot.writeI32(self.success)
8060 
      oprot.writeFieldEnd()
8061 
    oprot.writeFieldStop()
8062 
    oprot.writeStructEnd()
8063 
 
8064 
  def validate(self):
8065 
    return
8066 
 
8067 
 
8068 
  def __repr__(self):
8069 
    L = ['%s=%r' % (key, value)
8070 
      for key, value in self.__dict__.iteritems()]
8071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8072 
 
8073 
  def __eq__(self, other):
8074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8075 
 
8076 
  def __ne__(self, other):
8077 
    return not (self == other)
8078 
 
8079 
class getBestSellers_args:
8080 
 
8081 
  thrift_spec = (
8082 
  )
8083 
 
8084 
  def read(self, iprot):
8085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8087 
      return
8088 
    iprot.readStructBegin()
8089 
    while True:
8090 
      (fname, ftype, fid) = iprot.readFieldBegin()
8091 
      if ftype == TType.STOP:
8092 
        break
8093 
      else:
8094 
        iprot.skip(ftype)
8095 
      iprot.readFieldEnd()
8096 
    iprot.readStructEnd()
8097 
 
8098 
  def write(self, oprot):
8099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8101 
      return
8102 
    oprot.writeStructBegin('getBestSellers_args')
8103 
    oprot.writeFieldStop()
8104 
    oprot.writeStructEnd()
8105 
 
8106 
  def validate(self):
8107 
    return
8108 
 
8109 
 
8110 
  def __repr__(self):
8111 
    L = ['%s=%r' % (key, value)
8112 
      for key, value in self.__dict__.iteritems()]
8113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8114 
 
8115 
  def __eq__(self, other):
8116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8117 
 
8118 
  def __ne__(self, other):
8119 
    return not (self == other)
8120 
 
8121 
class getBestSellers_result:
8122 
  """
8123 
  Attributes:
8124 
   - success
8125 
   - isex
8126 
  """
8127 
 
8128 
  thrift_spec = (
8129 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8130 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8131 
  )
8132 
 
8133 
  def __init__(self, success=None, isex=None,):
8134 
    self.success = success
8135 
    self.isex = isex
8136 
 
8137 
  def read(self, iprot):
8138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8140 
      return
8141 
    iprot.readStructBegin()
8142 
    while True:
8143 
      (fname, ftype, fid) = iprot.readFieldBegin()
8144 
      if ftype == TType.STOP:
8145 
        break
8146 
      if fid == 0:
8147 
        if ftype == TType.LIST:
8148 
          self.success = []
7438 amit.gupta 8149 
          (_etype77, _size74) = iprot.readListBegin()
8150 
          for _i78 in xrange(_size74):
8151 
            _elem79 = Item()
8152 
            _elem79.read(iprot)
8153 
            self.success.append(_elem79)
5944 mandeep.dh 8154 
          iprot.readListEnd()
8155 
        else:
8156 
          iprot.skip(ftype)
8157 
      elif fid == 1:
8158 
        if ftype == TType.STRUCT:
8159 
          self.isex = CatalogServiceException()
8160 
          self.isex.read(iprot)
8161 
        else:
8162 
          iprot.skip(ftype)
8163 
      else:
8164 
        iprot.skip(ftype)
8165 
      iprot.readFieldEnd()
8166 
    iprot.readStructEnd()
8167 
 
8168 
  def write(self, oprot):
8169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8171 
      return
8172 
    oprot.writeStructBegin('getBestSellers_result')
8173 
    if self.success is not None:
8174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8176 
      for iter80 in self.success:
8177 
        iter80.write(oprot)
5944 mandeep.dh 8178 
      oprot.writeListEnd()
8179 
      oprot.writeFieldEnd()
8180 
    if self.isex is not None:
8181 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8182 
      self.isex.write(oprot)
8183 
      oprot.writeFieldEnd()
8184 
    oprot.writeFieldStop()
8185 
    oprot.writeStructEnd()
8186 
 
8187 
  def validate(self):
8188 
    return
8189 
 
8190 
 
8191 
  def __repr__(self):
8192 
    L = ['%s=%r' % (key, value)
8193 
      for key, value in self.__dict__.iteritems()]
8194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8195 
 
8196 
  def __eq__(self, other):
8197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8198 
 
8199 
  def __ne__(self, other):
8200 
    return not (self == other)
8201 
 
8202 
class getBestSellersCatalogIds_args:
8203 
  """
8204 
  Attributes:
8205 
   - beginIndex
8206 
   - totalItems
8207 
   - brand
8208 
   - category
8209 
  """
8210 
 
8211 
  thrift_spec = (
8212 
    None, # 0
8213 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8214 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8215 
    (3, TType.STRING, 'brand', None, None, ), # 3
8216 
    (4, TType.I64, 'category', None, None, ), # 4
8217 
  )
8218 
 
8219 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8220 
    self.beginIndex = beginIndex
8221 
    self.totalItems = totalItems
8222 
    self.brand = brand
8223 
    self.category = category
8224 
 
8225 
  def read(self, iprot):
8226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8228 
      return
8229 
    iprot.readStructBegin()
8230 
    while True:
8231 
      (fname, ftype, fid) = iprot.readFieldBegin()
8232 
      if ftype == TType.STOP:
8233 
        break
8234 
      if fid == 1:
8235 
        if ftype == TType.I64:
8236 
          self.beginIndex = iprot.readI64();
8237 
        else:
8238 
          iprot.skip(ftype)
8239 
      elif fid == 2:
8240 
        if ftype == TType.I64:
8241 
          self.totalItems = iprot.readI64();
8242 
        else:
8243 
          iprot.skip(ftype)
8244 
      elif fid == 3:
8245 
        if ftype == TType.STRING:
8246 
          self.brand = iprot.readString();
8247 
        else:
8248 
          iprot.skip(ftype)
8249 
      elif fid == 4:
8250 
        if ftype == TType.I64:
8251 
          self.category = iprot.readI64();
8252 
        else:
8253 
          iprot.skip(ftype)
8254 
      else:
8255 
        iprot.skip(ftype)
8256 
      iprot.readFieldEnd()
8257 
    iprot.readStructEnd()
8258 
 
8259 
  def write(self, oprot):
8260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8262 
      return
8263 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8264 
    if self.beginIndex is not None:
8265 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8266 
      oprot.writeI64(self.beginIndex)
8267 
      oprot.writeFieldEnd()
8268 
    if self.totalItems is not None:
8269 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8270 
      oprot.writeI64(self.totalItems)
8271 
      oprot.writeFieldEnd()
8272 
    if self.brand is not None:
8273 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8274 
      oprot.writeString(self.brand)
8275 
      oprot.writeFieldEnd()
8276 
    if self.category is not None:
8277 
      oprot.writeFieldBegin('category', TType.I64, 4)
8278 
      oprot.writeI64(self.category)
8279 
      oprot.writeFieldEnd()
8280 
    oprot.writeFieldStop()
8281 
    oprot.writeStructEnd()
8282 
 
8283 
  def validate(self):
8284 
    return
8285 
 
8286 
 
8287 
  def __repr__(self):
8288 
    L = ['%s=%r' % (key, value)
8289 
      for key, value in self.__dict__.iteritems()]
8290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8291 
 
8292 
  def __eq__(self, other):
8293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8294 
 
8295 
  def __ne__(self, other):
8296 
    return not (self == other)
8297 
 
8298 
class getBestSellersCatalogIds_result:
8299 
  """
8300 
  Attributes:
8301 
   - success
8302 
   - cex
8303 
  """
8304 
 
8305 
  thrift_spec = (
8306 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8307 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8308 
  )
8309 
 
8310 
  def __init__(self, success=None, cex=None,):
8311 
    self.success = success
8312 
    self.cex = cex
8313 
 
8314 
  def read(self, iprot):
8315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8317 
      return
8318 
    iprot.readStructBegin()
8319 
    while True:
8320 
      (fname, ftype, fid) = iprot.readFieldBegin()
8321 
      if ftype == TType.STOP:
8322 
        break
8323 
      if fid == 0:
8324 
        if ftype == TType.LIST:
8325 
          self.success = []
7438 amit.gupta 8326 
          (_etype84, _size81) = iprot.readListBegin()
8327 
          for _i85 in xrange(_size81):
8328 
            _elem86 = iprot.readI64();
8329 
            self.success.append(_elem86)
5944 mandeep.dh 8330 
          iprot.readListEnd()
8331 
        else:
8332 
          iprot.skip(ftype)
8333 
      elif fid == 1:
8334 
        if ftype == TType.STRUCT:
8335 
          self.cex = CatalogServiceException()
8336 
          self.cex.read(iprot)
8337 
        else:
8338 
          iprot.skip(ftype)
8339 
      else:
8340 
        iprot.skip(ftype)
8341 
      iprot.readFieldEnd()
8342 
    iprot.readStructEnd()
8343 
 
8344 
  def write(self, oprot):
8345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8347 
      return
8348 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8349 
    if self.success is not None:
8350 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8351 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8352 
      for iter87 in self.success:
8353 
        oprot.writeI64(iter87)
5944 mandeep.dh 8354 
      oprot.writeListEnd()
8355 
      oprot.writeFieldEnd()
8356 
    if self.cex is not None:
8357 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8358 
      self.cex.write(oprot)
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 getBestSellersCount_args:
8379 
 
8380 
  thrift_spec = (
8381 
  )
8382 
 
8383 
  def read(self, iprot):
8384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8386 
      return
8387 
    iprot.readStructBegin()
8388 
    while True:
8389 
      (fname, ftype, fid) = iprot.readFieldBegin()
8390 
      if ftype == TType.STOP:
8391 
        break
8392 
      else:
8393 
        iprot.skip(ftype)
8394 
      iprot.readFieldEnd()
8395 
    iprot.readStructEnd()
8396 
 
8397 
  def write(self, oprot):
8398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8400 
      return
8401 
    oprot.writeStructBegin('getBestSellersCount_args')
8402 
    oprot.writeFieldStop()
8403 
    oprot.writeStructEnd()
8404 
 
8405 
  def validate(self):
8406 
    return
8407 
 
8408 
 
8409 
  def __repr__(self):
8410 
    L = ['%s=%r' % (key, value)
8411 
      for key, value in self.__dict__.iteritems()]
8412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8413 
 
8414 
  def __eq__(self, other):
8415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8416 
 
8417 
  def __ne__(self, other):
8418 
    return not (self == other)
8419 
 
8420 
class getBestSellersCount_result:
8421 
  """
8422 
  Attributes:
8423 
   - success
8424 
   - cex
8425 
  """
8426 
 
8427 
  thrift_spec = (
8428 
    (0, TType.I64, 'success', None, None, ), # 0
8429 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8430 
  )
8431 
 
8432 
  def __init__(self, success=None, cex=None,):
8433 
    self.success = success
8434 
    self.cex = cex
8435 
 
8436 
  def read(self, iprot):
8437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8439 
      return
8440 
    iprot.readStructBegin()
8441 
    while True:
8442 
      (fname, ftype, fid) = iprot.readFieldBegin()
8443 
      if ftype == TType.STOP:
8444 
        break
8445 
      if fid == 0:
8446 
        if ftype == TType.I64:
8447 
          self.success = iprot.readI64();
8448 
        else:
8449 
          iprot.skip(ftype)
8450 
      elif fid == 1:
8451 
        if ftype == TType.STRUCT:
8452 
          self.cex = CatalogServiceException()
8453 
          self.cex.read(iprot)
8454 
        else:
8455 
          iprot.skip(ftype)
8456 
      else:
8457 
        iprot.skip(ftype)
8458 
      iprot.readFieldEnd()
8459 
    iprot.readStructEnd()
8460 
 
8461 
  def write(self, oprot):
8462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8464 
      return
8465 
    oprot.writeStructBegin('getBestSellersCount_result')
8466 
    if self.success is not None:
8467 
      oprot.writeFieldBegin('success', TType.I64, 0)
8468 
      oprot.writeI64(self.success)
8469 
      oprot.writeFieldEnd()
8470 
    if self.cex is not None:
8471 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8472 
      self.cex.write(oprot)
8473 
      oprot.writeFieldEnd()
8474 
    oprot.writeFieldStop()
8475 
    oprot.writeStructEnd()
8476 
 
8477 
  def validate(self):
8478 
    return
8479 
 
8480 
 
8481 
  def __repr__(self):
8482 
    L = ['%s=%r' % (key, value)
8483 
      for key, value in self.__dict__.iteritems()]
8484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8485 
 
8486 
  def __eq__(self, other):
8487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8488 
 
8489 
  def __ne__(self, other):
8490 
    return not (self == other)
8491 
 
8492 
class getBestDeals_args:
8493 
 
8494 
  thrift_spec = (
8495 
  )
8496 
 
8497 
  def read(self, iprot):
8498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8500 
      return
8501 
    iprot.readStructBegin()
8502 
    while True:
8503 
      (fname, ftype, fid) = iprot.readFieldBegin()
8504 
      if ftype == TType.STOP:
8505 
        break
8506 
      else:
8507 
        iprot.skip(ftype)
8508 
      iprot.readFieldEnd()
8509 
    iprot.readStructEnd()
8510 
 
8511 
  def write(self, oprot):
8512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8514 
      return
8515 
    oprot.writeStructBegin('getBestDeals_args')
8516 
    oprot.writeFieldStop()
8517 
    oprot.writeStructEnd()
8518 
 
8519 
  def validate(self):
8520 
    return
8521 
 
8522 
 
8523 
  def __repr__(self):
8524 
    L = ['%s=%r' % (key, value)
8525 
      for key, value in self.__dict__.iteritems()]
8526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8527 
 
8528 
  def __eq__(self, other):
8529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8530 
 
8531 
  def __ne__(self, other):
8532 
    return not (self == other)
8533 
 
8534 
class getBestDeals_result:
8535 
  """
8536 
  Attributes:
8537 
   - success
8538 
   - isex
8539 
  """
8540 
 
8541 
  thrift_spec = (
8542 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8543 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8544 
  )
8545 
 
8546 
  def __init__(self, success=None, isex=None,):
8547 
    self.success = success
8548 
    self.isex = isex
8549 
 
8550 
  def read(self, iprot):
8551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8553 
      return
8554 
    iprot.readStructBegin()
8555 
    while True:
8556 
      (fname, ftype, fid) = iprot.readFieldBegin()
8557 
      if ftype == TType.STOP:
8558 
        break
8559 
      if fid == 0:
8560 
        if ftype == TType.LIST:
8561 
          self.success = []
7438 amit.gupta 8562 
          (_etype91, _size88) = iprot.readListBegin()
8563 
          for _i92 in xrange(_size88):
8564 
            _elem93 = Item()
8565 
            _elem93.read(iprot)
8566 
            self.success.append(_elem93)
5944 mandeep.dh 8567 
          iprot.readListEnd()
8568 
        else:
8569 
          iprot.skip(ftype)
8570 
      elif fid == 1:
8571 
        if ftype == TType.STRUCT:
8572 
          self.isex = CatalogServiceException()
8573 
          self.isex.read(iprot)
8574 
        else:
8575 
          iprot.skip(ftype)
8576 
      else:
8577 
        iprot.skip(ftype)
8578 
      iprot.readFieldEnd()
8579 
    iprot.readStructEnd()
8580 
 
8581 
  def write(self, oprot):
8582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8584 
      return
8585 
    oprot.writeStructBegin('getBestDeals_result')
8586 
    if self.success is not None:
8587 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8588 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8589 
      for iter94 in self.success:
8590 
        iter94.write(oprot)
5944 mandeep.dh 8591 
      oprot.writeListEnd()
8592 
      oprot.writeFieldEnd()
8593 
    if self.isex is not None:
8594 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8595 
      self.isex.write(oprot)
8596 
      oprot.writeFieldEnd()
8597 
    oprot.writeFieldStop()
8598 
    oprot.writeStructEnd()
8599 
 
8600 
  def validate(self):
8601 
    return
8602 
 
8603 
 
8604 
  def __repr__(self):
8605 
    L = ['%s=%r' % (key, value)
8606 
      for key, value in self.__dict__.iteritems()]
8607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8608 
 
8609 
  def __eq__(self, other):
8610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8611 
 
8612 
  def __ne__(self, other):
8613 
    return not (self == other)
8614 
 
8615 
class getBestDealsCatalogIds_args:
8616 
  """
8617 
  Attributes:
8618 
   - beginIndex
8619 
   - totalItems
8620 
   - brand
8621 
   - category
8622 
  """
8623 
 
8624 
  thrift_spec = (
8625 
    None, # 0
8626 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8627 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8628 
    (3, TType.STRING, 'brand', None, None, ), # 3
8629 
    (4, TType.I64, 'category', None, None, ), # 4
8630 
  )
8631 
 
8632 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8633 
    self.beginIndex = beginIndex
8634 
    self.totalItems = totalItems
8635 
    self.brand = brand
8636 
    self.category = category
8637 
 
8638 
  def read(self, iprot):
8639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8641 
      return
8642 
    iprot.readStructBegin()
8643 
    while True:
8644 
      (fname, ftype, fid) = iprot.readFieldBegin()
8645 
      if ftype == TType.STOP:
8646 
        break
8647 
      if fid == 1:
8648 
        if ftype == TType.I64:
8649 
          self.beginIndex = iprot.readI64();
8650 
        else:
8651 
          iprot.skip(ftype)
8652 
      elif fid == 2:
8653 
        if ftype == TType.I64:
8654 
          self.totalItems = iprot.readI64();
8655 
        else:
8656 
          iprot.skip(ftype)
8657 
      elif fid == 3:
8658 
        if ftype == TType.STRING:
8659 
          self.brand = iprot.readString();
8660 
        else:
8661 
          iprot.skip(ftype)
8662 
      elif fid == 4:
8663 
        if ftype == TType.I64:
8664 
          self.category = iprot.readI64();
8665 
        else:
8666 
          iprot.skip(ftype)
8667 
      else:
8668 
        iprot.skip(ftype)
8669 
      iprot.readFieldEnd()
8670 
    iprot.readStructEnd()
8671 
 
8672 
  def write(self, oprot):
8673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8675 
      return
8676 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8677 
    if self.beginIndex is not None:
8678 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8679 
      oprot.writeI64(self.beginIndex)
8680 
      oprot.writeFieldEnd()
8681 
    if self.totalItems is not None:
8682 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8683 
      oprot.writeI64(self.totalItems)
8684 
      oprot.writeFieldEnd()
8685 
    if self.brand is not None:
8686 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8687 
      oprot.writeString(self.brand)
8688 
      oprot.writeFieldEnd()
8689 
    if self.category is not None:
8690 
      oprot.writeFieldBegin('category', TType.I64, 4)
8691 
      oprot.writeI64(self.category)
8692 
      oprot.writeFieldEnd()
8693 
    oprot.writeFieldStop()
8694 
    oprot.writeStructEnd()
8695 
 
8696 
  def validate(self):
8697 
    return
8698 
 
8699 
 
8700 
  def __repr__(self):
8701 
    L = ['%s=%r' % (key, value)
8702 
      for key, value in self.__dict__.iteritems()]
8703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8704 
 
8705 
  def __eq__(self, other):
8706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8707 
 
8708 
  def __ne__(self, other):
8709 
    return not (self == other)
8710 
 
8711 
class getBestDealsCatalogIds_result:
8712 
  """
8713 
  Attributes:
8714 
   - success
8715 
   - cex
8716 
  """
8717 
 
8718 
  thrift_spec = (
8719 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8720 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8721 
  )
8722 
 
8723 
  def __init__(self, success=None, cex=None,):
8724 
    self.success = success
8725 
    self.cex = cex
8726 
 
8727 
  def read(self, iprot):
8728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8730 
      return
8731 
    iprot.readStructBegin()
8732 
    while True:
8733 
      (fname, ftype, fid) = iprot.readFieldBegin()
8734 
      if ftype == TType.STOP:
8735 
        break
8736 
      if fid == 0:
8737 
        if ftype == TType.LIST:
8738 
          self.success = []
7438 amit.gupta 8739 
          (_etype98, _size95) = iprot.readListBegin()
8740 
          for _i99 in xrange(_size95):
8741 
            _elem100 = iprot.readI64();
8742 
            self.success.append(_elem100)
5944 mandeep.dh 8743 
          iprot.readListEnd()
8744 
        else:
8745 
          iprot.skip(ftype)
8746 
      elif fid == 1:
8747 
        if ftype == TType.STRUCT:
8748 
          self.cex = CatalogServiceException()
8749 
          self.cex.read(iprot)
8750 
        else:
8751 
          iprot.skip(ftype)
8752 
      else:
8753 
        iprot.skip(ftype)
8754 
      iprot.readFieldEnd()
8755 
    iprot.readStructEnd()
8756 
 
8757 
  def write(self, oprot):
8758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8760 
      return
8761 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8762 
    if self.success is not None:
8763 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8764 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8765 
      for iter101 in self.success:
8766 
        oprot.writeI64(iter101)
5944 mandeep.dh 8767 
      oprot.writeListEnd()
8768 
      oprot.writeFieldEnd()
8769 
    if self.cex is not None:
8770 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8771 
      self.cex.write(oprot)
8772 
      oprot.writeFieldEnd()
8773 
    oprot.writeFieldStop()
8774 
    oprot.writeStructEnd()
8775 
 
8776 
  def validate(self):
8777 
    return
8778 
 
8779 
 
8780 
  def __repr__(self):
8781 
    L = ['%s=%r' % (key, value)
8782 
      for key, value in self.__dict__.iteritems()]
8783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8784 
 
8785 
  def __eq__(self, other):
8786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8787 
 
8788 
  def __ne__(self, other):
8789 
    return not (self == other)
8790 
 
8791 
class getBestDealsCount_args:
8792 
 
8793 
  thrift_spec = (
8794 
  )
8795 
 
8796 
  def read(self, iprot):
8797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8799 
      return
8800 
    iprot.readStructBegin()
8801 
    while True:
8802 
      (fname, ftype, fid) = iprot.readFieldBegin()
8803 
      if ftype == TType.STOP:
8804 
        break
8805 
      else:
8806 
        iprot.skip(ftype)
8807 
      iprot.readFieldEnd()
8808 
    iprot.readStructEnd()
8809 
 
8810 
  def write(self, oprot):
8811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8813 
      return
8814 
    oprot.writeStructBegin('getBestDealsCount_args')
8815 
    oprot.writeFieldStop()
8816 
    oprot.writeStructEnd()
8817 
 
8818 
  def validate(self):
8819 
    return
8820 
 
8821 
 
8822 
  def __repr__(self):
8823 
    L = ['%s=%r' % (key, value)
8824 
      for key, value in self.__dict__.iteritems()]
8825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8826 
 
8827 
  def __eq__(self, other):
8828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8829 
 
8830 
  def __ne__(self, other):
8831 
    return not (self == other)
8832 
 
8833 
class getBestDealsCount_result:
8834 
  """
8835 
  Attributes:
8836 
   - success
8837 
   - cex
8838 
  """
8839 
 
8840 
  thrift_spec = (
8841 
    (0, TType.I64, 'success', None, None, ), # 0
8842 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8843 
  )
8844 
 
8845 
  def __init__(self, success=None, cex=None,):
8846 
    self.success = success
8847 
    self.cex = cex
8848 
 
8849 
  def read(self, iprot):
8850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8852 
      return
8853 
    iprot.readStructBegin()
8854 
    while True:
8855 
      (fname, ftype, fid) = iprot.readFieldBegin()
8856 
      if ftype == TType.STOP:
8857 
        break
8858 
      if fid == 0:
8859 
        if ftype == TType.I64:
8860 
          self.success = iprot.readI64();
8861 
        else:
8862 
          iprot.skip(ftype)
8863 
      elif fid == 1:
8864 
        if ftype == TType.STRUCT:
8865 
          self.cex = CatalogServiceException()
8866 
          self.cex.read(iprot)
8867 
        else:
8868 
          iprot.skip(ftype)
8869 
      else:
8870 
        iprot.skip(ftype)
8871 
      iprot.readFieldEnd()
8872 
    iprot.readStructEnd()
8873 
 
8874 
  def write(self, oprot):
8875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8877 
      return
8878 
    oprot.writeStructBegin('getBestDealsCount_result')
8879 
    if self.success is not None:
8880 
      oprot.writeFieldBegin('success', TType.I64, 0)
8881 
      oprot.writeI64(self.success)
8882 
      oprot.writeFieldEnd()
8883 
    if self.cex is not None:
8884 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8885 
      self.cex.write(oprot)
8886 
      oprot.writeFieldEnd()
8887 
    oprot.writeFieldStop()
8888 
    oprot.writeStructEnd()
8889 
 
8890 
  def validate(self):
8891 
    return
8892 
 
8893 
 
8894 
  def __repr__(self):
8895 
    L = ['%s=%r' % (key, value)
8896 
      for key, value in self.__dict__.iteritems()]
8897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8898 
 
8899 
  def __eq__(self, other):
8900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8901 
 
8902 
  def __ne__(self, other):
8903 
    return not (self == other)
8904 
 
8905 
class getComingSoon_args:
8906 
 
8907 
  thrift_spec = (
8908 
  )
8909 
 
8910 
  def read(self, iprot):
8911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8913 
      return
8914 
    iprot.readStructBegin()
8915 
    while True:
8916 
      (fname, ftype, fid) = iprot.readFieldBegin()
8917 
      if ftype == TType.STOP:
8918 
        break
8919 
      else:
8920 
        iprot.skip(ftype)
8921 
      iprot.readFieldEnd()
8922 
    iprot.readStructEnd()
8923 
 
8924 
  def write(self, oprot):
8925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8927 
      return
8928 
    oprot.writeStructBegin('getComingSoon_args')
8929 
    oprot.writeFieldStop()
8930 
    oprot.writeStructEnd()
8931 
 
8932 
  def validate(self):
8933 
    return
8934 
 
8935 
 
8936 
  def __repr__(self):
8937 
    L = ['%s=%r' % (key, value)
8938 
      for key, value in self.__dict__.iteritems()]
8939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8940 
 
8941 
  def __eq__(self, other):
8942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8943 
 
8944 
  def __ne__(self, other):
8945 
    return not (self == other)
8946 
 
8947 
class getComingSoon_result:
8948 
  """
8949 
  Attributes:
8950 
   - success
8951 
   - isex
8952 
  """
8953 
 
8954 
  thrift_spec = (
8955 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8956 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8957 
  )
8958 
 
8959 
  def __init__(self, success=None, isex=None,):
8960 
    self.success = success
8961 
    self.isex = isex
8962 
 
8963 
  def read(self, iprot):
8964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8966 
      return
8967 
    iprot.readStructBegin()
8968 
    while True:
8969 
      (fname, ftype, fid) = iprot.readFieldBegin()
8970 
      if ftype == TType.STOP:
8971 
        break
8972 
      if fid == 0:
8973 
        if ftype == TType.LIST:
8974 
          self.success = []
7438 amit.gupta 8975 
          (_etype105, _size102) = iprot.readListBegin()
8976 
          for _i106 in xrange(_size102):
8977 
            _elem107 = Item()
8978 
            _elem107.read(iprot)
8979 
            self.success.append(_elem107)
5944 mandeep.dh 8980 
          iprot.readListEnd()
8981 
        else:
8982 
          iprot.skip(ftype)
8983 
      elif fid == 1:
8984 
        if ftype == TType.STRUCT:
8985 
          self.isex = CatalogServiceException()
8986 
          self.isex.read(iprot)
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      else:
8990 
        iprot.skip(ftype)
8991 
      iprot.readFieldEnd()
8992 
    iprot.readStructEnd()
8993 
 
8994 
  def write(self, oprot):
8995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8997 
      return
8998 
    oprot.writeStructBegin('getComingSoon_result')
8999 
    if self.success is not None:
9000 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9001 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9002 
      for iter108 in self.success:
9003 
        iter108.write(oprot)
5944 mandeep.dh 9004 
      oprot.writeListEnd()
9005 
      oprot.writeFieldEnd()
9006 
    if self.isex is not None:
9007 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9008 
      self.isex.write(oprot)
9009 
      oprot.writeFieldEnd()
9010 
    oprot.writeFieldStop()
9011 
    oprot.writeStructEnd()
9012 
 
9013 
  def validate(self):
9014 
    return
9015 
 
9016 
 
9017 
  def __repr__(self):
9018 
    L = ['%s=%r' % (key, value)
9019 
      for key, value in self.__dict__.iteritems()]
9020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9021 
 
9022 
  def __eq__(self, other):
9023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9024 
 
9025 
  def __ne__(self, other):
9026 
    return not (self == other)
9027 
 
9028 
class getComingSoonCatalogIds_args:
9029 
  """
9030 
  Attributes:
9031 
   - beginIndex
9032 
   - totalItems
9033 
   - brand
9034 
   - category
9035 
  """
9036 
 
9037 
  thrift_spec = (
9038 
    None, # 0
9039 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9040 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9041 
    (3, TType.STRING, 'brand', None, None, ), # 3
9042 
    (4, TType.I64, 'category', None, None, ), # 4
9043 
  )
9044 
 
9045 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9046 
    self.beginIndex = beginIndex
9047 
    self.totalItems = totalItems
9048 
    self.brand = brand
9049 
    self.category = category
9050 
 
9051 
  def read(self, iprot):
9052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9054 
      return
9055 
    iprot.readStructBegin()
9056 
    while True:
9057 
      (fname, ftype, fid) = iprot.readFieldBegin()
9058 
      if ftype == TType.STOP:
9059 
        break
9060 
      if fid == 1:
9061 
        if ftype == TType.I64:
9062 
          self.beginIndex = iprot.readI64();
9063 
        else:
9064 
          iprot.skip(ftype)
9065 
      elif fid == 2:
9066 
        if ftype == TType.I64:
9067 
          self.totalItems = iprot.readI64();
9068 
        else:
9069 
          iprot.skip(ftype)
9070 
      elif fid == 3:
9071 
        if ftype == TType.STRING:
9072 
          self.brand = iprot.readString();
9073 
        else:
9074 
          iprot.skip(ftype)
9075 
      elif fid == 4:
9076 
        if ftype == TType.I64:
9077 
          self.category = iprot.readI64();
9078 
        else:
9079 
          iprot.skip(ftype)
9080 
      else:
9081 
        iprot.skip(ftype)
9082 
      iprot.readFieldEnd()
9083 
    iprot.readStructEnd()
9084 
 
9085 
  def write(self, oprot):
9086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9088 
      return
9089 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9090 
    if self.beginIndex is not None:
9091 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9092 
      oprot.writeI64(self.beginIndex)
9093 
      oprot.writeFieldEnd()
9094 
    if self.totalItems is not None:
9095 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9096 
      oprot.writeI64(self.totalItems)
9097 
      oprot.writeFieldEnd()
9098 
    if self.brand is not None:
9099 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9100 
      oprot.writeString(self.brand)
9101 
      oprot.writeFieldEnd()
9102 
    if self.category is not None:
9103 
      oprot.writeFieldBegin('category', TType.I64, 4)
9104 
      oprot.writeI64(self.category)
9105 
      oprot.writeFieldEnd()
9106 
    oprot.writeFieldStop()
9107 
    oprot.writeStructEnd()
9108 
 
9109 
  def validate(self):
9110 
    return
9111 
 
9112 
 
9113 
  def __repr__(self):
9114 
    L = ['%s=%r' % (key, value)
9115 
      for key, value in self.__dict__.iteritems()]
9116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9117 
 
9118 
  def __eq__(self, other):
9119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9120 
 
9121 
  def __ne__(self, other):
9122 
    return not (self == other)
9123 
 
9124 
class getComingSoonCatalogIds_result:
9125 
  """
9126 
  Attributes:
9127 
   - success
9128 
   - cex
9129 
  """
9130 
 
9131 
  thrift_spec = (
9132 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9133 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9134 
  )
9135 
 
9136 
  def __init__(self, success=None, cex=None,):
9137 
    self.success = success
9138 
    self.cex = cex
9139 
 
9140 
  def read(self, iprot):
9141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9143 
      return
9144 
    iprot.readStructBegin()
9145 
    while True:
9146 
      (fname, ftype, fid) = iprot.readFieldBegin()
9147 
      if ftype == TType.STOP:
9148 
        break
9149 
      if fid == 0:
9150 
        if ftype == TType.LIST:
9151 
          self.success = []
7438 amit.gupta 9152 
          (_etype112, _size109) = iprot.readListBegin()
9153 
          for _i113 in xrange(_size109):
9154 
            _elem114 = iprot.readI64();
9155 
            self.success.append(_elem114)
5944 mandeep.dh 9156 
          iprot.readListEnd()
9157 
        else:
9158 
          iprot.skip(ftype)
9159 
      elif fid == 1:
9160 
        if ftype == TType.STRUCT:
9161 
          self.cex = CatalogServiceException()
9162 
          self.cex.read(iprot)
9163 
        else:
9164 
          iprot.skip(ftype)
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9175 
    if self.success is not None:
9176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9177 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9178 
      for iter115 in self.success:
9179 
        oprot.writeI64(iter115)
5944 mandeep.dh 9180 
      oprot.writeListEnd()
9181 
      oprot.writeFieldEnd()
9182 
    if self.cex is not None:
9183 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9184 
      self.cex.write(oprot)
9185 
      oprot.writeFieldEnd()
9186 
    oprot.writeFieldStop()
9187 
    oprot.writeStructEnd()
9188 
 
9189 
  def validate(self):
9190 
    return
9191 
 
9192 
 
9193 
  def __repr__(self):
9194 
    L = ['%s=%r' % (key, value)
9195 
      for key, value in self.__dict__.iteritems()]
9196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9197 
 
9198 
  def __eq__(self, other):
9199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9200 
 
9201 
  def __ne__(self, other):
9202 
    return not (self == other)
9203 
 
9204 
class getComingSoonCount_args:
9205 
 
9206 
  thrift_spec = (
9207 
  )
9208 
 
9209 
  def read(self, iprot):
9210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9212 
      return
9213 
    iprot.readStructBegin()
9214 
    while True:
9215 
      (fname, ftype, fid) = iprot.readFieldBegin()
9216 
      if ftype == TType.STOP:
9217 
        break
9218 
      else:
9219 
        iprot.skip(ftype)
9220 
      iprot.readFieldEnd()
9221 
    iprot.readStructEnd()
9222 
 
9223 
  def write(self, oprot):
9224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9226 
      return
9227 
    oprot.writeStructBegin('getComingSoonCount_args')
9228 
    oprot.writeFieldStop()
9229 
    oprot.writeStructEnd()
9230 
 
9231 
  def validate(self):
9232 
    return
9233 
 
9234 
 
9235 
  def __repr__(self):
9236 
    L = ['%s=%r' % (key, value)
9237 
      for key, value in self.__dict__.iteritems()]
9238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9239 
 
9240 
  def __eq__(self, other):
9241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9242 
 
9243 
  def __ne__(self, other):
9244 
    return not (self == other)
9245 
 
9246 
class getComingSoonCount_result:
9247 
  """
9248 
  Attributes:
9249 
   - success
9250 
   - cex
9251 
  """
9252 
 
9253 
  thrift_spec = (
9254 
    (0, TType.I64, 'success', None, None, ), # 0
9255 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9256 
  )
9257 
 
9258 
  def __init__(self, success=None, cex=None,):
9259 
    self.success = success
9260 
    self.cex = cex
9261 
 
9262 
  def read(self, iprot):
9263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9265 
      return
9266 
    iprot.readStructBegin()
9267 
    while True:
9268 
      (fname, ftype, fid) = iprot.readFieldBegin()
9269 
      if ftype == TType.STOP:
9270 
        break
9271 
      if fid == 0:
9272 
        if ftype == TType.I64:
9273 
          self.success = iprot.readI64();
9274 
        else:
9275 
          iprot.skip(ftype)
9276 
      elif fid == 1:
9277 
        if ftype == TType.STRUCT:
9278 
          self.cex = CatalogServiceException()
9279 
          self.cex.read(iprot)
9280 
        else:
9281 
          iprot.skip(ftype)
9282 
      else:
9283 
        iprot.skip(ftype)
9284 
      iprot.readFieldEnd()
9285 
    iprot.readStructEnd()
9286 
 
9287 
  def write(self, oprot):
9288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9290 
      return
9291 
    oprot.writeStructBegin('getComingSoonCount_result')
9292 
    if self.success is not None:
9293 
      oprot.writeFieldBegin('success', TType.I64, 0)
9294 
      oprot.writeI64(self.success)
9295 
      oprot.writeFieldEnd()
9296 
    if self.cex is not None:
9297 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9298 
      self.cex.write(oprot)
9299 
      oprot.writeFieldEnd()
9300 
    oprot.writeFieldStop()
9301 
    oprot.writeStructEnd()
9302 
 
9303 
  def validate(self):
9304 
    return
9305 
 
9306 
 
9307 
  def __repr__(self):
9308 
    L = ['%s=%r' % (key, value)
9309 
      for key, value in self.__dict__.iteritems()]
9310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9311 
 
9312 
  def __eq__(self, other):
9313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9314 
 
9315 
  def __ne__(self, other):
9316 
    return not (self == other)
9317 
 
9318 
class getLatestArrivals_args:
9319 
 
9320 
  thrift_spec = (
9321 
  )
9322 
 
9323 
  def read(self, iprot):
9324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9326 
      return
9327 
    iprot.readStructBegin()
9328 
    while True:
9329 
      (fname, ftype, fid) = iprot.readFieldBegin()
9330 
      if ftype == TType.STOP:
9331 
        break
9332 
      else:
9333 
        iprot.skip(ftype)
9334 
      iprot.readFieldEnd()
9335 
    iprot.readStructEnd()
9336 
 
9337 
  def write(self, oprot):
9338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9340 
      return
9341 
    oprot.writeStructBegin('getLatestArrivals_args')
9342 
    oprot.writeFieldStop()
9343 
    oprot.writeStructEnd()
9344 
 
9345 
  def validate(self):
9346 
    return
9347 
 
9348 
 
9349 
  def __repr__(self):
9350 
    L = ['%s=%r' % (key, value)
9351 
      for key, value in self.__dict__.iteritems()]
9352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9353 
 
9354 
  def __eq__(self, other):
9355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9356 
 
9357 
  def __ne__(self, other):
9358 
    return not (self == other)
9359 
 
9360 
class getLatestArrivals_result:
9361 
  """
9362 
  Attributes:
9363 
   - success
9364 
   - isex
9365 
  """
9366 
 
9367 
  thrift_spec = (
9368 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9369 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9370 
  )
9371 
 
9372 
  def __init__(self, success=None, isex=None,):
9373 
    self.success = success
9374 
    self.isex = isex
9375 
 
9376 
  def read(self, iprot):
9377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9379 
      return
9380 
    iprot.readStructBegin()
9381 
    while True:
9382 
      (fname, ftype, fid) = iprot.readFieldBegin()
9383 
      if ftype == TType.STOP:
9384 
        break
9385 
      if fid == 0:
9386 
        if ftype == TType.LIST:
9387 
          self.success = []
7438 amit.gupta 9388 
          (_etype119, _size116) = iprot.readListBegin()
9389 
          for _i120 in xrange(_size116):
9390 
            _elem121 = Item()
9391 
            _elem121.read(iprot)
9392 
            self.success.append(_elem121)
5944 mandeep.dh 9393 
          iprot.readListEnd()
9394 
        else:
9395 
          iprot.skip(ftype)
9396 
      elif fid == 1:
9397 
        if ftype == TType.STRUCT:
9398 
          self.isex = CatalogServiceException()
9399 
          self.isex.read(iprot)
9400 
        else:
9401 
          iprot.skip(ftype)
9402 
      else:
9403 
        iprot.skip(ftype)
9404 
      iprot.readFieldEnd()
9405 
    iprot.readStructEnd()
9406 
 
9407 
  def write(self, oprot):
9408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9410 
      return
9411 
    oprot.writeStructBegin('getLatestArrivals_result')
9412 
    if self.success is not None:
9413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9414 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9415 
      for iter122 in self.success:
9416 
        iter122.write(oprot)
5944 mandeep.dh 9417 
      oprot.writeListEnd()
9418 
      oprot.writeFieldEnd()
9419 
    if self.isex is not None:
9420 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9421 
      self.isex.write(oprot)
9422 
      oprot.writeFieldEnd()
9423 
    oprot.writeFieldStop()
9424 
    oprot.writeStructEnd()
9425 
 
9426 
  def validate(self):
9427 
    return
9428 
 
9429 
 
9430 
  def __repr__(self):
9431 
    L = ['%s=%r' % (key, value)
9432 
      for key, value in self.__dict__.iteritems()]
9433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9434 
 
9435 
  def __eq__(self, other):
9436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9437 
 
9438 
  def __ne__(self, other):
9439 
    return not (self == other)
9440 
 
9441 
class getLatestArrivalsCatalogIds_args:
9442 
  """
9443 
  Attributes:
9444 
   - beginIndex
9445 
   - totalItems
9446 
   - brand
9447 
   - categories
9448 
  """
9449 
 
9450 
  thrift_spec = (
9451 
    None, # 0
9452 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9453 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9454 
    (3, TType.STRING, 'brand', None, None, ), # 3
9455 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9456 
  )
9457 
 
9458 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9459 
    self.beginIndex = beginIndex
9460 
    self.totalItems = totalItems
9461 
    self.brand = brand
9462 
    self.categories = categories
9463 
 
9464 
  def read(self, iprot):
9465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9467 
      return
9468 
    iprot.readStructBegin()
9469 
    while True:
9470 
      (fname, ftype, fid) = iprot.readFieldBegin()
9471 
      if ftype == TType.STOP:
9472 
        break
9473 
      if fid == 1:
9474 
        if ftype == TType.I64:
9475 
          self.beginIndex = iprot.readI64();
9476 
        else:
9477 
          iprot.skip(ftype)
9478 
      elif fid == 2:
9479 
        if ftype == TType.I64:
9480 
          self.totalItems = iprot.readI64();
9481 
        else:
9482 
          iprot.skip(ftype)
9483 
      elif fid == 3:
9484 
        if ftype == TType.STRING:
9485 
          self.brand = iprot.readString();
9486 
        else:
9487 
          iprot.skip(ftype)
9488 
      elif fid == 4:
9489 
        if ftype == TType.LIST:
9490 
          self.categories = []
7438 amit.gupta 9491 
          (_etype126, _size123) = iprot.readListBegin()
9492 
          for _i127 in xrange(_size123):
9493 
            _elem128 = iprot.readI64();
9494 
            self.categories.append(_elem128)
5944 mandeep.dh 9495 
          iprot.readListEnd()
9496 
        else:
9497 
          iprot.skip(ftype)
9498 
      else:
9499 
        iprot.skip(ftype)
9500 
      iprot.readFieldEnd()
9501 
    iprot.readStructEnd()
9502 
 
9503 
  def write(self, oprot):
9504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9506 
      return
9507 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9508 
    if self.beginIndex is not None:
9509 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9510 
      oprot.writeI64(self.beginIndex)
9511 
      oprot.writeFieldEnd()
9512 
    if self.totalItems is not None:
9513 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9514 
      oprot.writeI64(self.totalItems)
9515 
      oprot.writeFieldEnd()
9516 
    if self.brand is not None:
9517 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9518 
      oprot.writeString(self.brand)
9519 
      oprot.writeFieldEnd()
9520 
    if self.categories is not None:
9521 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9522 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9523 
      for iter129 in self.categories:
9524 
        oprot.writeI64(iter129)
5944 mandeep.dh 9525 
      oprot.writeListEnd()
9526 
      oprot.writeFieldEnd()
9527 
    oprot.writeFieldStop()
9528 
    oprot.writeStructEnd()
9529 
 
9530 
  def validate(self):
9531 
    return
9532 
 
9533 
 
9534 
  def __repr__(self):
9535 
    L = ['%s=%r' % (key, value)
9536 
      for key, value in self.__dict__.iteritems()]
9537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9538 
 
9539 
  def __eq__(self, other):
9540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9541 
 
9542 
  def __ne__(self, other):
9543 
    return not (self == other)
9544 
 
9545 
class getLatestArrivalsCatalogIds_result:
9546 
  """
9547 
  Attributes:
9548 
   - success
9549 
   - cex
9550 
  """
9551 
 
9552 
  thrift_spec = (
9553 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9554 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9555 
  )
9556 
 
9557 
  def __init__(self, success=None, cex=None,):
9558 
    self.success = success
9559 
    self.cex = cex
9560 
 
9561 
  def read(self, iprot):
9562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9564 
      return
9565 
    iprot.readStructBegin()
9566 
    while True:
9567 
      (fname, ftype, fid) = iprot.readFieldBegin()
9568 
      if ftype == TType.STOP:
9569 
        break
9570 
      if fid == 0:
9571 
        if ftype == TType.LIST:
9572 
          self.success = []
7438 amit.gupta 9573 
          (_etype133, _size130) = iprot.readListBegin()
9574 
          for _i134 in xrange(_size130):
9575 
            _elem135 = iprot.readI64();
9576 
            self.success.append(_elem135)
5944 mandeep.dh 9577 
          iprot.readListEnd()
9578 
        else:
9579 
          iprot.skip(ftype)
9580 
      elif fid == 1:
9581 
        if ftype == TType.STRUCT:
9582 
          self.cex = CatalogServiceException()
9583 
          self.cex.read(iprot)
9584 
        else:
9585 
          iprot.skip(ftype)
9586 
      else:
9587 
        iprot.skip(ftype)
9588 
      iprot.readFieldEnd()
9589 
    iprot.readStructEnd()
9590 
 
9591 
  def write(self, oprot):
9592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9594 
      return
9595 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9596 
    if self.success is not None:
9597 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9598 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9599 
      for iter136 in self.success:
9600 
        oprot.writeI64(iter136)
5944 mandeep.dh 9601 
      oprot.writeListEnd()
9602 
      oprot.writeFieldEnd()
9603 
    if self.cex is not None:
9604 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9605 
      self.cex.write(oprot)
9606 
      oprot.writeFieldEnd()
9607 
    oprot.writeFieldStop()
9608 
    oprot.writeStructEnd()
9609 
 
9610 
  def validate(self):
9611 
    return
9612 
 
9613 
 
9614 
  def __repr__(self):
9615 
    L = ['%s=%r' % (key, value)
9616 
      for key, value in self.__dict__.iteritems()]
9617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9618 
 
9619 
  def __eq__(self, other):
9620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9621 
 
9622 
  def __ne__(self, other):
9623 
    return not (self == other)
9624 
 
9625 
class getLatestArrivalsCount_args:
9626 
 
9627 
  thrift_spec = (
9628 
  )
9629 
 
9630 
  def read(self, iprot):
9631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9633 
      return
9634 
    iprot.readStructBegin()
9635 
    while True:
9636 
      (fname, ftype, fid) = iprot.readFieldBegin()
9637 
      if ftype == TType.STOP:
9638 
        break
9639 
      else:
9640 
        iprot.skip(ftype)
9641 
      iprot.readFieldEnd()
9642 
    iprot.readStructEnd()
9643 
 
9644 
  def write(self, oprot):
9645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9647 
      return
9648 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9649 
    oprot.writeFieldStop()
9650 
    oprot.writeStructEnd()
9651 
 
9652 
  def validate(self):
9653 
    return
9654 
 
9655 
 
9656 
  def __repr__(self):
9657 
    L = ['%s=%r' % (key, value)
9658 
      for key, value in self.__dict__.iteritems()]
9659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9660 
 
9661 
  def __eq__(self, other):
9662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9663 
 
9664 
  def __ne__(self, other):
9665 
    return not (self == other)
9666 
 
9667 
class getLatestArrivalsCount_result:
9668 
  """
9669 
  Attributes:
9670 
   - success
9671 
   - cex
9672 
  """
9673 
 
9674 
  thrift_spec = (
9675 
    (0, TType.I64, 'success', None, None, ), # 0
9676 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9677 
  )
9678 
 
9679 
  def __init__(self, success=None, cex=None,):
9680 
    self.success = success
9681 
    self.cex = cex
9682 
 
9683 
  def read(self, iprot):
9684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9686 
      return
9687 
    iprot.readStructBegin()
9688 
    while True:
9689 
      (fname, ftype, fid) = iprot.readFieldBegin()
9690 
      if ftype == TType.STOP:
9691 
        break
9692 
      if fid == 0:
9693 
        if ftype == TType.I64:
9694 
          self.success = iprot.readI64();
9695 
        else:
9696 
          iprot.skip(ftype)
9697 
      elif fid == 1:
9698 
        if ftype == TType.STRUCT:
9699 
          self.cex = CatalogServiceException()
9700 
          self.cex.read(iprot)
9701 
        else:
9702 
          iprot.skip(ftype)
9703 
      else:
9704 
        iprot.skip(ftype)
9705 
      iprot.readFieldEnd()
9706 
    iprot.readStructEnd()
9707 
 
9708 
  def write(self, oprot):
9709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9711 
      return
9712 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9713 
    if self.success is not None:
9714 
      oprot.writeFieldBegin('success', TType.I64, 0)
9715 
      oprot.writeI64(self.success)
9716 
      oprot.writeFieldEnd()
9717 
    if self.cex is not None:
9718 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9719 
      self.cex.write(oprot)
9720 
      oprot.writeFieldEnd()
9721 
    oprot.writeFieldStop()
9722 
    oprot.writeStructEnd()
9723 
 
9724 
  def validate(self):
9725 
    return
9726 
 
9727 
 
9728 
  def __repr__(self):
9729 
    L = ['%s=%r' % (key, value)
9730 
      for key, value in self.__dict__.iteritems()]
9731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9732 
 
9733 
  def __eq__(self, other):
9734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9735 
 
9736 
  def __ne__(self, other):
9737 
    return not (self == other)
9738 
 
9739 
class generateNewEntityID_args:
9740 
 
9741 
  thrift_spec = (
9742 
  )
9743 
 
9744 
  def read(self, iprot):
9745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9747 
      return
9748 
    iprot.readStructBegin()
9749 
    while True:
9750 
      (fname, ftype, fid) = iprot.readFieldBegin()
9751 
      if ftype == TType.STOP:
9752 
        break
9753 
      else:
9754 
        iprot.skip(ftype)
9755 
      iprot.readFieldEnd()
9756 
    iprot.readStructEnd()
9757 
 
9758 
  def write(self, oprot):
9759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9761 
      return
9762 
    oprot.writeStructBegin('generateNewEntityID_args')
9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
9781 
class generateNewEntityID_result:
9782 
  """
9783 
  Attributes:
9784 
   - success
9785 
  """
9786 
 
9787 
  thrift_spec = (
9788 
    (0, TType.I64, 'success', None, None, ), # 0
9789 
  )
9790 
 
9791 
  def __init__(self, success=None,):
9792 
    self.success = success
9793 
 
9794 
  def read(self, iprot):
9795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9797 
      return
9798 
    iprot.readStructBegin()
9799 
    while True:
9800 
      (fname, ftype, fid) = iprot.readFieldBegin()
9801 
      if ftype == TType.STOP:
9802 
        break
9803 
      if fid == 0:
9804 
        if ftype == TType.I64:
9805 
          self.success = iprot.readI64();
9806 
        else:
9807 
          iprot.skip(ftype)
9808 
      else:
9809 
        iprot.skip(ftype)
9810 
      iprot.readFieldEnd()
9811 
    iprot.readStructEnd()
9812 
 
9813 
  def write(self, oprot):
9814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9816 
      return
9817 
    oprot.writeStructBegin('generateNewEntityID_result')
9818 
    if self.success is not None:
9819 
      oprot.writeFieldBegin('success', TType.I64, 0)
9820 
      oprot.writeI64(self.success)
9821 
      oprot.writeFieldEnd()
9822 
    oprot.writeFieldStop()
9823 
    oprot.writeStructEnd()
9824 
 
9825 
  def validate(self):
9826 
    return
9827 
 
9828 
 
9829 
  def __repr__(self):
9830 
    L = ['%s=%r' % (key, value)
9831 
      for key, value in self.__dict__.iteritems()]
9832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9833 
 
9834 
  def __eq__(self, other):
9835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9836 
 
9837 
  def __ne__(self, other):
9838 
    return not (self == other)
9839 
 
9840 
class addCategory_args:
9841 
  """
9842 
  Attributes:
9843 
   - category
9844 
  """
9845 
 
9846 
  thrift_spec = (
9847 
    None, # 0
9848 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9849 
  )
9850 
 
9851 
  def __init__(self, category=None,):
9852 
    self.category = category
9853 
 
9854 
  def read(self, iprot):
9855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9857 
      return
9858 
    iprot.readStructBegin()
9859 
    while True:
9860 
      (fname, ftype, fid) = iprot.readFieldBegin()
9861 
      if ftype == TType.STOP:
9862 
        break
9863 
      if fid == 1:
9864 
        if ftype == TType.STRUCT:
9865 
          self.category = Category()
9866 
          self.category.read(iprot)
9867 
        else:
9868 
          iprot.skip(ftype)
9869 
      else:
9870 
        iprot.skip(ftype)
9871 
      iprot.readFieldEnd()
9872 
    iprot.readStructEnd()
9873 
 
9874 
  def write(self, oprot):
9875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9877 
      return
9878 
    oprot.writeStructBegin('addCategory_args')
9879 
    if self.category is not None:
9880 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9881 
      self.category.write(oprot)
9882 
      oprot.writeFieldEnd()
9883 
    oprot.writeFieldStop()
9884 
    oprot.writeStructEnd()
9885 
 
9886 
  def validate(self):
9887 
    return
9888 
 
9889 
 
9890 
  def __repr__(self):
9891 
    L = ['%s=%r' % (key, value)
9892 
      for key, value in self.__dict__.iteritems()]
9893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9894 
 
9895 
  def __eq__(self, other):
9896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9897 
 
9898 
  def __ne__(self, other):
9899 
    return not (self == other)
9900 
 
9901 
class addCategory_result:
9902 
  """
9903 
  Attributes:
9904 
   - success
9905 
  """
9906 
 
9907 
  thrift_spec = (
9908 
    (0, TType.BOOL, 'success', None, None, ), # 0
9909 
  )
9910 
 
9911 
  def __init__(self, success=None,):
9912 
    self.success = success
9913 
 
9914 
  def read(self, iprot):
9915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9917 
      return
9918 
    iprot.readStructBegin()
9919 
    while True:
9920 
      (fname, ftype, fid) = iprot.readFieldBegin()
9921 
      if ftype == TType.STOP:
9922 
        break
9923 
      if fid == 0:
9924 
        if ftype == TType.BOOL:
9925 
          self.success = iprot.readBool();
9926 
        else:
9927 
          iprot.skip(ftype)
9928 
      else:
9929 
        iprot.skip(ftype)
9930 
      iprot.readFieldEnd()
9931 
    iprot.readStructEnd()
9932 
 
9933 
  def write(self, oprot):
9934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9936 
      return
9937 
    oprot.writeStructBegin('addCategory_result')
9938 
    if self.success is not None:
9939 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9940 
      oprot.writeBool(self.success)
9941 
      oprot.writeFieldEnd()
9942 
    oprot.writeFieldStop()
9943 
    oprot.writeStructEnd()
9944 
 
9945 
  def validate(self):
9946 
    return
9947 
 
9948 
 
9949 
  def __repr__(self):
9950 
    L = ['%s=%r' % (key, value)
9951 
      for key, value in self.__dict__.iteritems()]
9952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9953 
 
9954 
  def __eq__(self, other):
9955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9956 
 
9957 
  def __ne__(self, other):
9958 
    return not (self == other)
9959 
 
9960 
class getCategory_args:
9961 
  """
9962 
  Attributes:
9963 
   - id
9964 
  """
9965 
 
9966 
  thrift_spec = (
9967 
    None, # 0
9968 
    (1, TType.I64, 'id', None, None, ), # 1
9969 
  )
9970 
 
9971 
  def __init__(self, id=None,):
9972 
    self.id = id
9973 
 
9974 
  def read(self, iprot):
9975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9977 
      return
9978 
    iprot.readStructBegin()
9979 
    while True:
9980 
      (fname, ftype, fid) = iprot.readFieldBegin()
9981 
      if ftype == TType.STOP:
9982 
        break
9983 
      if fid == 1:
9984 
        if ftype == TType.I64:
9985 
          self.id = iprot.readI64();
9986 
        else:
9987 
          iprot.skip(ftype)
9988 
      else:
9989 
        iprot.skip(ftype)
9990 
      iprot.readFieldEnd()
9991 
    iprot.readStructEnd()
9992 
 
9993 
  def write(self, oprot):
9994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9996 
      return
9997 
    oprot.writeStructBegin('getCategory_args')
9998 
    if self.id is not None:
9999 
      oprot.writeFieldBegin('id', TType.I64, 1)
10000 
      oprot.writeI64(self.id)
10001 
      oprot.writeFieldEnd()
10002 
    oprot.writeFieldStop()
10003 
    oprot.writeStructEnd()
10004 
 
10005 
  def validate(self):
10006 
    return
10007 
 
10008 
 
10009 
  def __repr__(self):
10010 
    L = ['%s=%r' % (key, value)
10011 
      for key, value in self.__dict__.iteritems()]
10012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10013 
 
10014 
  def __eq__(self, other):
10015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10016 
 
10017 
  def __ne__(self, other):
10018 
    return not (self == other)
10019 
 
10020 
class getCategory_result:
10021 
  """
10022 
  Attributes:
10023 
   - success
10024 
  """
10025 
 
10026 
  thrift_spec = (
10027 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
10028 
  )
10029 
 
10030 
  def __init__(self, success=None,):
10031 
    self.success = success
10032 
 
10033 
  def read(self, iprot):
10034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10036 
      return
10037 
    iprot.readStructBegin()
10038 
    while True:
10039 
      (fname, ftype, fid) = iprot.readFieldBegin()
10040 
      if ftype == TType.STOP:
10041 
        break
10042 
      if fid == 0:
10043 
        if ftype == TType.STRUCT:
10044 
          self.success = Category()
10045 
          self.success.read(iprot)
10046 
        else:
10047 
          iprot.skip(ftype)
10048 
      else:
10049 
        iprot.skip(ftype)
10050 
      iprot.readFieldEnd()
10051 
    iprot.readStructEnd()
10052 
 
10053 
  def write(self, oprot):
10054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10056 
      return
10057 
    oprot.writeStructBegin('getCategory_result')
10058 
    if self.success is not None:
10059 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10060 
      self.success.write(oprot)
10061 
      oprot.writeFieldEnd()
10062 
    oprot.writeFieldStop()
10063 
    oprot.writeStructEnd()
10064 
 
10065 
  def validate(self):
10066 
    return
10067 
 
10068 
 
10069 
  def __repr__(self):
10070 
    L = ['%s=%r' % (key, value)
10071 
      for key, value in self.__dict__.iteritems()]
10072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10073 
 
10074 
  def __eq__(self, other):
10075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10076 
 
10077 
  def __ne__(self, other):
10078 
    return not (self == other)
10079 
 
10080 
class getAllCategories_args:
10081 
 
10082 
  thrift_spec = (
10083 
  )
10084 
 
10085 
  def read(self, iprot):
10086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10088 
      return
10089 
    iprot.readStructBegin()
10090 
    while True:
10091 
      (fname, ftype, fid) = iprot.readFieldBegin()
10092 
      if ftype == TType.STOP:
10093 
        break
10094 
      else:
10095 
        iprot.skip(ftype)
10096 
      iprot.readFieldEnd()
10097 
    iprot.readStructEnd()
10098 
 
10099 
  def write(self, oprot):
10100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10102 
      return
10103 
    oprot.writeStructBegin('getAllCategories_args')
10104 
    oprot.writeFieldStop()
10105 
    oprot.writeStructEnd()
10106 
 
10107 
  def validate(self):
10108 
    return
10109 
 
10110 
 
10111 
  def __repr__(self):
10112 
    L = ['%s=%r' % (key, value)
10113 
      for key, value in self.__dict__.iteritems()]
10114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10115 
 
10116 
  def __eq__(self, other):
10117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10118 
 
10119 
  def __ne__(self, other):
10120 
    return not (self == other)
10121 
 
10122 
class getAllCategories_result:
10123 
  """
10124 
  Attributes:
10125 
   - success
10126 
  """
10127 
 
10128 
  thrift_spec = (
10129 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10130 
  )
10131 
 
10132 
  def __init__(self, success=None,):
10133 
    self.success = success
10134 
 
10135 
  def read(self, iprot):
10136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10138 
      return
10139 
    iprot.readStructBegin()
10140 
    while True:
10141 
      (fname, ftype, fid) = iprot.readFieldBegin()
10142 
      if ftype == TType.STOP:
10143 
        break
10144 
      if fid == 0:
10145 
        if ftype == TType.LIST:
10146 
          self.success = []
7438 amit.gupta 10147 
          (_etype140, _size137) = iprot.readListBegin()
10148 
          for _i141 in xrange(_size137):
10149 
            _elem142 = Category()
10150 
            _elem142.read(iprot)
10151 
            self.success.append(_elem142)
5944 mandeep.dh 10152 
          iprot.readListEnd()
10153 
        else:
10154 
          iprot.skip(ftype)
10155 
      else:
10156 
        iprot.skip(ftype)
10157 
      iprot.readFieldEnd()
10158 
    iprot.readStructEnd()
10159 
 
10160 
  def write(self, oprot):
10161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10163 
      return
10164 
    oprot.writeStructBegin('getAllCategories_result')
10165 
    if self.success is not None:
10166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10168 
      for iter143 in self.success:
10169 
        iter143.write(oprot)
5944 mandeep.dh 10170 
      oprot.writeListEnd()
10171 
      oprot.writeFieldEnd()
10172 
    oprot.writeFieldStop()
10173 
    oprot.writeStructEnd()
10174 
 
10175 
  def validate(self):
10176 
    return
10177 
 
10178 
 
10179 
  def __repr__(self):
10180 
    L = ['%s=%r' % (key, value)
10181 
      for key, value in self.__dict__.iteritems()]
10182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10183 
 
10184 
  def __eq__(self, other):
10185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10186 
 
10187 
  def __ne__(self, other):
10188 
    return not (self == other)
10189 
 
10190 
class getAllSimilarItems_args:
10191 
  """
10192 
  Attributes:
10193 
   - itemId
10194 
  """
10195 
 
10196 
  thrift_spec = (
10197 
    None, # 0
10198 
    (1, TType.I64, 'itemId', None, None, ), # 1
10199 
  )
10200 
 
10201 
  def __init__(self, itemId=None,):
10202 
    self.itemId = itemId
10203 
 
10204 
  def read(self, iprot):
10205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10207 
      return
10208 
    iprot.readStructBegin()
10209 
    while True:
10210 
      (fname, ftype, fid) = iprot.readFieldBegin()
10211 
      if ftype == TType.STOP:
10212 
        break
10213 
      if fid == 1:
10214 
        if ftype == TType.I64:
10215 
          self.itemId = iprot.readI64();
10216 
        else:
10217 
          iprot.skip(ftype)
10218 
      else:
10219 
        iprot.skip(ftype)
10220 
      iprot.readFieldEnd()
10221 
    iprot.readStructEnd()
10222 
 
10223 
  def write(self, oprot):
10224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10226 
      return
10227 
    oprot.writeStructBegin('getAllSimilarItems_args')
10228 
    if self.itemId is not None:
10229 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10230 
      oprot.writeI64(self.itemId)
10231 
      oprot.writeFieldEnd()
10232 
    oprot.writeFieldStop()
10233 
    oprot.writeStructEnd()
10234 
 
10235 
  def validate(self):
10236 
    return
10237 
 
10238 
 
10239 
  def __repr__(self):
10240 
    L = ['%s=%r' % (key, value)
10241 
      for key, value in self.__dict__.iteritems()]
10242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10243 
 
10244 
  def __eq__(self, other):
10245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10246 
 
10247 
  def __ne__(self, other):
10248 
    return not (self == other)
10249 
 
10250 
class getAllSimilarItems_result:
10251 
  """
10252 
  Attributes:
10253 
   - success
10254 
  """
10255 
 
10256 
  thrift_spec = (
10257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10258 
  )
10259 
 
10260 
  def __init__(self, success=None,):
10261 
    self.success = success
10262 
 
10263 
  def read(self, iprot):
10264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10266 
      return
10267 
    iprot.readStructBegin()
10268 
    while True:
10269 
      (fname, ftype, fid) = iprot.readFieldBegin()
10270 
      if ftype == TType.STOP:
10271 
        break
10272 
      if fid == 0:
10273 
        if ftype == TType.LIST:
10274 
          self.success = []
7438 amit.gupta 10275 
          (_etype147, _size144) = iprot.readListBegin()
10276 
          for _i148 in xrange(_size144):
10277 
            _elem149 = Item()
10278 
            _elem149.read(iprot)
10279 
            self.success.append(_elem149)
5944 mandeep.dh 10280 
          iprot.readListEnd()
10281 
        else:
10282 
          iprot.skip(ftype)
10283 
      else:
10284 
        iprot.skip(ftype)
10285 
      iprot.readFieldEnd()
10286 
    iprot.readStructEnd()
10287 
 
10288 
  def write(self, oprot):
10289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10291 
      return
10292 
    oprot.writeStructBegin('getAllSimilarItems_result')
10293 
    if self.success is not None:
10294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10296 
      for iter150 in self.success:
10297 
        iter150.write(oprot)
5944 mandeep.dh 10298 
      oprot.writeListEnd()
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 addSimilarItem_args:
10319 
  """
10320 
  Attributes:
10321 
   - itemId
10322 
   - catalogItemId
10323 
  """
10324 
 
10325 
  thrift_spec = (
10326 
    None, # 0
10327 
    (1, TType.I64, 'itemId', None, None, ), # 1
10328 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10329 
  )
10330 
 
10331 
  def __init__(self, itemId=None, catalogItemId=None,):
10332 
    self.itemId = itemId
10333 
    self.catalogItemId = catalogItemId
10334 
 
10335 
  def read(self, iprot):
10336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10338 
      return
10339 
    iprot.readStructBegin()
10340 
    while True:
10341 
      (fname, ftype, fid) = iprot.readFieldBegin()
10342 
      if ftype == TType.STOP:
10343 
        break
10344 
      if fid == 1:
10345 
        if ftype == TType.I64:
10346 
          self.itemId = iprot.readI64();
10347 
        else:
10348 
          iprot.skip(ftype)
10349 
      elif fid == 2:
10350 
        if ftype == TType.I64:
10351 
          self.catalogItemId = iprot.readI64();
10352 
        else:
10353 
          iprot.skip(ftype)
10354 
      else:
10355 
        iprot.skip(ftype)
10356 
      iprot.readFieldEnd()
10357 
    iprot.readStructEnd()
10358 
 
10359 
  def write(self, oprot):
10360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10362 
      return
10363 
    oprot.writeStructBegin('addSimilarItem_args')
10364 
    if self.itemId is not None:
10365 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10366 
      oprot.writeI64(self.itemId)
10367 
      oprot.writeFieldEnd()
10368 
    if self.catalogItemId is not None:
10369 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10370 
      oprot.writeI64(self.catalogItemId)
10371 
      oprot.writeFieldEnd()
10372 
    oprot.writeFieldStop()
10373 
    oprot.writeStructEnd()
10374 
 
10375 
  def validate(self):
10376 
    return
10377 
 
10378 
 
10379 
  def __repr__(self):
10380 
    L = ['%s=%r' % (key, value)
10381 
      for key, value in self.__dict__.iteritems()]
10382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10383 
 
10384 
  def __eq__(self, other):
10385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10386 
 
10387 
  def __ne__(self, other):
10388 
    return not (self == other)
10389 
 
10390 
class addSimilarItem_result:
10391 
  """
10392 
  Attributes:
10393 
   - success
10394 
   - cex
10395 
  """
10396 
 
10397 
  thrift_spec = (
10398 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10399 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10400 
  )
10401 
 
10402 
  def __init__(self, success=None, cex=None,):
10403 
    self.success = success
10404 
    self.cex = cex
10405 
 
10406 
  def read(self, iprot):
10407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10409 
      return
10410 
    iprot.readStructBegin()
10411 
    while True:
10412 
      (fname, ftype, fid) = iprot.readFieldBegin()
10413 
      if ftype == TType.STOP:
10414 
        break
10415 
      if fid == 0:
10416 
        if ftype == TType.STRUCT:
10417 
          self.success = Item()
10418 
          self.success.read(iprot)
10419 
        else:
10420 
          iprot.skip(ftype)
10421 
      elif fid == 1:
10422 
        if ftype == TType.STRUCT:
10423 
          self.cex = CatalogServiceException()
10424 
          self.cex.read(iprot)
10425 
        else:
10426 
          iprot.skip(ftype)
10427 
      else:
10428 
        iprot.skip(ftype)
10429 
      iprot.readFieldEnd()
10430 
    iprot.readStructEnd()
10431 
 
10432 
  def write(self, oprot):
10433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10435 
      return
10436 
    oprot.writeStructBegin('addSimilarItem_result')
10437 
    if self.success is not None:
10438 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10439 
      self.success.write(oprot)
10440 
      oprot.writeFieldEnd()
10441 
    if self.cex is not None:
10442 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10443 
      self.cex.write(oprot)
10444 
      oprot.writeFieldEnd()
10445 
    oprot.writeFieldStop()
10446 
    oprot.writeStructEnd()
10447 
 
10448 
  def validate(self):
10449 
    return
10450 
 
10451 
 
10452 
  def __repr__(self):
10453 
    L = ['%s=%r' % (key, value)
10454 
      for key, value in self.__dict__.iteritems()]
10455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10456 
 
10457 
  def __eq__(self, other):
10458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10459 
 
10460 
  def __ne__(self, other):
10461 
    return not (self == other)
10462 
 
6512 kshitij.so 10463 
class addTag_args:
10464 
  """
10465 
  Attributes:
10466 
   - displayName
10467 
   - itemId
10468 
  """
10469 
 
10470 
  thrift_spec = (
10471 
    None, # 0
10472 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10473 
    (2, TType.I64, 'itemId', None, None, ), # 2
10474 
  )
10475 
 
10476 
  def __init__(self, displayName=None, itemId=None,):
10477 
    self.displayName = displayName
10478 
    self.itemId = itemId
10479 
 
10480 
  def read(self, iprot):
10481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10483 
      return
10484 
    iprot.readStructBegin()
10485 
    while True:
10486 
      (fname, ftype, fid) = iprot.readFieldBegin()
10487 
      if ftype == TType.STOP:
10488 
        break
10489 
      if fid == 1:
10490 
        if ftype == TType.STRING:
10491 
          self.displayName = iprot.readString();
10492 
        else:
10493 
          iprot.skip(ftype)
10494 
      elif fid == 2:
10495 
        if ftype == TType.I64:
10496 
          self.itemId = iprot.readI64();
10497 
        else:
10498 
          iprot.skip(ftype)
10499 
      else:
10500 
        iprot.skip(ftype)
10501 
      iprot.readFieldEnd()
10502 
    iprot.readStructEnd()
10503 
 
10504 
  def write(self, oprot):
10505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10507 
      return
10508 
    oprot.writeStructBegin('addTag_args')
10509 
    if self.displayName is not None:
10510 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10511 
      oprot.writeString(self.displayName)
10512 
      oprot.writeFieldEnd()
10513 
    if self.itemId is not None:
10514 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10515 
      oprot.writeI64(self.itemId)
10516 
      oprot.writeFieldEnd()
10517 
    oprot.writeFieldStop()
10518 
    oprot.writeStructEnd()
10519 
 
10520 
  def validate(self):
10521 
    return
10522 
 
10523 
 
10524 
  def __repr__(self):
10525 
    L = ['%s=%r' % (key, value)
10526 
      for key, value in self.__dict__.iteritems()]
10527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10528 
 
10529 
  def __eq__(self, other):
10530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10531 
 
10532 
  def __ne__(self, other):
10533 
    return not (self == other)
10534 
 
10535 
class addTag_result:
10536 
  """
10537 
  Attributes:
10538 
   - success
10539 
  """
10540 
 
10541 
  thrift_spec = (
10542 
    (0, TType.BOOL, 'success', None, None, ), # 0
10543 
  )
10544 
 
10545 
  def __init__(self, success=None,):
10546 
    self.success = success
10547 
 
10548 
  def read(self, iprot):
10549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10551 
      return
10552 
    iprot.readStructBegin()
10553 
    while True:
10554 
      (fname, ftype, fid) = iprot.readFieldBegin()
10555 
      if ftype == TType.STOP:
10556 
        break
10557 
      if fid == 0:
10558 
        if ftype == TType.BOOL:
10559 
          self.success = iprot.readBool();
10560 
        else:
10561 
          iprot.skip(ftype)
10562 
      else:
10563 
        iprot.skip(ftype)
10564 
      iprot.readFieldEnd()
10565 
    iprot.readStructEnd()
10566 
 
10567 
  def write(self, oprot):
10568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10570 
      return
10571 
    oprot.writeStructBegin('addTag_result')
10572 
    if self.success is not None:
10573 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10574 
      oprot.writeBool(self.success)
10575 
      oprot.writeFieldEnd()
10576 
    oprot.writeFieldStop()
10577 
    oprot.writeStructEnd()
10578 
 
10579 
  def validate(self):
10580 
    return
10581 
 
10582 
 
10583 
  def __repr__(self):
10584 
    L = ['%s=%r' % (key, value)
10585 
      for key, value in self.__dict__.iteritems()]
10586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10587 
 
10588 
  def __eq__(self, other):
10589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10590 
 
10591 
  def __ne__(self, other):
10592 
    return not (self == other)
10593 
 
10594 
class deleteEntityTag_args:
10595 
  """
10596 
  Attributes:
10597 
   - displayName
10598 
   - itemId
10599 
  """
10600 
 
10601 
  thrift_spec = (
10602 
    None, # 0
10603 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10604 
    (2, TType.I64, 'itemId', None, None, ), # 2
10605 
  )
10606 
 
10607 
  def __init__(self, displayName=None, itemId=None,):
10608 
    self.displayName = displayName
10609 
    self.itemId = itemId
10610 
 
10611 
  def read(self, iprot):
10612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10614 
      return
10615 
    iprot.readStructBegin()
10616 
    while True:
10617 
      (fname, ftype, fid) = iprot.readFieldBegin()
10618 
      if ftype == TType.STOP:
10619 
        break
10620 
      if fid == 1:
10621 
        if ftype == TType.STRING:
10622 
          self.displayName = iprot.readString();
10623 
        else:
10624 
          iprot.skip(ftype)
10625 
      elif fid == 2:
10626 
        if ftype == TType.I64:
10627 
          self.itemId = iprot.readI64();
10628 
        else:
10629 
          iprot.skip(ftype)
10630 
      else:
10631 
        iprot.skip(ftype)
10632 
      iprot.readFieldEnd()
10633 
    iprot.readStructEnd()
10634 
 
10635 
  def write(self, oprot):
10636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10638 
      return
10639 
    oprot.writeStructBegin('deleteEntityTag_args')
10640 
    if self.displayName is not None:
10641 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10642 
      oprot.writeString(self.displayName)
10643 
      oprot.writeFieldEnd()
10644 
    if self.itemId is not None:
10645 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10646 
      oprot.writeI64(self.itemId)
10647 
      oprot.writeFieldEnd()
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
10665 
 
10666 
class deleteEntityTag_result:
10667 
  """
10668 
  Attributes:
10669 
   - success
10670 
  """
10671 
 
10672 
  thrift_spec = (
10673 
    (0, TType.BOOL, 'success', None, None, ), # 0
10674 
  )
10675 
 
10676 
  def __init__(self, success=None,):
10677 
    self.success = success
10678 
 
10679 
  def read(self, iprot):
10680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10682 
      return
10683 
    iprot.readStructBegin()
10684 
    while True:
10685 
      (fname, ftype, fid) = iprot.readFieldBegin()
10686 
      if ftype == TType.STOP:
10687 
        break
10688 
      if fid == 0:
10689 
        if ftype == TType.BOOL:
10690 
          self.success = iprot.readBool();
10691 
        else:
10692 
          iprot.skip(ftype)
10693 
      else:
10694 
        iprot.skip(ftype)
10695 
      iprot.readFieldEnd()
10696 
    iprot.readStructEnd()
10697 
 
10698 
  def write(self, oprot):
10699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10701 
      return
10702 
    oprot.writeStructBegin('deleteEntityTag_result')
10703 
    if self.success is not None:
10704 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10705 
      oprot.writeBool(self.success)
10706 
      oprot.writeFieldEnd()
10707 
    oprot.writeFieldStop()
10708 
    oprot.writeStructEnd()
10709 
 
10710 
  def validate(self):
10711 
    return
10712 
 
10713 
 
10714 
  def __repr__(self):
10715 
    L = ['%s=%r' % (key, value)
10716 
      for key, value in self.__dict__.iteritems()]
10717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10718 
 
10719 
  def __eq__(self, other):
10720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10721 
 
10722 
  def __ne__(self, other):
10723 
    return not (self == other)
10724 
 
10725 
class deleteTag_args:
10726 
  """
10727 
  Attributes:
10728 
   - displayName
10729 
  """
10730 
 
10731 
  thrift_spec = (
10732 
    None, # 0
10733 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10734 
  )
10735 
 
10736 
  def __init__(self, displayName=None,):
10737 
    self.displayName = displayName
10738 
 
10739 
  def read(self, iprot):
10740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10742 
      return
10743 
    iprot.readStructBegin()
10744 
    while True:
10745 
      (fname, ftype, fid) = iprot.readFieldBegin()
10746 
      if ftype == TType.STOP:
10747 
        break
10748 
      if fid == 1:
10749 
        if ftype == TType.STRING:
10750 
          self.displayName = iprot.readString();
10751 
        else:
10752 
          iprot.skip(ftype)
10753 
      else:
10754 
        iprot.skip(ftype)
10755 
      iprot.readFieldEnd()
10756 
    iprot.readStructEnd()
10757 
 
10758 
  def write(self, oprot):
10759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10761 
      return
10762 
    oprot.writeStructBegin('deleteTag_args')
10763 
    if self.displayName is not None:
10764 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10765 
      oprot.writeString(self.displayName)
10766 
      oprot.writeFieldEnd()
10767 
    oprot.writeFieldStop()
10768 
    oprot.writeStructEnd()
10769 
 
10770 
  def validate(self):
10771 
    return
10772 
 
10773 
 
10774 
  def __repr__(self):
10775 
    L = ['%s=%r' % (key, value)
10776 
      for key, value in self.__dict__.iteritems()]
10777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10778 
 
10779 
  def __eq__(self, other):
10780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10781 
 
10782 
  def __ne__(self, other):
10783 
    return not (self == other)
10784 
 
10785 
class deleteTag_result:
10786 
  """
10787 
  Attributes:
10788 
   - success
10789 
  """
10790 
 
10791 
  thrift_spec = (
10792 
    (0, TType.BOOL, 'success', None, None, ), # 0
10793 
  )
10794 
 
10795 
  def __init__(self, success=None,):
10796 
    self.success = success
10797 
 
10798 
  def read(self, iprot):
10799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10801 
      return
10802 
    iprot.readStructBegin()
10803 
    while True:
10804 
      (fname, ftype, fid) = iprot.readFieldBegin()
10805 
      if ftype == TType.STOP:
10806 
        break
10807 
      if fid == 0:
10808 
        if ftype == TType.BOOL:
10809 
          self.success = iprot.readBool();
10810 
        else:
10811 
          iprot.skip(ftype)
10812 
      else:
10813 
        iprot.skip(ftype)
10814 
      iprot.readFieldEnd()
10815 
    iprot.readStructEnd()
10816 
 
10817 
  def write(self, oprot):
10818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10820 
      return
10821 
    oprot.writeStructBegin('deleteTag_result')
10822 
    if self.success is not None:
10823 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10824 
      oprot.writeBool(self.success)
10825 
      oprot.writeFieldEnd()
10826 
    oprot.writeFieldStop()
10827 
    oprot.writeStructEnd()
10828 
 
10829 
  def validate(self):
10830 
    return
10831 
 
10832 
 
10833 
  def __repr__(self):
10834 
    L = ['%s=%r' % (key, value)
10835 
      for key, value in self.__dict__.iteritems()]
10836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10837 
 
10838 
  def __eq__(self, other):
10839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10840 
 
10841 
  def __ne__(self, other):
10842 
    return not (self == other)
10843 
 
10844 
class getAllTags_args:
10845 
 
10846 
  thrift_spec = (
10847 
  )
10848 
 
10849 
  def read(self, iprot):
10850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10852 
      return
10853 
    iprot.readStructBegin()
10854 
    while True:
10855 
      (fname, ftype, fid) = iprot.readFieldBegin()
10856 
      if ftype == TType.STOP:
10857 
        break
10858 
      else:
10859 
        iprot.skip(ftype)
10860 
      iprot.readFieldEnd()
10861 
    iprot.readStructEnd()
10862 
 
10863 
  def write(self, oprot):
10864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10866 
      return
10867 
    oprot.writeStructBegin('getAllTags_args')
10868 
    oprot.writeFieldStop()
10869 
    oprot.writeStructEnd()
10870 
 
10871 
  def validate(self):
10872 
    return
10873 
 
10874 
 
10875 
  def __repr__(self):
10876 
    L = ['%s=%r' % (key, value)
10877 
      for key, value in self.__dict__.iteritems()]
10878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10879 
 
10880 
  def __eq__(self, other):
10881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10882 
 
10883 
  def __ne__(self, other):
10884 
    return not (self == other)
10885 
 
10886 
class getAllTags_result:
10887 
  """
10888 
  Attributes:
10889 
   - success
10890 
  """
10891 
 
10892 
  thrift_spec = (
10893 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10894 
  )
10895 
 
10896 
  def __init__(self, success=None,):
10897 
    self.success = success
10898 
 
10899 
  def read(self, iprot):
10900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10902 
      return
10903 
    iprot.readStructBegin()
10904 
    while True:
10905 
      (fname, ftype, fid) = iprot.readFieldBegin()
10906 
      if ftype == TType.STOP:
10907 
        break
10908 
      if fid == 0:
10909 
        if ftype == TType.LIST:
10910 
          self.success = []
7438 amit.gupta 10911 
          (_etype154, _size151) = iprot.readListBegin()
10912 
          for _i155 in xrange(_size151):
10913 
            _elem156 = iprot.readString();
10914 
            self.success.append(_elem156)
6512 kshitij.so 10915 
          iprot.readListEnd()
10916 
        else:
10917 
          iprot.skip(ftype)
10918 
      else:
10919 
        iprot.skip(ftype)
10920 
      iprot.readFieldEnd()
10921 
    iprot.readStructEnd()
10922 
 
10923 
  def write(self, oprot):
10924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10926 
      return
10927 
    oprot.writeStructBegin('getAllTags_result')
10928 
    if self.success is not None:
10929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10930 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10931 
      for iter157 in self.success:
10932 
        oprot.writeString(iter157)
6512 kshitij.so 10933 
      oprot.writeListEnd()
10934 
      oprot.writeFieldEnd()
10935 
    oprot.writeFieldStop()
10936 
    oprot.writeStructEnd()
10937 
 
10938 
  def validate(self):
10939 
    return
10940 
 
10941 
 
10942 
  def __repr__(self):
10943 
    L = ['%s=%r' % (key, value)
10944 
      for key, value in self.__dict__.iteritems()]
10945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10946 
 
10947 
  def __eq__(self, other):
10948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10949 
 
10950 
  def __ne__(self, other):
10951 
    return not (self == other)
10952 
 
10953 
class getAllEntitiesByTagName_args:
10954 
  """
10955 
  Attributes:
10956 
   - displayName
10957 
  """
10958 
 
10959 
  thrift_spec = (
10960 
    None, # 0
10961 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10962 
  )
10963 
 
10964 
  def __init__(self, displayName=None,):
10965 
    self.displayName = displayName
10966 
 
10967 
  def read(self, iprot):
10968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10970 
      return
10971 
    iprot.readStructBegin()
10972 
    while True:
10973 
      (fname, ftype, fid) = iprot.readFieldBegin()
10974 
      if ftype == TType.STOP:
10975 
        break
10976 
      if fid == 1:
10977 
        if ftype == TType.STRING:
10978 
          self.displayName = iprot.readString();
10979 
        else:
10980 
          iprot.skip(ftype)
10981 
      else:
10982 
        iprot.skip(ftype)
10983 
      iprot.readFieldEnd()
10984 
    iprot.readStructEnd()
10985 
 
10986 
  def write(self, oprot):
10987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10989 
      return
10990 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10991 
    if self.displayName is not None:
10992 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10993 
      oprot.writeString(self.displayName)
10994 
      oprot.writeFieldEnd()
10995 
    oprot.writeFieldStop()
10996 
    oprot.writeStructEnd()
10997 
 
10998 
  def validate(self):
10999 
    return
11000 
 
11001 
 
11002 
  def __repr__(self):
11003 
    L = ['%s=%r' % (key, value)
11004 
      for key, value in self.__dict__.iteritems()]
11005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11006 
 
11007 
  def __eq__(self, other):
11008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11009 
 
11010 
  def __ne__(self, other):
11011 
    return not (self == other)
11012 
 
11013 
class getAllEntitiesByTagName_result:
11014 
  """
11015 
  Attributes:
11016 
   - success
11017 
  """
11018 
 
11019 
  thrift_spec = (
11020 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11021 
  )
11022 
 
11023 
  def __init__(self, success=None,):
11024 
    self.success = success
11025 
 
11026 
  def read(self, iprot):
11027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11029 
      return
11030 
    iprot.readStructBegin()
11031 
    while True:
11032 
      (fname, ftype, fid) = iprot.readFieldBegin()
11033 
      if ftype == TType.STOP:
11034 
        break
11035 
      if fid == 0:
11036 
        if ftype == TType.LIST:
11037 
          self.success = []
7438 amit.gupta 11038 
          (_etype161, _size158) = iprot.readListBegin()
11039 
          for _i162 in xrange(_size158):
11040 
            _elem163 = iprot.readI64();
11041 
            self.success.append(_elem163)
6512 kshitij.so 11042 
          iprot.readListEnd()
11043 
        else:
11044 
          iprot.skip(ftype)
11045 
      else:
11046 
        iprot.skip(ftype)
11047 
      iprot.readFieldEnd()
11048 
    iprot.readStructEnd()
11049 
 
11050 
  def write(self, oprot):
11051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11053 
      return
11054 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
11055 
    if self.success is not None:
11056 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11057 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 11058 
      for iter164 in self.success:
11059 
        oprot.writeI64(iter164)
6512 kshitij.so 11060 
      oprot.writeListEnd()
11061 
      oprot.writeFieldEnd()
11062 
    oprot.writeFieldStop()
11063 
    oprot.writeStructEnd()
11064 
 
11065 
  def validate(self):
11066 
    return
11067 
 
11068 
 
11069 
  def __repr__(self):
11070 
    L = ['%s=%r' % (key, value)
11071 
      for key, value in self.__dict__.iteritems()]
11072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11073 
 
11074 
  def __eq__(self, other):
11075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11076 
 
11077 
  def __ne__(self, other):
11078 
    return not (self == other)
11079 
 
6845 amit.gupta 11080 
class getAllEntityTags_args:
11081 
 
11082 
  thrift_spec = (
11083 
  )
11084 
 
11085 
  def read(self, iprot):
11086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11088 
      return
11089 
    iprot.readStructBegin()
11090 
    while True:
11091 
      (fname, ftype, fid) = iprot.readFieldBegin()
11092 
      if ftype == TType.STOP:
11093 
        break
11094 
      else:
11095 
        iprot.skip(ftype)
11096 
      iprot.readFieldEnd()
11097 
    iprot.readStructEnd()
11098 
 
11099 
  def write(self, oprot):
11100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11102 
      return
11103 
    oprot.writeStructBegin('getAllEntityTags_args')
11104 
    oprot.writeFieldStop()
11105 
    oprot.writeStructEnd()
11106 
 
11107 
  def validate(self):
11108 
    return
11109 
 
11110 
 
11111 
  def __repr__(self):
11112 
    L = ['%s=%r' % (key, value)
11113 
      for key, value in self.__dict__.iteritems()]
11114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11115 
 
11116 
  def __eq__(self, other):
11117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11118 
 
11119 
  def __ne__(self, other):
11120 
    return not (self == other)
11121 
 
11122 
class getAllEntityTags_result:
11123 
  """
11124 
  Attributes:
11125 
   - success
11126 
  """
11127 
 
11128 
  thrift_spec = (
11129 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11130 
  )
11131 
 
11132 
  def __init__(self, success=None,):
11133 
    self.success = success
11134 
 
11135 
  def read(self, iprot):
11136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11138 
      return
11139 
    iprot.readStructBegin()
11140 
    while True:
11141 
      (fname, ftype, fid) = iprot.readFieldBegin()
11142 
      if ftype == TType.STOP:
11143 
        break
11144 
      if fid == 0:
11145 
        if ftype == TType.MAP:
11146 
          self.success = {}
7438 amit.gupta 11147 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
11148 
          for _i169 in xrange(_size165):
11149 
            _key170 = iprot.readI64();
11150 
            _val171 = []
11151 
            (_etype175, _size172) = iprot.readListBegin()
11152 
            for _i176 in xrange(_size172):
11153 
              _elem177 = iprot.readString();
11154 
              _val171.append(_elem177)
6845 amit.gupta 11155 
            iprot.readListEnd()
7438 amit.gupta 11156 
            self.success[_key170] = _val171
6845 amit.gupta 11157 
          iprot.readMapEnd()
11158 
        else:
11159 
          iprot.skip(ftype)
11160 
      else:
11161 
        iprot.skip(ftype)
11162 
      iprot.readFieldEnd()
11163 
    iprot.readStructEnd()
11164 
 
11165 
  def write(self, oprot):
11166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11168 
      return
11169 
    oprot.writeStructBegin('getAllEntityTags_result')
11170 
    if self.success is not None:
11171 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11172 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 11173 
      for kiter178,viter179 in self.success.items():
11174 
        oprot.writeI64(kiter178)
11175 
        oprot.writeListBegin(TType.STRING, len(viter179))
11176 
        for iter180 in viter179:
11177 
          oprot.writeString(iter180)
6845 amit.gupta 11178 
        oprot.writeListEnd()
11179 
      oprot.writeMapEnd()
11180 
      oprot.writeFieldEnd()
11181 
    oprot.writeFieldStop()
11182 
    oprot.writeStructEnd()
11183 
 
11184 
  def validate(self):
11185 
    return
11186 
 
11187 
 
11188 
  def __repr__(self):
11189 
    L = ['%s=%r' % (key, value)
11190 
      for key, value in self.__dict__.iteritems()]
11191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11192 
 
11193 
  def __eq__(self, other):
11194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11195 
 
11196 
  def __ne__(self, other):
11197 
    return not (self == other)
11198 
 
6850 kshitij.so 11199 
class addBanner_args:
11200 
  """
11201 
  Attributes:
11202 
   - bannerName
11203 
   - imageName
11204 
   - link
11205 
   - priority
11206 
   - isActive
11207 
   - hasMap
11208 
  """
11209 
 
11210 
  thrift_spec = (
11211 
    None, # 0
11212 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11213 
    (2, TType.STRING, 'imageName', None, None, ), # 2
11214 
    (3, TType.STRING, 'link', None, None, ), # 3
11215 
    (4, TType.I64, 'priority', None, None, ), # 4
11216 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
11217 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
11218 
  )
11219 
 
11220 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
11221 
    self.bannerName = bannerName
11222 
    self.imageName = imageName
11223 
    self.link = link
11224 
    self.priority = priority
11225 
    self.isActive = isActive
11226 
    self.hasMap = hasMap
11227 
 
11228 
  def read(self, iprot):
11229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11231 
      return
11232 
    iprot.readStructBegin()
11233 
    while True:
11234 
      (fname, ftype, fid) = iprot.readFieldBegin()
11235 
      if ftype == TType.STOP:
11236 
        break
11237 
      if fid == 1:
11238 
        if ftype == TType.STRING:
11239 
          self.bannerName = iprot.readString();
11240 
        else:
11241 
          iprot.skip(ftype)
11242 
      elif fid == 2:
11243 
        if ftype == TType.STRING:
11244 
          self.imageName = iprot.readString();
11245 
        else:
11246 
          iprot.skip(ftype)
11247 
      elif fid == 3:
11248 
        if ftype == TType.STRING:
11249 
          self.link = iprot.readString();
11250 
        else:
11251 
          iprot.skip(ftype)
11252 
      elif fid == 4:
11253 
        if ftype == TType.I64:
11254 
          self.priority = iprot.readI64();
11255 
        else:
11256 
          iprot.skip(ftype)
11257 
      elif fid == 5:
11258 
        if ftype == TType.BOOL:
11259 
          self.isActive = iprot.readBool();
11260 
        else:
11261 
          iprot.skip(ftype)
11262 
      elif fid == 6:
11263 
        if ftype == TType.BOOL:
11264 
          self.hasMap = iprot.readBool();
11265 
        else:
11266 
          iprot.skip(ftype)
11267 
      else:
11268 
        iprot.skip(ftype)
11269 
      iprot.readFieldEnd()
11270 
    iprot.readStructEnd()
11271 
 
11272 
  def write(self, oprot):
11273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11275 
      return
11276 
    oprot.writeStructBegin('addBanner_args')
11277 
    if self.bannerName is not None:
11278 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11279 
      oprot.writeString(self.bannerName)
11280 
      oprot.writeFieldEnd()
11281 
    if self.imageName is not None:
11282 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
11283 
      oprot.writeString(self.imageName)
11284 
      oprot.writeFieldEnd()
11285 
    if self.link is not None:
11286 
      oprot.writeFieldBegin('link', TType.STRING, 3)
11287 
      oprot.writeString(self.link)
11288 
      oprot.writeFieldEnd()
11289 
    if self.priority is not None:
11290 
      oprot.writeFieldBegin('priority', TType.I64, 4)
11291 
      oprot.writeI64(self.priority)
11292 
      oprot.writeFieldEnd()
11293 
    if self.isActive is not None:
11294 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
11295 
      oprot.writeBool(self.isActive)
11296 
      oprot.writeFieldEnd()
11297 
    if self.hasMap is not None:
11298 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
11299 
      oprot.writeBool(self.hasMap)
11300 
      oprot.writeFieldEnd()
11301 
    oprot.writeFieldStop()
11302 
    oprot.writeStructEnd()
11303 
 
11304 
  def validate(self):
11305 
    return
11306 
 
11307 
 
11308 
  def __repr__(self):
11309 
    L = ['%s=%r' % (key, value)
11310 
      for key, value in self.__dict__.iteritems()]
11311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11312 
 
11313 
  def __eq__(self, other):
11314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11315 
 
11316 
  def __ne__(self, other):
11317 
    return not (self == other)
11318 
 
11319 
class addBanner_result:
11320 
  """
11321 
  Attributes:
11322 
   - success
11323 
  """
11324 
 
11325 
  thrift_spec = (
11326 
    (0, TType.BOOL, 'success', None, None, ), # 0
11327 
  )
11328 
 
11329 
  def __init__(self, success=None,):
11330 
    self.success = success
11331 
 
11332 
  def read(self, iprot):
11333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11335 
      return
11336 
    iprot.readStructBegin()
11337 
    while True:
11338 
      (fname, ftype, fid) = iprot.readFieldBegin()
11339 
      if ftype == TType.STOP:
11340 
        break
11341 
      if fid == 0:
11342 
        if ftype == TType.BOOL:
11343 
          self.success = iprot.readBool();
11344 
        else:
11345 
          iprot.skip(ftype)
11346 
      else:
11347 
        iprot.skip(ftype)
11348 
      iprot.readFieldEnd()
11349 
    iprot.readStructEnd()
11350 
 
11351 
  def write(self, oprot):
11352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11354 
      return
11355 
    oprot.writeStructBegin('addBanner_result')
11356 
    if self.success is not None:
11357 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11358 
      oprot.writeBool(self.success)
11359 
      oprot.writeFieldEnd()
11360 
    oprot.writeFieldStop()
11361 
    oprot.writeStructEnd()
11362 
 
11363 
  def validate(self):
11364 
    return
11365 
 
11366 
 
11367 
  def __repr__(self):
11368 
    L = ['%s=%r' % (key, value)
11369 
      for key, value in self.__dict__.iteritems()]
11370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11371 
 
11372 
  def __eq__(self, other):
11373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11374 
 
11375 
  def __ne__(self, other):
11376 
    return not (self == other)
11377 
 
11378 
class getAllBanners_args:
11379 
 
11380 
  thrift_spec = (
11381 
  )
11382 
 
11383 
  def read(self, iprot):
11384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11386 
      return
11387 
    iprot.readStructBegin()
11388 
    while True:
11389 
      (fname, ftype, fid) = iprot.readFieldBegin()
11390 
      if ftype == TType.STOP:
11391 
        break
11392 
      else:
11393 
        iprot.skip(ftype)
11394 
      iprot.readFieldEnd()
11395 
    iprot.readStructEnd()
11396 
 
11397 
  def write(self, oprot):
11398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11400 
      return
11401 
    oprot.writeStructBegin('getAllBanners_args')
11402 
    oprot.writeFieldStop()
11403 
    oprot.writeStructEnd()
11404 
 
11405 
  def validate(self):
11406 
    return
11407 
 
11408 
 
11409 
  def __repr__(self):
11410 
    L = ['%s=%r' % (key, value)
11411 
      for key, value in self.__dict__.iteritems()]
11412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11413 
 
11414 
  def __eq__(self, other):
11415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11416 
 
11417 
  def __ne__(self, other):
11418 
    return not (self == other)
11419 
 
11420 
class getAllBanners_result:
11421 
  """
11422 
  Attributes:
11423 
   - success
11424 
  """
11425 
 
11426 
  thrift_spec = (
11427 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11428 
  )
11429 
 
11430 
  def __init__(self, success=None,):
11431 
    self.success = success
11432 
 
11433 
  def read(self, iprot):
11434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11436 
      return
11437 
    iprot.readStructBegin()
11438 
    while True:
11439 
      (fname, ftype, fid) = iprot.readFieldBegin()
11440 
      if ftype == TType.STOP:
11441 
        break
11442 
      if fid == 0:
11443 
        if ftype == TType.LIST:
11444 
          self.success = []
7438 amit.gupta 11445 
          (_etype184, _size181) = iprot.readListBegin()
11446 
          for _i185 in xrange(_size181):
11447 
            _elem186 = iprot.readString();
11448 
            self.success.append(_elem186)
6850 kshitij.so 11449 
          iprot.readListEnd()
11450 
        else:
11451 
          iprot.skip(ftype)
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('getAllBanners_result')
11462 
    if self.success is not None:
11463 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11464 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11465 
      for iter187 in self.success:
11466 
        oprot.writeString(iter187)
6850 kshitij.so 11467 
      oprot.writeListEnd()
11468 
      oprot.writeFieldEnd()
11469 
    oprot.writeFieldStop()
11470 
    oprot.writeStructEnd()
11471 
 
11472 
  def validate(self):
11473 
    return
11474 
 
11475 
 
11476 
  def __repr__(self):
11477 
    L = ['%s=%r' % (key, value)
11478 
      for key, value in self.__dict__.iteritems()]
11479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11480 
 
11481 
  def __eq__(self, other):
11482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11483 
 
11484 
  def __ne__(self, other):
11485 
    return not (self == other)
11486 
 
11487 
class deleteBanner_args:
11488 
  """
11489 
  Attributes:
11490 
   - bannerName
11491 
  """
11492 
 
11493 
  thrift_spec = (
11494 
    None, # 0
11495 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11496 
  )
11497 
 
11498 
  def __init__(self, bannerName=None,):
11499 
    self.bannerName = bannerName
11500 
 
11501 
  def read(self, iprot):
11502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11504 
      return
11505 
    iprot.readStructBegin()
11506 
    while True:
11507 
      (fname, ftype, fid) = iprot.readFieldBegin()
11508 
      if ftype == TType.STOP:
11509 
        break
11510 
      if fid == 1:
11511 
        if ftype == TType.STRING:
11512 
          self.bannerName = iprot.readString();
11513 
        else:
11514 
          iprot.skip(ftype)
11515 
      else:
11516 
        iprot.skip(ftype)
11517 
      iprot.readFieldEnd()
11518 
    iprot.readStructEnd()
11519 
 
11520 
  def write(self, oprot):
11521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11523 
      return
11524 
    oprot.writeStructBegin('deleteBanner_args')
11525 
    if self.bannerName is not None:
11526 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11527 
      oprot.writeString(self.bannerName)
11528 
      oprot.writeFieldEnd()
11529 
    oprot.writeFieldStop()
11530 
    oprot.writeStructEnd()
11531 
 
11532 
  def validate(self):
11533 
    return
11534 
 
11535 
 
11536 
  def __repr__(self):
11537 
    L = ['%s=%r' % (key, value)
11538 
      for key, value in self.__dict__.iteritems()]
11539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11540 
 
11541 
  def __eq__(self, other):
11542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11543 
 
11544 
  def __ne__(self, other):
11545 
    return not (self == other)
11546 
 
11547 
class deleteBanner_result:
11548 
  """
11549 
  Attributes:
11550 
   - success
11551 
  """
11552 
 
11553 
  thrift_spec = (
11554 
    (0, TType.BOOL, 'success', None, None, ), # 0
11555 
  )
11556 
 
11557 
  def __init__(self, success=None,):
11558 
    self.success = success
11559 
 
11560 
  def read(self, iprot):
11561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11563 
      return
11564 
    iprot.readStructBegin()
11565 
    while True:
11566 
      (fname, ftype, fid) = iprot.readFieldBegin()
11567 
      if ftype == TType.STOP:
11568 
        break
11569 
      if fid == 0:
11570 
        if ftype == TType.BOOL:
11571 
          self.success = iprot.readBool();
11572 
        else:
11573 
          iprot.skip(ftype)
11574 
      else:
11575 
        iprot.skip(ftype)
11576 
      iprot.readFieldEnd()
11577 
    iprot.readStructEnd()
11578 
 
11579 
  def write(self, oprot):
11580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11582 
      return
11583 
    oprot.writeStructBegin('deleteBanner_result')
11584 
    if self.success is not None:
11585 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11586 
      oprot.writeBool(self.success)
11587 
      oprot.writeFieldEnd()
11588 
    oprot.writeFieldStop()
11589 
    oprot.writeStructEnd()
11590 
 
11591 
  def validate(self):
11592 
    return
11593 
 
11594 
 
11595 
  def __repr__(self):
11596 
    L = ['%s=%r' % (key, value)
11597 
      for key, value in self.__dict__.iteritems()]
11598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11599 
 
11600 
  def __eq__(self, other):
11601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11602 
 
11603 
  def __ne__(self, other):
11604 
    return not (self == other)
11605 
 
11606 
class getBannerDetails_args:
11607 
  """
11608 
  Attributes:
11609 
   - bannerName
11610 
  """
11611 
 
11612 
  thrift_spec = (
11613 
    None, # 0
11614 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11615 
  )
11616 
 
11617 
  def __init__(self, bannerName=None,):
11618 
    self.bannerName = bannerName
11619 
 
11620 
  def read(self, iprot):
11621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11623 
      return
11624 
    iprot.readStructBegin()
11625 
    while True:
11626 
      (fname, ftype, fid) = iprot.readFieldBegin()
11627 
      if ftype == TType.STOP:
11628 
        break
11629 
      if fid == 1:
11630 
        if ftype == TType.STRING:
11631 
          self.bannerName = iprot.readString();
11632 
        else:
11633 
          iprot.skip(ftype)
11634 
      else:
11635 
        iprot.skip(ftype)
11636 
      iprot.readFieldEnd()
11637 
    iprot.readStructEnd()
11638 
 
11639 
  def write(self, oprot):
11640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11642 
      return
11643 
    oprot.writeStructBegin('getBannerDetails_args')
11644 
    if self.bannerName is not None:
11645 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11646 
      oprot.writeString(self.bannerName)
11647 
      oprot.writeFieldEnd()
11648 
    oprot.writeFieldStop()
11649 
    oprot.writeStructEnd()
11650 
 
11651 
  def validate(self):
11652 
    return
11653 
 
11654 
 
11655 
  def __repr__(self):
11656 
    L = ['%s=%r' % (key, value)
11657 
      for key, value in self.__dict__.iteritems()]
11658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11659 
 
11660 
  def __eq__(self, other):
11661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11662 
 
11663 
  def __ne__(self, other):
11664 
    return not (self == other)
11665 
 
11666 
class getBannerDetails_result:
11667 
  """
11668 
  Attributes:
11669 
   - success
11670 
  """
11671 
 
11672 
  thrift_spec = (
11673 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11674 
  )
11675 
 
11676 
  def __init__(self, success=None,):
11677 
    self.success = success
11678 
 
11679 
  def read(self, iprot):
11680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11682 
      return
11683 
    iprot.readStructBegin()
11684 
    while True:
11685 
      (fname, ftype, fid) = iprot.readFieldBegin()
11686 
      if ftype == TType.STOP:
11687 
        break
11688 
      if fid == 0:
11689 
        if ftype == TType.STRUCT:
11690 
          self.success = Banner()
11691 
          self.success.read(iprot)
11692 
        else:
11693 
          iprot.skip(ftype)
11694 
      else:
11695 
        iprot.skip(ftype)
11696 
      iprot.readFieldEnd()
11697 
    iprot.readStructEnd()
11698 
 
11699 
  def write(self, oprot):
11700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11702 
      return
11703 
    oprot.writeStructBegin('getBannerDetails_result')
11704 
    if self.success is not None:
11705 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11706 
      self.success.write(oprot)
11707 
      oprot.writeFieldEnd()
11708 
    oprot.writeFieldStop()
11709 
    oprot.writeStructEnd()
11710 
 
11711 
  def validate(self):
11712 
    return
11713 
 
11714 
 
11715 
  def __repr__(self):
11716 
    L = ['%s=%r' % (key, value)
11717 
      for key, value in self.__dict__.iteritems()]
11718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11719 
 
11720 
  def __eq__(self, other):
11721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11722 
 
11723 
  def __ne__(self, other):
11724 
    return not (self == other)
11725 
 
11726 
class getActiveBanners_args:
11727 
 
11728 
  thrift_spec = (
11729 
  )
11730 
 
11731 
  def read(self, iprot):
11732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11734 
      return
11735 
    iprot.readStructBegin()
11736 
    while True:
11737 
      (fname, ftype, fid) = iprot.readFieldBegin()
11738 
      if ftype == TType.STOP:
11739 
        break
11740 
      else:
11741 
        iprot.skip(ftype)
11742 
      iprot.readFieldEnd()
11743 
    iprot.readStructEnd()
11744 
 
11745 
  def write(self, oprot):
11746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11748 
      return
11749 
    oprot.writeStructBegin('getActiveBanners_args')
11750 
    oprot.writeFieldStop()
11751 
    oprot.writeStructEnd()
11752 
 
11753 
  def validate(self):
11754 
    return
11755 
 
11756 
 
11757 
  def __repr__(self):
11758 
    L = ['%s=%r' % (key, value)
11759 
      for key, value in self.__dict__.iteritems()]
11760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11761 
 
11762 
  def __eq__(self, other):
11763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11764 
 
11765 
  def __ne__(self, other):
11766 
    return not (self == other)
11767 
 
11768 
class getActiveBanners_result:
11769 
  """
11770 
  Attributes:
11771 
   - success
11772 
  """
11773 
 
11774 
  thrift_spec = (
11775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11776 
  )
11777 
 
11778 
  def __init__(self, success=None,):
11779 
    self.success = success
11780 
 
11781 
  def read(self, iprot):
11782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11784 
      return
11785 
    iprot.readStructBegin()
11786 
    while True:
11787 
      (fname, ftype, fid) = iprot.readFieldBegin()
11788 
      if ftype == TType.STOP:
11789 
        break
11790 
      if fid == 0:
11791 
        if ftype == TType.LIST:
11792 
          self.success = []
7438 amit.gupta 11793 
          (_etype191, _size188) = iprot.readListBegin()
11794 
          for _i192 in xrange(_size188):
11795 
            _elem193 = Banner()
11796 
            _elem193.read(iprot)
11797 
            self.success.append(_elem193)
6850 kshitij.so 11798 
          iprot.readListEnd()
11799 
        else:
11800 
          iprot.skip(ftype)
11801 
      else:
11802 
        iprot.skip(ftype)
11803 
      iprot.readFieldEnd()
11804 
    iprot.readStructEnd()
11805 
 
11806 
  def write(self, oprot):
11807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11809 
      return
11810 
    oprot.writeStructBegin('getActiveBanners_result')
11811 
    if self.success is not None:
11812 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11813 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11814 
      for iter194 in self.success:
11815 
        iter194.write(oprot)
6850 kshitij.so 11816 
      oprot.writeListEnd()
11817 
      oprot.writeFieldEnd()
11818 
    oprot.writeFieldStop()
11819 
    oprot.writeStructEnd()
11820 
 
11821 
  def validate(self):
11822 
    return
11823 
 
11824 
 
11825 
  def __repr__(self):
11826 
    L = ['%s=%r' % (key, value)
11827 
      for key, value in self.__dict__.iteritems()]
11828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11829 
 
11830 
  def __eq__(self, other):
11831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11832 
 
11833 
  def __ne__(self, other):
11834 
    return not (self == other)
11835 
 
6849 kshitij.so 11836 
class addBannerMap_args:
11837 
  """
11838 
  Attributes:
11839 
   - bannerName
11840 
   - mapLink
11841 
   - coordinates
11842 
  """
11843 
 
11844 
  thrift_spec = (
11845 
    None, # 0
11846 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11847 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11848 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11849 
  )
11850 
 
11851 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11852 
    self.bannerName = bannerName
11853 
    self.mapLink = mapLink
11854 
    self.coordinates = coordinates
11855 
 
11856 
  def read(self, iprot):
11857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11859 
      return
11860 
    iprot.readStructBegin()
11861 
    while True:
11862 
      (fname, ftype, fid) = iprot.readFieldBegin()
11863 
      if ftype == TType.STOP:
11864 
        break
11865 
      if fid == 1:
11866 
        if ftype == TType.STRING:
11867 
          self.bannerName = iprot.readString();
11868 
        else:
11869 
          iprot.skip(ftype)
11870 
      elif fid == 2:
11871 
        if ftype == TType.STRING:
11872 
          self.mapLink = iprot.readString();
11873 
        else:
11874 
          iprot.skip(ftype)
11875 
      elif fid == 3:
11876 
        if ftype == TType.STRING:
11877 
          self.coordinates = iprot.readString();
11878 
        else:
11879 
          iprot.skip(ftype)
11880 
      else:
11881 
        iprot.skip(ftype)
11882 
      iprot.readFieldEnd()
11883 
    iprot.readStructEnd()
11884 
 
11885 
  def write(self, oprot):
11886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11888 
      return
11889 
    oprot.writeStructBegin('addBannerMap_args')
11890 
    if self.bannerName is not None:
11891 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11892 
      oprot.writeString(self.bannerName)
11893 
      oprot.writeFieldEnd()
11894 
    if self.mapLink is not None:
11895 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11896 
      oprot.writeString(self.mapLink)
11897 
      oprot.writeFieldEnd()
11898 
    if self.coordinates is not None:
11899 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11900 
      oprot.writeString(self.coordinates)
11901 
      oprot.writeFieldEnd()
11902 
    oprot.writeFieldStop()
11903 
    oprot.writeStructEnd()
11904 
 
11905 
  def validate(self):
11906 
    return
11907 
 
11908 
 
11909 
  def __repr__(self):
11910 
    L = ['%s=%r' % (key, value)
11911 
      for key, value in self.__dict__.iteritems()]
11912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11913 
 
11914 
  def __eq__(self, other):
11915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11916 
 
11917 
  def __ne__(self, other):
11918 
    return not (self == other)
11919 
 
11920 
class addBannerMap_result:
11921 
  """
11922 
  Attributes:
11923 
   - success
11924 
  """
11925 
 
11926 
  thrift_spec = (
11927 
    (0, TType.BOOL, 'success', None, None, ), # 0
11928 
  )
11929 
 
11930 
  def __init__(self, success=None,):
11931 
    self.success = success
11932 
 
11933 
  def read(self, iprot):
11934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11936 
      return
11937 
    iprot.readStructBegin()
11938 
    while True:
11939 
      (fname, ftype, fid) = iprot.readFieldBegin()
11940 
      if ftype == TType.STOP:
11941 
        break
11942 
      if fid == 0:
11943 
        if ftype == TType.BOOL:
11944 
          self.success = iprot.readBool();
11945 
        else:
11946 
          iprot.skip(ftype)
11947 
      else:
11948 
        iprot.skip(ftype)
11949 
      iprot.readFieldEnd()
11950 
    iprot.readStructEnd()
11951 
 
11952 
  def write(self, oprot):
11953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11955 
      return
11956 
    oprot.writeStructBegin('addBannerMap_result')
11957 
    if self.success is not None:
11958 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11959 
      oprot.writeBool(self.success)
11960 
      oprot.writeFieldEnd()
11961 
    oprot.writeFieldStop()
11962 
    oprot.writeStructEnd()
11963 
 
11964 
  def validate(self):
11965 
    return
11966 
 
11967 
 
11968 
  def __repr__(self):
11969 
    L = ['%s=%r' % (key, value)
11970 
      for key, value in self.__dict__.iteritems()]
11971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11972 
 
11973 
  def __eq__(self, other):
11974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11975 
 
11976 
  def __ne__(self, other):
11977 
    return not (self == other)
11978 
 
11979 
class deleteBannerMap_args:
11980 
  """
11981 
  Attributes:
11982 
   - bannerName
11983 
  """
11984 
 
11985 
  thrift_spec = (
11986 
    None, # 0
11987 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11988 
  )
11989 
 
11990 
  def __init__(self, bannerName=None,):
11991 
    self.bannerName = bannerName
11992 
 
11993 
  def read(self, iprot):
11994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11996 
      return
11997 
    iprot.readStructBegin()
11998 
    while True:
11999 
      (fname, ftype, fid) = iprot.readFieldBegin()
12000 
      if ftype == TType.STOP:
12001 
        break
12002 
      if fid == 1:
12003 
        if ftype == TType.STRING:
12004 
          self.bannerName = iprot.readString();
12005 
        else:
12006 
          iprot.skip(ftype)
12007 
      else:
12008 
        iprot.skip(ftype)
12009 
      iprot.readFieldEnd()
12010 
    iprot.readStructEnd()
12011 
 
12012 
  def write(self, oprot):
12013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12015 
      return
12016 
    oprot.writeStructBegin('deleteBannerMap_args')
12017 
    if self.bannerName is not None:
12018 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12019 
      oprot.writeString(self.bannerName)
12020 
      oprot.writeFieldEnd()
12021 
    oprot.writeFieldStop()
12022 
    oprot.writeStructEnd()
12023 
 
12024 
  def validate(self):
12025 
    return
12026 
 
12027 
 
12028 
  def __repr__(self):
12029 
    L = ['%s=%r' % (key, value)
12030 
      for key, value in self.__dict__.iteritems()]
12031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12032 
 
12033 
  def __eq__(self, other):
12034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12035 
 
12036 
  def __ne__(self, other):
12037 
    return not (self == other)
12038 
 
12039 
class deleteBannerMap_result:
12040 
  """
12041 
  Attributes:
12042 
   - success
12043 
  """
12044 
 
12045 
  thrift_spec = (
12046 
    (0, TType.BOOL, 'success', None, None, ), # 0
12047 
  )
12048 
 
12049 
  def __init__(self, success=None,):
12050 
    self.success = success
12051 
 
12052 
  def read(self, iprot):
12053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12055 
      return
12056 
    iprot.readStructBegin()
12057 
    while True:
12058 
      (fname, ftype, fid) = iprot.readFieldBegin()
12059 
      if ftype == TType.STOP:
12060 
        break
12061 
      if fid == 0:
12062 
        if ftype == TType.BOOL:
12063 
          self.success = iprot.readBool();
12064 
        else:
12065 
          iprot.skip(ftype)
12066 
      else:
12067 
        iprot.skip(ftype)
12068 
      iprot.readFieldEnd()
12069 
    iprot.readStructEnd()
12070 
 
12071 
  def write(self, oprot):
12072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12074 
      return
12075 
    oprot.writeStructBegin('deleteBannerMap_result')
12076 
    if self.success is not None:
12077 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12078 
      oprot.writeBool(self.success)
12079 
      oprot.writeFieldEnd()
12080 
    oprot.writeFieldStop()
12081 
    oprot.writeStructEnd()
12082 
 
12083 
  def validate(self):
12084 
    return
12085 
 
12086 
 
12087 
  def __repr__(self):
12088 
    L = ['%s=%r' % (key, value)
12089 
      for key, value in self.__dict__.iteritems()]
12090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12091 
 
12092 
  def __eq__(self, other):
12093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12094 
 
12095 
  def __ne__(self, other):
12096 
    return not (self == other)
12097 
 
12098 
class getBannerMapDetails_args:
12099 
  """
12100 
  Attributes:
12101 
   - bannerName
12102 
  """
12103 
 
12104 
  thrift_spec = (
12105 
    None, # 0
12106 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12107 
  )
12108 
 
12109 
  def __init__(self, bannerName=None,):
12110 
    self.bannerName = bannerName
12111 
 
12112 
  def read(self, iprot):
12113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12115 
      return
12116 
    iprot.readStructBegin()
12117 
    while True:
12118 
      (fname, ftype, fid) = iprot.readFieldBegin()
12119 
      if ftype == TType.STOP:
12120 
        break
12121 
      if fid == 1:
12122 
        if ftype == TType.STRING:
12123 
          self.bannerName = iprot.readString();
12124 
        else:
12125 
          iprot.skip(ftype)
12126 
      else:
12127 
        iprot.skip(ftype)
12128 
      iprot.readFieldEnd()
12129 
    iprot.readStructEnd()
12130 
 
12131 
  def write(self, oprot):
12132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12134 
      return
12135 
    oprot.writeStructBegin('getBannerMapDetails_args')
12136 
    if self.bannerName is not None:
12137 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12138 
      oprot.writeString(self.bannerName)
12139 
      oprot.writeFieldEnd()
12140 
    oprot.writeFieldStop()
12141 
    oprot.writeStructEnd()
12142 
 
12143 
  def validate(self):
12144 
    return
12145 
 
12146 
 
12147 
  def __repr__(self):
12148 
    L = ['%s=%r' % (key, value)
12149 
      for key, value in self.__dict__.iteritems()]
12150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12151 
 
12152 
  def __eq__(self, other):
12153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12154 
 
12155 
  def __ne__(self, other):
12156 
    return not (self == other)
12157 
 
12158 
class getBannerMapDetails_result:
12159 
  """
12160 
  Attributes:
12161 
   - success
12162 
  """
12163 
 
12164 
  thrift_spec = (
12165 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
12166 
  )
12167 
 
12168 
  def __init__(self, success=None,):
12169 
    self.success = success
12170 
 
12171 
  def read(self, iprot):
12172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12174 
      return
12175 
    iprot.readStructBegin()
12176 
    while True:
12177 
      (fname, ftype, fid) = iprot.readFieldBegin()
12178 
      if ftype == TType.STOP:
12179 
        break
12180 
      if fid == 0:
12181 
        if ftype == TType.LIST:
12182 
          self.success = []
7438 amit.gupta 12183 
          (_etype198, _size195) = iprot.readListBegin()
12184 
          for _i199 in xrange(_size195):
12185 
            _elem200 = BannerMap()
12186 
            _elem200.read(iprot)
12187 
            self.success.append(_elem200)
6849 kshitij.so 12188 
          iprot.readListEnd()
12189 
        else:
12190 
          iprot.skip(ftype)
12191 
      else:
12192 
        iprot.skip(ftype)
12193 
      iprot.readFieldEnd()
12194 
    iprot.readStructEnd()
12195 
 
12196 
  def write(self, oprot):
12197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12199 
      return
12200 
    oprot.writeStructBegin('getBannerMapDetails_result')
12201 
    if self.success is not None:
12202 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12203 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12204 
      for iter201 in self.success:
12205 
        iter201.write(oprot)
6849 kshitij.so 12206 
      oprot.writeListEnd()
12207 
      oprot.writeFieldEnd()
12208 
    oprot.writeFieldStop()
12209 
    oprot.writeStructEnd()
12210 
 
12211 
  def validate(self):
12212 
    return
12213 
 
12214 
 
12215 
  def __repr__(self):
12216 
    L = ['%s=%r' % (key, value)
12217 
      for key, value in self.__dict__.iteritems()]
12218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12219 
 
12220 
  def __eq__(self, other):
12221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12222 
 
12223 
  def __ne__(self, other):
12224 
    return not (self == other)
12225 
 
5944 mandeep.dh 12226 
class deleteSimilarItem_args:
12227 
  """
12228 
  Attributes:
12229 
   - itemId
12230 
   - catalogItemId
12231 
  """
12232 
 
12233 
  thrift_spec = (
12234 
    None, # 0
12235 
    (1, TType.I64, 'itemId', None, None, ), # 1
12236 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
12237 
  )
12238 
 
12239 
  def __init__(self, itemId=None, catalogItemId=None,):
12240 
    self.itemId = itemId
12241 
    self.catalogItemId = catalogItemId
12242 
 
12243 
  def read(self, iprot):
12244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12246 
      return
12247 
    iprot.readStructBegin()
12248 
    while True:
12249 
      (fname, ftype, fid) = iprot.readFieldBegin()
12250 
      if ftype == TType.STOP:
12251 
        break
12252 
      if fid == 1:
12253 
        if ftype == TType.I64:
12254 
          self.itemId = iprot.readI64();
12255 
        else:
12256 
          iprot.skip(ftype)
12257 
      elif fid == 2:
12258 
        if ftype == TType.I64:
12259 
          self.catalogItemId = iprot.readI64();
12260 
        else:
12261 
          iprot.skip(ftype)
12262 
      else:
12263 
        iprot.skip(ftype)
12264 
      iprot.readFieldEnd()
12265 
    iprot.readStructEnd()
12266 
 
12267 
  def write(self, oprot):
12268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12270 
      return
12271 
    oprot.writeStructBegin('deleteSimilarItem_args')
12272 
    if self.itemId is not None:
12273 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12274 
      oprot.writeI64(self.itemId)
12275 
      oprot.writeFieldEnd()
12276 
    if self.catalogItemId is not None:
12277 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12278 
      oprot.writeI64(self.catalogItemId)
12279 
      oprot.writeFieldEnd()
12280 
    oprot.writeFieldStop()
12281 
    oprot.writeStructEnd()
12282 
 
12283 
  def validate(self):
12284 
    return
12285 
 
12286 
 
12287 
  def __repr__(self):
12288 
    L = ['%s=%r' % (key, value)
12289 
      for key, value in self.__dict__.iteritems()]
12290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12291 
 
12292 
  def __eq__(self, other):
12293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12294 
 
12295 
  def __ne__(self, other):
12296 
    return not (self == other)
12297 
 
12298 
class deleteSimilarItem_result:
12299 
  """
12300 
  Attributes:
12301 
   - success
12302 
   - cex
12303 
  """
12304 
 
12305 
  thrift_spec = (
12306 
    (0, TType.BOOL, 'success', None, None, ), # 0
12307 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12308 
  )
12309 
 
12310 
  def __init__(self, success=None, cex=None,):
12311 
    self.success = success
12312 
    self.cex = cex
12313 
 
12314 
  def read(self, iprot):
12315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12317 
      return
12318 
    iprot.readStructBegin()
12319 
    while True:
12320 
      (fname, ftype, fid) = iprot.readFieldBegin()
12321 
      if ftype == TType.STOP:
12322 
        break
12323 
      if fid == 0:
12324 
        if ftype == TType.BOOL:
12325 
          self.success = iprot.readBool();
12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      elif fid == 1:
12329 
        if ftype == TType.STRUCT:
12330 
          self.cex = CatalogServiceException()
12331 
          self.cex.read(iprot)
12332 
        else:
12333 
          iprot.skip(ftype)
12334 
      else:
12335 
        iprot.skip(ftype)
12336 
      iprot.readFieldEnd()
12337 
    iprot.readStructEnd()
12338 
 
12339 
  def write(self, oprot):
12340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12342 
      return
12343 
    oprot.writeStructBegin('deleteSimilarItem_result')
12344 
    if self.success is not None:
12345 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12346 
      oprot.writeBool(self.success)
12347 
      oprot.writeFieldEnd()
12348 
    if self.cex is not None:
12349 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12350 
      self.cex.write(oprot)
12351 
      oprot.writeFieldEnd()
12352 
    oprot.writeFieldStop()
12353 
    oprot.writeStructEnd()
12354 
 
12355 
  def validate(self):
12356 
    return
12357 
 
12358 
 
12359 
  def __repr__(self):
12360 
    L = ['%s=%r' % (key, value)
12361 
      for key, value in self.__dict__.iteritems()]
12362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12363 
 
12364 
  def __eq__(self, other):
12365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12366 
 
12367 
  def __ne__(self, other):
12368 
    return not (self == other)
12369 
 
12370 
class checkSimilarItem_args:
12371 
  """
12372 
  Attributes:
12373 
   - brand
12374 
   - modelNumber
12375 
   - modelName
12376 
   - color
12377 
  """
12378 
 
12379 
  thrift_spec = (
12380 
    None, # 0
12381 
    (1, TType.STRING, 'brand', None, None, ), # 1
12382 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
12383 
    (3, TType.STRING, 'modelName', None, None, ), # 3
12384 
    (4, TType.STRING, 'color', None, None, ), # 4
12385 
  )
12386 
 
12387 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
12388 
    self.brand = brand
12389 
    self.modelNumber = modelNumber
12390 
    self.modelName = modelName
12391 
    self.color = color
12392 
 
12393 
  def read(self, iprot):
12394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12396 
      return
12397 
    iprot.readStructBegin()
12398 
    while True:
12399 
      (fname, ftype, fid) = iprot.readFieldBegin()
12400 
      if ftype == TType.STOP:
12401 
        break
12402 
      if fid == 1:
12403 
        if ftype == TType.STRING:
12404 
          self.brand = iprot.readString();
12405 
        else:
12406 
          iprot.skip(ftype)
12407 
      elif fid == 2:
12408 
        if ftype == TType.STRING:
12409 
          self.modelNumber = iprot.readString();
12410 
        else:
12411 
          iprot.skip(ftype)
12412 
      elif fid == 3:
12413 
        if ftype == TType.STRING:
12414 
          self.modelName = iprot.readString();
12415 
        else:
12416 
          iprot.skip(ftype)
12417 
      elif fid == 4:
12418 
        if ftype == TType.STRING:
12419 
          self.color = iprot.readString();
12420 
        else:
12421 
          iprot.skip(ftype)
12422 
      else:
12423 
        iprot.skip(ftype)
12424 
      iprot.readFieldEnd()
12425 
    iprot.readStructEnd()
12426 
 
12427 
  def write(self, oprot):
12428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12430 
      return
12431 
    oprot.writeStructBegin('checkSimilarItem_args')
12432 
    if self.brand is not None:
12433 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
12434 
      oprot.writeString(self.brand)
12435 
      oprot.writeFieldEnd()
12436 
    if self.modelNumber is not None:
12437 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
12438 
      oprot.writeString(self.modelNumber)
12439 
      oprot.writeFieldEnd()
12440 
    if self.modelName is not None:
12441 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
12442 
      oprot.writeString(self.modelName)
12443 
      oprot.writeFieldEnd()
12444 
    if self.color is not None:
12445 
      oprot.writeFieldBegin('color', TType.STRING, 4)
12446 
      oprot.writeString(self.color)
12447 
      oprot.writeFieldEnd()
12448 
    oprot.writeFieldStop()
12449 
    oprot.writeStructEnd()
12450 
 
12451 
  def validate(self):
12452 
    return
12453 
 
12454 
 
12455 
  def __repr__(self):
12456 
    L = ['%s=%r' % (key, value)
12457 
      for key, value in self.__dict__.iteritems()]
12458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12459 
 
12460 
  def __eq__(self, other):
12461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12462 
 
12463 
  def __ne__(self, other):
12464 
    return not (self == other)
12465 
 
12466 
class checkSimilarItem_result:
12467 
  """
12468 
  Attributes:
12469 
   - success
12470 
  """
12471 
 
12472 
  thrift_spec = (
12473 
    (0, TType.I64, 'success', None, None, ), # 0
12474 
  )
12475 
 
12476 
  def __init__(self, success=None,):
12477 
    self.success = success
12478 
 
12479 
  def read(self, iprot):
12480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12482 
      return
12483 
    iprot.readStructBegin()
12484 
    while True:
12485 
      (fname, ftype, fid) = iprot.readFieldBegin()
12486 
      if ftype == TType.STOP:
12487 
        break
12488 
      if fid == 0:
12489 
        if ftype == TType.I64:
12490 
          self.success = iprot.readI64();
12491 
        else:
12492 
          iprot.skip(ftype)
12493 
      else:
12494 
        iprot.skip(ftype)
12495 
      iprot.readFieldEnd()
12496 
    iprot.readStructEnd()
12497 
 
12498 
  def write(self, oprot):
12499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12501 
      return
12502 
    oprot.writeStructBegin('checkSimilarItem_result')
12503 
    if self.success is not None:
12504 
      oprot.writeFieldBegin('success', TType.I64, 0)
12505 
      oprot.writeI64(self.success)
12506 
      oprot.writeFieldEnd()
12507 
    oprot.writeFieldStop()
12508 
    oprot.writeStructEnd()
12509 
 
12510 
  def validate(self):
12511 
    return
12512 
 
12513 
 
12514 
  def __repr__(self):
12515 
    L = ['%s=%r' % (key, value)
12516 
      for key, value in self.__dict__.iteritems()]
12517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12518 
 
12519 
  def __eq__(self, other):
12520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12521 
 
12522 
  def __ne__(self, other):
12523 
    return not (self == other)
12524 
 
12525 
class validateRiskyStatus_args:
12526 
  """
12527 
  Attributes:
12528 
   - itemId
12529 
  """
12530 
 
12531 
  thrift_spec = (
12532 
    None, # 0
12533 
    (1, TType.I64, 'itemId', None, None, ), # 1
12534 
  )
12535 
 
12536 
  def __init__(self, itemId=None,):
12537 
    self.itemId = itemId
12538 
 
12539 
  def read(self, iprot):
12540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12542 
      return
12543 
    iprot.readStructBegin()
12544 
    while True:
12545 
      (fname, ftype, fid) = iprot.readFieldBegin()
12546 
      if ftype == TType.STOP:
12547 
        break
12548 
      if fid == 1:
12549 
        if ftype == TType.I64:
12550 
          self.itemId = iprot.readI64();
12551 
        else:
12552 
          iprot.skip(ftype)
12553 
      else:
12554 
        iprot.skip(ftype)
12555 
      iprot.readFieldEnd()
12556 
    iprot.readStructEnd()
12557 
 
12558 
  def write(self, oprot):
12559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12561 
      return
12562 
    oprot.writeStructBegin('validateRiskyStatus_args')
12563 
    if self.itemId is not None:
12564 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12565 
      oprot.writeI64(self.itemId)
12566 
      oprot.writeFieldEnd()
12567 
    oprot.writeFieldStop()
12568 
    oprot.writeStructEnd()
12569 
 
12570 
  def validate(self):
12571 
    return
12572 
 
12573 
 
12574 
  def __repr__(self):
12575 
    L = ['%s=%r' % (key, value)
12576 
      for key, value in self.__dict__.iteritems()]
12577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12578 
 
12579 
  def __eq__(self, other):
12580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12581 
 
12582 
  def __ne__(self, other):
12583 
    return not (self == other)
12584 
 
12585 
class validateRiskyStatus_result:
12586 
 
12587 
  thrift_spec = (
12588 
  )
12589 
 
12590 
  def read(self, iprot):
12591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12593 
      return
12594 
    iprot.readStructBegin()
12595 
    while True:
12596 
      (fname, ftype, fid) = iprot.readFieldBegin()
12597 
      if ftype == TType.STOP:
12598 
        break
12599 
      else:
12600 
        iprot.skip(ftype)
12601 
      iprot.readFieldEnd()
12602 
    iprot.readStructEnd()
12603 
 
12604 
  def write(self, oprot):
12605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12607 
      return
12608 
    oprot.writeStructBegin('validateRiskyStatus_result')
12609 
    oprot.writeFieldStop()
12610 
    oprot.writeStructEnd()
12611 
 
12612 
  def validate(self):
12613 
    return
12614 
 
12615 
 
12616 
  def __repr__(self):
12617 
    L = ['%s=%r' % (key, value)
12618 
      for key, value in self.__dict__.iteritems()]
12619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12620 
 
12621 
  def __eq__(self, other):
12622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12623 
 
12624 
  def __ne__(self, other):
12625 
    return not (self == other)
12626 
 
12627 
class changeItemRiskyFlag_args:
12628 
  """
12629 
  Attributes:
12630 
   - itemId
12631 
   - risky
12632 
  """
12633 
 
12634 
  thrift_spec = (
12635 
    None, # 0
12636 
    (1, TType.I64, 'itemId', None, None, ), # 1
12637 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12638 
  )
12639 
 
12640 
  def __init__(self, itemId=None, risky=None,):
12641 
    self.itemId = itemId
12642 
    self.risky = risky
12643 
 
12644 
  def read(self, iprot):
12645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12647 
      return
12648 
    iprot.readStructBegin()
12649 
    while True:
12650 
      (fname, ftype, fid) = iprot.readFieldBegin()
12651 
      if ftype == TType.STOP:
12652 
        break
12653 
      if fid == 1:
12654 
        if ftype == TType.I64:
12655 
          self.itemId = iprot.readI64();
12656 
        else:
12657 
          iprot.skip(ftype)
12658 
      elif fid == 2:
12659 
        if ftype == TType.BOOL:
12660 
          self.risky = iprot.readBool();
12661 
        else:
12662 
          iprot.skip(ftype)
12663 
      else:
12664 
        iprot.skip(ftype)
12665 
      iprot.readFieldEnd()
12666 
    iprot.readStructEnd()
12667 
 
12668 
  def write(self, oprot):
12669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12671 
      return
12672 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12673 
    if self.itemId is not None:
12674 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12675 
      oprot.writeI64(self.itemId)
12676 
      oprot.writeFieldEnd()
12677 
    if self.risky is not None:
12678 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12679 
      oprot.writeBool(self.risky)
12680 
      oprot.writeFieldEnd()
12681 
    oprot.writeFieldStop()
12682 
    oprot.writeStructEnd()
12683 
 
12684 
  def validate(self):
12685 
    return
12686 
 
12687 
 
12688 
  def __repr__(self):
12689 
    L = ['%s=%r' % (key, value)
12690 
      for key, value in self.__dict__.iteritems()]
12691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12692 
 
12693 
  def __eq__(self, other):
12694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12695 
 
12696 
  def __ne__(self, other):
12697 
    return not (self == other)
12698 
 
12699 
class changeItemRiskyFlag_result:
12700 
 
12701 
  thrift_spec = (
12702 
  )
12703 
 
12704 
  def read(self, iprot):
12705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12707 
      return
12708 
    iprot.readStructBegin()
12709 
    while True:
12710 
      (fname, ftype, fid) = iprot.readFieldBegin()
12711 
      if ftype == TType.STOP:
12712 
        break
12713 
      else:
12714 
        iprot.skip(ftype)
12715 
      iprot.readFieldEnd()
12716 
    iprot.readStructEnd()
12717 
 
12718 
  def write(self, oprot):
12719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12721 
      return
12722 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12723 
    oprot.writeFieldStop()
12724 
    oprot.writeStructEnd()
12725 
 
12726 
  def validate(self):
12727 
    return
12728 
 
12729 
 
12730 
  def __repr__(self):
12731 
    L = ['%s=%r' % (key, value)
12732 
      for key, value in self.__dict__.iteritems()]
12733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12734 
 
12735 
  def __eq__(self, other):
12736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12737 
 
12738 
  def __ne__(self, other):
12739 
    return not (self == other)
12740 
 
12741 
class getItemsByRiskyFlag_args:
12742 
 
12743 
  thrift_spec = (
12744 
  )
12745 
 
12746 
  def read(self, iprot):
12747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12749 
      return
12750 
    iprot.readStructBegin()
12751 
    while True:
12752 
      (fname, ftype, fid) = iprot.readFieldBegin()
12753 
      if ftype == TType.STOP:
12754 
        break
12755 
      else:
12756 
        iprot.skip(ftype)
12757 
      iprot.readFieldEnd()
12758 
    iprot.readStructEnd()
12759 
 
12760 
  def write(self, oprot):
12761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12763 
      return
12764 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12765 
    oprot.writeFieldStop()
12766 
    oprot.writeStructEnd()
12767 
 
12768 
  def validate(self):
12769 
    return
12770 
 
12771 
 
12772 
  def __repr__(self):
12773 
    L = ['%s=%r' % (key, value)
12774 
      for key, value in self.__dict__.iteritems()]
12775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12776 
 
12777 
  def __eq__(self, other):
12778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12779 
 
12780 
  def __ne__(self, other):
12781 
    return not (self == other)
12782 
 
12783 
class getItemsByRiskyFlag_result:
12784 
  """
12785 
  Attributes:
12786 
   - success
12787 
  """
12788 
 
12789 
  thrift_spec = (
12790 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12791 
  )
12792 
 
12793 
  def __init__(self, success=None,):
12794 
    self.success = success
12795 
 
12796 
  def read(self, iprot):
12797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12799 
      return
12800 
    iprot.readStructBegin()
12801 
    while True:
12802 
      (fname, ftype, fid) = iprot.readFieldBegin()
12803 
      if ftype == TType.STOP:
12804 
        break
12805 
      if fid == 0:
12806 
        if ftype == TType.LIST:
12807 
          self.success = []
7438 amit.gupta 12808 
          (_etype205, _size202) = iprot.readListBegin()
12809 
          for _i206 in xrange(_size202):
12810 
            _elem207 = Item()
12811 
            _elem207.read(iprot)
12812 
            self.success.append(_elem207)
5944 mandeep.dh 12813 
          iprot.readListEnd()
12814 
        else:
12815 
          iprot.skip(ftype)
12816 
      else:
12817 
        iprot.skip(ftype)
12818 
      iprot.readFieldEnd()
12819 
    iprot.readStructEnd()
12820 
 
12821 
  def write(self, oprot):
12822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12824 
      return
12825 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12826 
    if self.success is not None:
12827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12829 
      for iter208 in self.success:
12830 
        iter208.write(oprot)
5944 mandeep.dh 12831 
      oprot.writeListEnd()
12832 
      oprot.writeFieldEnd()
12833 
    oprot.writeFieldStop()
12834 
    oprot.writeStructEnd()
12835 
 
12836 
  def validate(self):
12837 
    return
12838 
 
12839 
 
12840 
  def __repr__(self):
12841 
    L = ['%s=%r' % (key, value)
12842 
      for key, value in self.__dict__.iteritems()]
12843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12844 
 
12845 
  def __eq__(self, other):
12846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12847 
 
12848 
  def __ne__(self, other):
12849 
    return not (self == other)
12850 
 
12851 
class getItemsForMasterSheet_args:
12852 
  """
12853 
  Attributes:
12854 
   - category
12855 
   - brand
12856 
  """
12857 
 
12858 
  thrift_spec = (
12859 
    None, # 0
12860 
    (1, TType.STRING, 'category', None, None, ), # 1
12861 
    (2, TType.STRING, 'brand', None, None, ), # 2
12862 
  )
12863 
 
12864 
  def __init__(self, category=None, brand=None,):
12865 
    self.category = category
12866 
    self.brand = brand
12867 
 
12868 
  def read(self, iprot):
12869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12871 
      return
12872 
    iprot.readStructBegin()
12873 
    while True:
12874 
      (fname, ftype, fid) = iprot.readFieldBegin()
12875 
      if ftype == TType.STOP:
12876 
        break
12877 
      if fid == 1:
12878 
        if ftype == TType.STRING:
12879 
          self.category = iprot.readString();
12880 
        else:
12881 
          iprot.skip(ftype)
12882 
      elif fid == 2:
12883 
        if ftype == TType.STRING:
12884 
          self.brand = iprot.readString();
12885 
        else:
12886 
          iprot.skip(ftype)
12887 
      else:
12888 
        iprot.skip(ftype)
12889 
      iprot.readFieldEnd()
12890 
    iprot.readStructEnd()
12891 
 
12892 
  def write(self, oprot):
12893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12895 
      return
12896 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12897 
    if self.category is not None:
12898 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12899 
      oprot.writeString(self.category)
12900 
      oprot.writeFieldEnd()
12901 
    if self.brand is not None:
12902 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12903 
      oprot.writeString(self.brand)
12904 
      oprot.writeFieldEnd()
12905 
    oprot.writeFieldStop()
12906 
    oprot.writeStructEnd()
12907 
 
12908 
  def validate(self):
12909 
    return
12910 
 
12911 
 
12912 
  def __repr__(self):
12913 
    L = ['%s=%r' % (key, value)
12914 
      for key, value in self.__dict__.iteritems()]
12915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12916 
 
12917 
  def __eq__(self, other):
12918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12919 
 
12920 
  def __ne__(self, other):
12921 
    return not (self == other)
12922 
 
12923 
class getItemsForMasterSheet_result:
12924 
  """
12925 
  Attributes:
12926 
   - success
12927 
  """
12928 
 
12929 
  thrift_spec = (
12930 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12931 
  )
12932 
 
12933 
  def __init__(self, success=None,):
12934 
    self.success = success
12935 
 
12936 
  def read(self, iprot):
12937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12939 
      return
12940 
    iprot.readStructBegin()
12941 
    while True:
12942 
      (fname, ftype, fid) = iprot.readFieldBegin()
12943 
      if ftype == TType.STOP:
12944 
        break
12945 
      if fid == 0:
12946 
        if ftype == TType.LIST:
12947 
          self.success = []
7438 amit.gupta 12948 
          (_etype212, _size209) = iprot.readListBegin()
12949 
          for _i213 in xrange(_size209):
12950 
            _elem214 = Item()
12951 
            _elem214.read(iprot)
12952 
            self.success.append(_elem214)
5944 mandeep.dh 12953 
          iprot.readListEnd()
12954 
        else:
12955 
          iprot.skip(ftype)
12956 
      else:
12957 
        iprot.skip(ftype)
12958 
      iprot.readFieldEnd()
12959 
    iprot.readStructEnd()
12960 
 
12961 
  def write(self, oprot):
12962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12964 
      return
12965 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12966 
    if self.success is not None:
12967 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12968 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12969 
      for iter215 in self.success:
12970 
        iter215.write(oprot)
5944 mandeep.dh 12971 
      oprot.writeListEnd()
12972 
      oprot.writeFieldEnd()
12973 
    oprot.writeFieldStop()
12974 
    oprot.writeStructEnd()
12975 
 
12976 
  def validate(self):
12977 
    return
12978 
 
12979 
 
12980 
  def __repr__(self):
12981 
    L = ['%s=%r' % (key, value)
12982 
      for key, value in self.__dict__.iteritems()]
12983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12984 
 
12985 
  def __eq__(self, other):
12986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12987 
 
12988 
  def __ne__(self, other):
12989 
    return not (self == other)
12990 
 
12991 
class getSimilarItemsCatalogIds_args:
12992 
  """
12993 
  Attributes:
12994 
   - beginIndex
12995 
   - totalItems
12996 
   - itemId
12997 
  """
12998 
 
12999 
  thrift_spec = (
13000 
    None, # 0
13001 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
13002 
    (2, TType.I64, 'totalItems', None, None, ), # 2
13003 
    (3, TType.I64, 'itemId', None, None, ), # 3
13004 
  )
13005 
 
13006 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
13007 
    self.beginIndex = beginIndex
13008 
    self.totalItems = totalItems
13009 
    self.itemId = itemId
13010 
 
13011 
  def read(self, iprot):
13012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13014 
      return
13015 
    iprot.readStructBegin()
13016 
    while True:
13017 
      (fname, ftype, fid) = iprot.readFieldBegin()
13018 
      if ftype == TType.STOP:
13019 
        break
13020 
      if fid == 1:
13021 
        if ftype == TType.I64:
13022 
          self.beginIndex = iprot.readI64();
13023 
        else:
13024 
          iprot.skip(ftype)
13025 
      elif fid == 2:
13026 
        if ftype == TType.I64:
13027 
          self.totalItems = iprot.readI64();
13028 
        else:
13029 
          iprot.skip(ftype)
13030 
      elif fid == 3:
13031 
        if ftype == TType.I64:
13032 
          self.itemId = iprot.readI64();
13033 
        else:
13034 
          iprot.skip(ftype)
13035 
      else:
13036 
        iprot.skip(ftype)
13037 
      iprot.readFieldEnd()
13038 
    iprot.readStructEnd()
13039 
 
13040 
  def write(self, oprot):
13041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13043 
      return
13044 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
13045 
    if self.beginIndex is not None:
13046 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
13047 
      oprot.writeI64(self.beginIndex)
13048 
      oprot.writeFieldEnd()
13049 
    if self.totalItems is not None:
13050 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
13051 
      oprot.writeI64(self.totalItems)
13052 
      oprot.writeFieldEnd()
13053 
    if self.itemId is not None:
13054 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
13055 
      oprot.writeI64(self.itemId)
13056 
      oprot.writeFieldEnd()
13057 
    oprot.writeFieldStop()
13058 
    oprot.writeStructEnd()
13059 
 
13060 
  def validate(self):
13061 
    return
13062 
 
13063 
 
13064 
  def __repr__(self):
13065 
    L = ['%s=%r' % (key, value)
13066 
      for key, value in self.__dict__.iteritems()]
13067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13068 
 
13069 
  def __eq__(self, other):
13070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13071 
 
13072 
  def __ne__(self, other):
13073 
    return not (self == other)
13074 
 
13075 
class getSimilarItemsCatalogIds_result:
13076 
  """
13077 
  Attributes:
13078 
   - success
13079 
  """
13080 
 
13081 
  thrift_spec = (
13082 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
13083 
  )
13084 
 
13085 
  def __init__(self, success=None,):
13086 
    self.success = success
13087 
 
13088 
  def read(self, iprot):
13089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13091 
      return
13092 
    iprot.readStructBegin()
13093 
    while True:
13094 
      (fname, ftype, fid) = iprot.readFieldBegin()
13095 
      if ftype == TType.STOP:
13096 
        break
13097 
      if fid == 0:
13098 
        if ftype == TType.LIST:
13099 
          self.success = []
7438 amit.gupta 13100 
          (_etype219, _size216) = iprot.readListBegin()
13101 
          for _i220 in xrange(_size216):
13102 
            _elem221 = iprot.readI64();
13103 
            self.success.append(_elem221)
5944 mandeep.dh 13104 
          iprot.readListEnd()
13105 
        else:
13106 
          iprot.skip(ftype)
13107 
      else:
13108 
        iprot.skip(ftype)
13109 
      iprot.readFieldEnd()
13110 
    iprot.readStructEnd()
13111 
 
13112 
  def write(self, oprot):
13113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13115 
      return
13116 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
13117 
    if self.success is not None:
13118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13119 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 13120 
      for iter222 in self.success:
13121 
        oprot.writeI64(iter222)
5944 mandeep.dh 13122 
      oprot.writeListEnd()
13123 
      oprot.writeFieldEnd()
13124 
    oprot.writeFieldStop()
13125 
    oprot.writeStructEnd()
13126 
 
13127 
  def validate(self):
13128 
    return
13129 
 
13130 
 
13131 
  def __repr__(self):
13132 
    L = ['%s=%r' % (key, value)
13133 
      for key, value in self.__dict__.iteritems()]
13134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13135 
 
13136 
  def __eq__(self, other):
13137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13138 
 
13139 
  def __ne__(self, other):
13140 
    return not (self == other)
13141 
 
13142 
class addProductNotification_args:
13143 
  """
13144 
  Attributes:
13145 
   - itemId
13146 
   - email
13147 
  """
13148 
 
13149 
  thrift_spec = None
13150 
  def __init__(self, itemId=None, email=None,):
13151 
    self.itemId = itemId
13152 
    self.email = email
13153 
 
13154 
  def read(self, iprot):
13155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13157 
      return
13158 
    iprot.readStructBegin()
13159 
    while True:
13160 
      (fname, ftype, fid) = iprot.readFieldBegin()
13161 
      if ftype == TType.STOP:
13162 
        break
13163 
      if fid == -1:
13164 
        if ftype == TType.I64:
13165 
          self.itemId = iprot.readI64();
13166 
        else:
13167 
          iprot.skip(ftype)
13168 
      elif fid == -2:
13169 
        if ftype == TType.STRING:
13170 
          self.email = iprot.readString();
13171 
        else:
13172 
          iprot.skip(ftype)
13173 
      else:
13174 
        iprot.skip(ftype)
13175 
      iprot.readFieldEnd()
13176 
    iprot.readStructEnd()
13177 
 
13178 
  def write(self, oprot):
13179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13181 
      return
13182 
    oprot.writeStructBegin('addProductNotification_args')
13183 
    if self.email is not None:
13184 
      oprot.writeFieldBegin('email', TType.STRING, -2)
13185 
      oprot.writeString(self.email)
13186 
      oprot.writeFieldEnd()
13187 
    if self.itemId is not None:
13188 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
13189 
      oprot.writeI64(self.itemId)
13190 
      oprot.writeFieldEnd()
13191 
    oprot.writeFieldStop()
13192 
    oprot.writeStructEnd()
13193 
 
13194 
  def validate(self):
13195 
    return
13196 
 
13197 
 
13198 
  def __repr__(self):
13199 
    L = ['%s=%r' % (key, value)
13200 
      for key, value in self.__dict__.iteritems()]
13201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13202 
 
13203 
  def __eq__(self, other):
13204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13205 
 
13206 
  def __ne__(self, other):
13207 
    return not (self == other)
13208 
 
13209 
class addProductNotification_result:
13210 
  """
13211 
  Attributes:
13212 
   - success
13213 
  """
13214 
 
13215 
  thrift_spec = (
13216 
    (0, TType.BOOL, 'success', None, None, ), # 0
13217 
  )
13218 
 
13219 
  def __init__(self, success=None,):
13220 
    self.success = success
13221 
 
13222 
  def read(self, iprot):
13223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13225 
      return
13226 
    iprot.readStructBegin()
13227 
    while True:
13228 
      (fname, ftype, fid) = iprot.readFieldBegin()
13229 
      if ftype == TType.STOP:
13230 
        break
13231 
      if fid == 0:
13232 
        if ftype == TType.BOOL:
13233 
          self.success = iprot.readBool();
13234 
        else:
13235 
          iprot.skip(ftype)
13236 
      else:
13237 
        iprot.skip(ftype)
13238 
      iprot.readFieldEnd()
13239 
    iprot.readStructEnd()
13240 
 
13241 
  def write(self, oprot):
13242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13244 
      return
13245 
    oprot.writeStructBegin('addProductNotification_result')
13246 
    if self.success is not None:
13247 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13248 
      oprot.writeBool(self.success)
13249 
      oprot.writeFieldEnd()
13250 
    oprot.writeFieldStop()
13251 
    oprot.writeStructEnd()
13252 
 
13253 
  def validate(self):
13254 
    return
13255 
 
13256 
 
13257 
  def __repr__(self):
13258 
    L = ['%s=%r' % (key, value)
13259 
      for key, value in self.__dict__.iteritems()]
13260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13261 
 
13262 
  def __eq__(self, other):
13263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13264 
 
13265 
  def __ne__(self, other):
13266 
    return not (self == other)
13267 
 
13268 
class sendProductNotifications_args:
13269 
 
13270 
  thrift_spec = (
13271 
  )
13272 
 
13273 
  def read(self, iprot):
13274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13276 
      return
13277 
    iprot.readStructBegin()
13278 
    while True:
13279 
      (fname, ftype, fid) = iprot.readFieldBegin()
13280 
      if ftype == TType.STOP:
13281 
        break
13282 
      else:
13283 
        iprot.skip(ftype)
13284 
      iprot.readFieldEnd()
13285 
    iprot.readStructEnd()
13286 
 
13287 
  def write(self, oprot):
13288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13290 
      return
13291 
    oprot.writeStructBegin('sendProductNotifications_args')
13292 
    oprot.writeFieldStop()
13293 
    oprot.writeStructEnd()
13294 
 
13295 
  def validate(self):
13296 
    return
13297 
 
13298 
 
13299 
  def __repr__(self):
13300 
    L = ['%s=%r' % (key, value)
13301 
      for key, value in self.__dict__.iteritems()]
13302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13303 
 
13304 
  def __eq__(self, other):
13305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13306 
 
13307 
  def __ne__(self, other):
13308 
    return not (self == other)
13309 
 
13310 
class sendProductNotifications_result:
13311 
  """
13312 
  Attributes:
13313 
   - success
13314 
  """
13315 
 
13316 
  thrift_spec = (
13317 
    (0, TType.BOOL, 'success', None, None, ), # 0
13318 
  )
13319 
 
13320 
  def __init__(self, success=None,):
13321 
    self.success = success
13322 
 
13323 
  def read(self, iprot):
13324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13326 
      return
13327 
    iprot.readStructBegin()
13328 
    while True:
13329 
      (fname, ftype, fid) = iprot.readFieldBegin()
13330 
      if ftype == TType.STOP:
13331 
        break
13332 
      if fid == 0:
13333 
        if ftype == TType.BOOL:
13334 
          self.success = iprot.readBool();
13335 
        else:
13336 
          iprot.skip(ftype)
13337 
      else:
13338 
        iprot.skip(ftype)
13339 
      iprot.readFieldEnd()
13340 
    iprot.readStructEnd()
13341 
 
13342 
  def write(self, oprot):
13343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13345 
      return
13346 
    oprot.writeStructBegin('sendProductNotifications_result')
13347 
    if self.success is not None:
13348 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13349 
      oprot.writeBool(self.success)
13350 
      oprot.writeFieldEnd()
13351 
    oprot.writeFieldStop()
13352 
    oprot.writeStructEnd()
13353 
 
13354 
  def validate(self):
13355 
    return
13356 
 
13357 
 
13358 
  def __repr__(self):
13359 
    L = ['%s=%r' % (key, value)
13360 
      for key, value in self.__dict__.iteritems()]
13361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13362 
 
13363 
  def __eq__(self, other):
13364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13365 
 
13366 
  def __ne__(self, other):
13367 
    return not (self == other)
13368 
 
13369 
class getAllBrandsByCategory_args:
13370 
  """
13371 
  Attributes:
13372 
   - categoryId
13373 
  """
13374 
 
13375 
  thrift_spec = (
13376 
    None, # 0
13377 
    (1, TType.I64, 'categoryId', None, None, ), # 1
13378 
  )
13379 
 
13380 
  def __init__(self, categoryId=None,):
13381 
    self.categoryId = categoryId
13382 
 
13383 
  def read(self, iprot):
13384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13386 
      return
13387 
    iprot.readStructBegin()
13388 
    while True:
13389 
      (fname, ftype, fid) = iprot.readFieldBegin()
13390 
      if ftype == TType.STOP:
13391 
        break
13392 
      if fid == 1:
13393 
        if ftype == TType.I64:
13394 
          self.categoryId = iprot.readI64();
13395 
        else:
13396 
          iprot.skip(ftype)
13397 
      else:
13398 
        iprot.skip(ftype)
13399 
      iprot.readFieldEnd()
13400 
    iprot.readStructEnd()
13401 
 
13402 
  def write(self, oprot):
13403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13405 
      return
13406 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
13407 
    if self.categoryId is not None:
13408 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
13409 
      oprot.writeI64(self.categoryId)
13410 
      oprot.writeFieldEnd()
13411 
    oprot.writeFieldStop()
13412 
    oprot.writeStructEnd()
13413 
 
13414 
  def validate(self):
13415 
    return
13416 
 
13417 
 
13418 
  def __repr__(self):
13419 
    L = ['%s=%r' % (key, value)
13420 
      for key, value in self.__dict__.iteritems()]
13421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13422 
 
13423 
  def __eq__(self, other):
13424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13425 
 
13426 
  def __ne__(self, other):
13427 
    return not (self == other)
13428 
 
13429 
class getAllBrandsByCategory_result:
13430 
  """
13431 
  Attributes:
13432 
   - success
13433 
  """
13434 
 
13435 
  thrift_spec = (
13436 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13437 
  )
13438 
 
13439 
  def __init__(self, success=None,):
13440 
    self.success = success
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 == 0:
13452 
        if ftype == TType.LIST:
13453 
          self.success = []
7438 amit.gupta 13454 
          (_etype226, _size223) = iprot.readListBegin()
13455 
          for _i227 in xrange(_size223):
13456 
            _elem228 = iprot.readString();
13457 
            self.success.append(_elem228)
5944 mandeep.dh 13458 
          iprot.readListEnd()
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('getAllBrandsByCategory_result')
13471 
    if self.success is not None:
13472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13473 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13474 
      for iter229 in self.success:
13475 
        oprot.writeString(iter229)
5944 mandeep.dh 13476 
      oprot.writeListEnd()
13477 
      oprot.writeFieldEnd()
13478 
    oprot.writeFieldStop()
13479 
    oprot.writeStructEnd()
13480 
 
13481 
  def validate(self):
13482 
    return
13483 
 
13484 
 
13485 
  def __repr__(self):
13486 
    L = ['%s=%r' % (key, value)
13487 
      for key, value in self.__dict__.iteritems()]
13488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13489 
 
13490 
  def __eq__(self, other):
13491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13492 
 
13493 
  def __ne__(self, other):
13494 
    return not (self == other)
13495 
 
13496 
class getAllBrands_args:
13497 
 
13498 
  thrift_spec = (
13499 
  )
13500 
 
13501 
  def read(self, iprot):
13502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13504 
      return
13505 
    iprot.readStructBegin()
13506 
    while True:
13507 
      (fname, ftype, fid) = iprot.readFieldBegin()
13508 
      if ftype == TType.STOP:
13509 
        break
13510 
      else:
13511 
        iprot.skip(ftype)
13512 
      iprot.readFieldEnd()
13513 
    iprot.readStructEnd()
13514 
 
13515 
  def write(self, oprot):
13516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13518 
      return
13519 
    oprot.writeStructBegin('getAllBrands_args')
13520 
    oprot.writeFieldStop()
13521 
    oprot.writeStructEnd()
13522 
 
13523 
  def validate(self):
13524 
    return
13525 
 
13526 
 
13527 
  def __repr__(self):
13528 
    L = ['%s=%r' % (key, value)
13529 
      for key, value in self.__dict__.iteritems()]
13530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13531 
 
13532 
  def __eq__(self, other):
13533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13534 
 
13535 
  def __ne__(self, other):
13536 
    return not (self == other)
13537 
 
13538 
class getAllBrands_result:
13539 
  """
13540 
  Attributes:
13541 
   - success
13542 
  """
13543 
 
13544 
  thrift_spec = (
13545 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13546 
  )
13547 
 
13548 
  def __init__(self, success=None,):
13549 
    self.success = success
13550 
 
13551 
  def read(self, iprot):
13552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13554 
      return
13555 
    iprot.readStructBegin()
13556 
    while True:
13557 
      (fname, ftype, fid) = iprot.readFieldBegin()
13558 
      if ftype == TType.STOP:
13559 
        break
13560 
      if fid == 0:
13561 
        if ftype == TType.LIST:
13562 
          self.success = []
7438 amit.gupta 13563 
          (_etype233, _size230) = iprot.readListBegin()
13564 
          for _i234 in xrange(_size230):
13565 
            _elem235 = iprot.readString();
13566 
            self.success.append(_elem235)
5944 mandeep.dh 13567 
          iprot.readListEnd()
13568 
        else:
13569 
          iprot.skip(ftype)
13570 
      else:
13571 
        iprot.skip(ftype)
13572 
      iprot.readFieldEnd()
13573 
    iprot.readStructEnd()
13574 
 
13575 
  def write(self, oprot):
13576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13578 
      return
13579 
    oprot.writeStructBegin('getAllBrands_result')
13580 
    if self.success is not None:
13581 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13582 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13583 
      for iter236 in self.success:
13584 
        oprot.writeString(iter236)
5944 mandeep.dh 13585 
      oprot.writeListEnd()
13586 
      oprot.writeFieldEnd()
13587 
    oprot.writeFieldStop()
13588 
    oprot.writeStructEnd()
13589 
 
13590 
  def validate(self):
13591 
    return
13592 
 
13593 
 
13594 
  def __repr__(self):
13595 
    L = ['%s=%r' % (key, value)
13596 
      for key, value in self.__dict__.iteritems()]
13597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13598 
 
13599 
  def __eq__(self, other):
13600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13601 
 
13602 
  def __ne__(self, other):
13603 
    return not (self == other)
13604 
 
13605 
class getAllSources_args:
13606 
 
13607 
  thrift_spec = (
13608 
  )
13609 
 
13610 
  def read(self, iprot):
13611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13613 
      return
13614 
    iprot.readStructBegin()
13615 
    while True:
13616 
      (fname, ftype, fid) = iprot.readFieldBegin()
13617 
      if ftype == TType.STOP:
13618 
        break
13619 
      else:
13620 
        iprot.skip(ftype)
13621 
      iprot.readFieldEnd()
13622 
    iprot.readStructEnd()
13623 
 
13624 
  def write(self, oprot):
13625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13627 
      return
13628 
    oprot.writeStructBegin('getAllSources_args')
13629 
    oprot.writeFieldStop()
13630 
    oprot.writeStructEnd()
13631 
 
13632 
  def validate(self):
13633 
    return
13634 
 
13635 
 
13636 
  def __repr__(self):
13637 
    L = ['%s=%r' % (key, value)
13638 
      for key, value in self.__dict__.iteritems()]
13639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13640 
 
13641 
  def __eq__(self, other):
13642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13643 
 
13644 
  def __ne__(self, other):
13645 
    return not (self == other)
13646 
 
13647 
class getAllSources_result:
13648 
  """
13649 
  Attributes:
13650 
   - success
13651 
  """
13652 
 
13653 
  thrift_spec = (
13654 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13655 
  )
13656 
 
13657 
  def __init__(self, success=None,):
13658 
    self.success = success
13659 
 
13660 
  def read(self, iprot):
13661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13663 
      return
13664 
    iprot.readStructBegin()
13665 
    while True:
13666 
      (fname, ftype, fid) = iprot.readFieldBegin()
13667 
      if ftype == TType.STOP:
13668 
        break
13669 
      if fid == 0:
13670 
        if ftype == TType.LIST:
13671 
          self.success = []
7438 amit.gupta 13672 
          (_etype240, _size237) = iprot.readListBegin()
13673 
          for _i241 in xrange(_size237):
13674 
            _elem242 = Source()
13675 
            _elem242.read(iprot)
13676 
            self.success.append(_elem242)
5944 mandeep.dh 13677 
          iprot.readListEnd()
13678 
        else:
13679 
          iprot.skip(ftype)
13680 
      else:
13681 
        iprot.skip(ftype)
13682 
      iprot.readFieldEnd()
13683 
    iprot.readStructEnd()
13684 
 
13685 
  def write(self, oprot):
13686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13688 
      return
13689 
    oprot.writeStructBegin('getAllSources_result')
13690 
    if self.success is not None:
13691 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13692 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13693 
      for iter243 in self.success:
13694 
        iter243.write(oprot)
5944 mandeep.dh 13695 
      oprot.writeListEnd()
13696 
      oprot.writeFieldEnd()
13697 
    oprot.writeFieldStop()
13698 
    oprot.writeStructEnd()
13699 
 
13700 
  def validate(self):
13701 
    return
13702 
 
13703 
 
13704 
  def __repr__(self):
13705 
    L = ['%s=%r' % (key, value)
13706 
      for key, value in self.__dict__.iteritems()]
13707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13708 
 
13709 
  def __eq__(self, other):
13710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13711 
 
13712 
  def __ne__(self, other):
13713 
    return not (self == other)
13714 
 
13715 
class getItemPricingBySource_args:
13716 
  """
13717 
  Attributes:
13718 
   - itemId
13719 
   - sourceId
13720 
  """
13721 
 
13722 
  thrift_spec = (
13723 
    None, # 0
13724 
    (1, TType.I64, 'itemId', None, None, ), # 1
13725 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13726 
  )
13727 
 
13728 
  def __init__(self, itemId=None, sourceId=None,):
13729 
    self.itemId = itemId
13730 
    self.sourceId = sourceId
13731 
 
13732 
  def read(self, iprot):
13733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13735 
      return
13736 
    iprot.readStructBegin()
13737 
    while True:
13738 
      (fname, ftype, fid) = iprot.readFieldBegin()
13739 
      if ftype == TType.STOP:
13740 
        break
13741 
      if fid == 1:
13742 
        if ftype == TType.I64:
13743 
          self.itemId = iprot.readI64();
13744 
        else:
13745 
          iprot.skip(ftype)
13746 
      elif fid == 2:
13747 
        if ftype == TType.I64:
13748 
          self.sourceId = iprot.readI64();
13749 
        else:
13750 
          iprot.skip(ftype)
13751 
      else:
13752 
        iprot.skip(ftype)
13753 
      iprot.readFieldEnd()
13754 
    iprot.readStructEnd()
13755 
 
13756 
  def write(self, oprot):
13757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13759 
      return
13760 
    oprot.writeStructBegin('getItemPricingBySource_args')
13761 
    if self.itemId is not None:
13762 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13763 
      oprot.writeI64(self.itemId)
13764 
      oprot.writeFieldEnd()
13765 
    if self.sourceId is not None:
13766 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13767 
      oprot.writeI64(self.sourceId)
13768 
      oprot.writeFieldEnd()
13769 
    oprot.writeFieldStop()
13770 
    oprot.writeStructEnd()
13771 
 
13772 
  def validate(self):
13773 
    return
13774 
 
13775 
 
13776 
  def __repr__(self):
13777 
    L = ['%s=%r' % (key, value)
13778 
      for key, value in self.__dict__.iteritems()]
13779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13780 
 
13781 
  def __eq__(self, other):
13782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13783 
 
13784 
  def __ne__(self, other):
13785 
    return not (self == other)
13786 
 
13787 
class getItemPricingBySource_result:
13788 
  """
13789 
  Attributes:
13790 
   - success
13791 
   - cex
13792 
  """
13793 
 
13794 
  thrift_spec = (
13795 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13796 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13797 
  )
13798 
 
13799 
  def __init__(self, success=None, cex=None,):
13800 
    self.success = success
13801 
    self.cex = cex
13802 
 
13803 
  def read(self, iprot):
13804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13806 
      return
13807 
    iprot.readStructBegin()
13808 
    while True:
13809 
      (fname, ftype, fid) = iprot.readFieldBegin()
13810 
      if ftype == TType.STOP:
13811 
        break
13812 
      if fid == 0:
13813 
        if ftype == TType.STRUCT:
13814 
          self.success = SourceItemPricing()
13815 
          self.success.read(iprot)
13816 
        else:
13817 
          iprot.skip(ftype)
13818 
      elif fid == 1:
13819 
        if ftype == TType.STRUCT:
13820 
          self.cex = CatalogServiceException()
13821 
          self.cex.read(iprot)
13822 
        else:
13823 
          iprot.skip(ftype)
13824 
      else:
13825 
        iprot.skip(ftype)
13826 
      iprot.readFieldEnd()
13827 
    iprot.readStructEnd()
13828 
 
13829 
  def write(self, oprot):
13830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13832 
      return
13833 
    oprot.writeStructBegin('getItemPricingBySource_result')
13834 
    if self.success is not None:
13835 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13836 
      self.success.write(oprot)
13837 
      oprot.writeFieldEnd()
13838 
    if self.cex is not None:
13839 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13840 
      self.cex.write(oprot)
13841 
      oprot.writeFieldEnd()
13842 
    oprot.writeFieldStop()
13843 
    oprot.writeStructEnd()
13844 
 
13845 
  def validate(self):
13846 
    return
13847 
 
13848 
 
13849 
  def __repr__(self):
13850 
    L = ['%s=%r' % (key, value)
13851 
      for key, value in self.__dict__.iteritems()]
13852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13853 
 
13854 
  def __eq__(self, other):
13855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13856 
 
13857 
  def __ne__(self, other):
13858 
    return not (self == other)
13859 
 
13860 
class addSourceItemPricing_args:
13861 
  """
13862 
  Attributes:
13863 
   - sourceItemPricing
13864 
  """
13865 
 
13866 
  thrift_spec = (
13867 
    None, # 0
13868 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13869 
  )
13870 
 
13871 
  def __init__(self, sourceItemPricing=None,):
13872 
    self.sourceItemPricing = sourceItemPricing
13873 
 
13874 
  def read(self, iprot):
13875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13877 
      return
13878 
    iprot.readStructBegin()
13879 
    while True:
13880 
      (fname, ftype, fid) = iprot.readFieldBegin()
13881 
      if ftype == TType.STOP:
13882 
        break
13883 
      if fid == 1:
13884 
        if ftype == TType.STRUCT:
13885 
          self.sourceItemPricing = SourceItemPricing()
13886 
          self.sourceItemPricing.read(iprot)
13887 
        else:
13888 
          iprot.skip(ftype)
13889 
      else:
13890 
        iprot.skip(ftype)
13891 
      iprot.readFieldEnd()
13892 
    iprot.readStructEnd()
13893 
 
13894 
  def write(self, oprot):
13895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13897 
      return
13898 
    oprot.writeStructBegin('addSourceItemPricing_args')
13899 
    if self.sourceItemPricing is not None:
13900 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13901 
      self.sourceItemPricing.write(oprot)
13902 
      oprot.writeFieldEnd()
13903 
    oprot.writeFieldStop()
13904 
    oprot.writeStructEnd()
13905 
 
13906 
  def validate(self):
13907 
    return
13908 
 
13909 
 
13910 
  def __repr__(self):
13911 
    L = ['%s=%r' % (key, value)
13912 
      for key, value in self.__dict__.iteritems()]
13913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13914 
 
13915 
  def __eq__(self, other):
13916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13917 
 
13918 
  def __ne__(self, other):
13919 
    return not (self == other)
13920 
 
13921 
class addSourceItemPricing_result:
13922 
  """
13923 
  Attributes:
13924 
   - cex
13925 
  """
13926 
 
13927 
  thrift_spec = (
13928 
    None, # 0
13929 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13930 
  )
13931 
 
13932 
  def __init__(self, cex=None,):
13933 
    self.cex = cex
13934 
 
13935 
  def read(self, iprot):
13936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13938 
      return
13939 
    iprot.readStructBegin()
13940 
    while True:
13941 
      (fname, ftype, fid) = iprot.readFieldBegin()
13942 
      if ftype == TType.STOP:
13943 
        break
13944 
      if fid == 1:
13945 
        if ftype == TType.STRUCT:
13946 
          self.cex = CatalogServiceException()
13947 
          self.cex.read(iprot)
13948 
        else:
13949 
          iprot.skip(ftype)
13950 
      else:
13951 
        iprot.skip(ftype)
13952 
      iprot.readFieldEnd()
13953 
    iprot.readStructEnd()
13954 
 
13955 
  def write(self, oprot):
13956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13958 
      return
13959 
    oprot.writeStructBegin('addSourceItemPricing_result')
13960 
    if self.cex is not None:
13961 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13962 
      self.cex.write(oprot)
13963 
      oprot.writeFieldEnd()
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 getAllSourcePricing_args:
13983 
  """
13984 
  Attributes:
13985 
   - itemId
13986 
  """
13987 
 
13988 
  thrift_spec = (
13989 
    None, # 0
13990 
    (1, TType.I64, 'itemId', None, None, ), # 1
13991 
  )
13992 
 
13993 
  def __init__(self, itemId=None,):
13994 
    self.itemId = itemId
13995 
 
13996 
  def read(self, iprot):
13997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13999 
      return
14000 
    iprot.readStructBegin()
14001 
    while True:
14002 
      (fname, ftype, fid) = iprot.readFieldBegin()
14003 
      if ftype == TType.STOP:
14004 
        break
14005 
      if fid == 1:
14006 
        if ftype == TType.I64:
14007 
          self.itemId = iprot.readI64();
14008 
        else:
14009 
          iprot.skip(ftype)
14010 
      else:
14011 
        iprot.skip(ftype)
14012 
      iprot.readFieldEnd()
14013 
    iprot.readStructEnd()
14014 
 
14015 
  def write(self, oprot):
14016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14018 
      return
14019 
    oprot.writeStructBegin('getAllSourcePricing_args')
14020 
    if self.itemId is not None:
14021 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14022 
      oprot.writeI64(self.itemId)
14023 
      oprot.writeFieldEnd()
14024 
    oprot.writeFieldStop()
14025 
    oprot.writeStructEnd()
14026 
 
14027 
  def validate(self):
14028 
    return
14029 
 
14030 
 
14031 
  def __repr__(self):
14032 
    L = ['%s=%r' % (key, value)
14033 
      for key, value in self.__dict__.iteritems()]
14034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14035 
 
14036 
  def __eq__(self, other):
14037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14038 
 
14039 
  def __ne__(self, other):
14040 
    return not (self == other)
14041 
 
14042 
class getAllSourcePricing_result:
14043 
  """
14044 
  Attributes:
14045 
   - success
14046 
   - cex
14047 
  """
14048 
 
14049 
  thrift_spec = (
14050 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
14051 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14052 
  )
14053 
 
14054 
  def __init__(self, success=None, cex=None,):
14055 
    self.success = success
14056 
    self.cex = cex
14057 
 
14058 
  def read(self, iprot):
14059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14061 
      return
14062 
    iprot.readStructBegin()
14063 
    while True:
14064 
      (fname, ftype, fid) = iprot.readFieldBegin()
14065 
      if ftype == TType.STOP:
14066 
        break
14067 
      if fid == 0:
14068 
        if ftype == TType.LIST:
14069 
          self.success = []
7438 amit.gupta 14070 
          (_etype247, _size244) = iprot.readListBegin()
14071 
          for _i248 in xrange(_size244):
14072 
            _elem249 = SourceItemPricing()
14073 
            _elem249.read(iprot)
14074 
            self.success.append(_elem249)
5944 mandeep.dh 14075 
          iprot.readListEnd()
14076 
        else:
14077 
          iprot.skip(ftype)
14078 
      elif fid == 1:
14079 
        if ftype == TType.STRUCT:
14080 
          self.cex = CatalogServiceException()
14081 
          self.cex.read(iprot)
14082 
        else:
14083 
          iprot.skip(ftype)
14084 
      else:
14085 
        iprot.skip(ftype)
14086 
      iprot.readFieldEnd()
14087 
    iprot.readStructEnd()
14088 
 
14089 
  def write(self, oprot):
14090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14092 
      return
14093 
    oprot.writeStructBegin('getAllSourcePricing_result')
14094 
    if self.success is not None:
14095 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14096 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14097 
      for iter250 in self.success:
14098 
        iter250.write(oprot)
5944 mandeep.dh 14099 
      oprot.writeListEnd()
14100 
      oprot.writeFieldEnd()
14101 
    if self.cex is not None:
14102 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14103 
      self.cex.write(oprot)
14104 
      oprot.writeFieldEnd()
14105 
    oprot.writeFieldStop()
14106 
    oprot.writeStructEnd()
14107 
 
14108 
  def validate(self):
14109 
    return
14110 
 
14111 
 
14112 
  def __repr__(self):
14113 
    L = ['%s=%r' % (key, value)
14114 
      for key, value in self.__dict__.iteritems()]
14115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14116 
 
14117 
  def __eq__(self, other):
14118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14119 
 
14120 
  def __ne__(self, other):
14121 
    return not (self == other)
14122 
 
14123 
class getItemForSource_args:
14124 
  """
14125 
  Attributes:
14126 
   - item_id
14127 
   - sourceId
14128 
  """
14129 
 
14130 
  thrift_spec = (
14131 
    None, # 0
14132 
    (1, TType.I64, 'item_id', None, None, ), # 1
14133 
    (2, TType.I64, 'sourceId', None, None, ), # 2
14134 
  )
14135 
 
14136 
  def __init__(self, item_id=None, sourceId=None,):
14137 
    self.item_id = item_id
14138 
    self.sourceId = sourceId
14139 
 
14140 
  def read(self, iprot):
14141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14143 
      return
14144 
    iprot.readStructBegin()
14145 
    while True:
14146 
      (fname, ftype, fid) = iprot.readFieldBegin()
14147 
      if ftype == TType.STOP:
14148 
        break
14149 
      if fid == 1:
14150 
        if ftype == TType.I64:
14151 
          self.item_id = iprot.readI64();
14152 
        else:
14153 
          iprot.skip(ftype)
14154 
      elif fid == 2:
14155 
        if ftype == TType.I64:
14156 
          self.sourceId = iprot.readI64();
14157 
        else:
14158 
          iprot.skip(ftype)
14159 
      else:
14160 
        iprot.skip(ftype)
14161 
      iprot.readFieldEnd()
14162 
    iprot.readStructEnd()
14163 
 
14164 
  def write(self, oprot):
14165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14167 
      return
14168 
    oprot.writeStructBegin('getItemForSource_args')
14169 
    if self.item_id is not None:
14170 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
14171 
      oprot.writeI64(self.item_id)
14172 
      oprot.writeFieldEnd()
14173 
    if self.sourceId is not None:
14174 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
14175 
      oprot.writeI64(self.sourceId)
14176 
      oprot.writeFieldEnd()
14177 
    oprot.writeFieldStop()
14178 
    oprot.writeStructEnd()
14179 
 
14180 
  def validate(self):
14181 
    return
14182 
 
14183 
 
14184 
  def __repr__(self):
14185 
    L = ['%s=%r' % (key, value)
14186 
      for key, value in self.__dict__.iteritems()]
14187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14188 
 
14189 
  def __eq__(self, other):
14190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14191 
 
14192 
  def __ne__(self, other):
14193 
    return not (self == other)
14194 
 
14195 
class getItemForSource_result:
14196 
  """
14197 
  Attributes:
14198 
   - success
14199 
   - cex
14200 
  """
14201 
 
14202 
  thrift_spec = (
14203 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
14204 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14205 
  )
14206 
 
14207 
  def __init__(self, success=None, cex=None,):
14208 
    self.success = success
14209 
    self.cex = cex
14210 
 
14211 
  def read(self, iprot):
14212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14214 
      return
14215 
    iprot.readStructBegin()
14216 
    while True:
14217 
      (fname, ftype, fid) = iprot.readFieldBegin()
14218 
      if ftype == TType.STOP:
14219 
        break
14220 
      if fid == 0:
14221 
        if ftype == TType.STRUCT:
14222 
          self.success = Item()
14223 
          self.success.read(iprot)
14224 
        else:
14225 
          iprot.skip(ftype)
14226 
      elif fid == 1:
14227 
        if ftype == TType.STRUCT:
14228 
          self.cex = CatalogServiceException()
14229 
          self.cex.read(iprot)
14230 
        else:
14231 
          iprot.skip(ftype)
14232 
      else:
14233 
        iprot.skip(ftype)
14234 
      iprot.readFieldEnd()
14235 
    iprot.readStructEnd()
14236 
 
14237 
  def write(self, oprot):
14238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14240 
      return
14241 
    oprot.writeStructBegin('getItemForSource_result')
14242 
    if self.success is not None:
14243 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
14244 
      self.success.write(oprot)
14245 
      oprot.writeFieldEnd()
14246 
    if self.cex is not None:
14247 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14248 
      self.cex.write(oprot)
14249 
      oprot.writeFieldEnd()
14250 
    oprot.writeFieldStop()
14251 
    oprot.writeStructEnd()
14252 
 
14253 
  def validate(self):
14254 
    return
14255 
 
14256 
 
14257 
  def __repr__(self):
14258 
    L = ['%s=%r' % (key, value)
14259 
      for key, value in self.__dict__.iteritems()]
14260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14261 
 
14262 
  def __eq__(self, other):
14263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14264 
 
14265 
  def __ne__(self, other):
14266 
    return not (self == other)
14267 
 
14268 
class searchItemsInRange_args:
14269 
  """
14270 
  Attributes:
14271 
   - searchTerms
14272 
   - offset
14273 
   - limit
14274 
  """
14275 
 
14276 
  thrift_spec = (
14277 
    None, # 0
14278 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14279 
    (2, TType.I64, 'offset', None, None, ), # 2
14280 
    (3, TType.I64, 'limit', None, None, ), # 3
14281 
  )
14282 
 
14283 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
14284 
    self.searchTerms = searchTerms
14285 
    self.offset = offset
14286 
    self.limit = limit
14287 
 
14288 
  def read(self, iprot):
14289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14291 
      return
14292 
    iprot.readStructBegin()
14293 
    while True:
14294 
      (fname, ftype, fid) = iprot.readFieldBegin()
14295 
      if ftype == TType.STOP:
14296 
        break
14297 
      if fid == 1:
14298 
        if ftype == TType.LIST:
14299 
          self.searchTerms = []
7438 amit.gupta 14300 
          (_etype254, _size251) = iprot.readListBegin()
14301 
          for _i255 in xrange(_size251):
14302 
            _elem256 = iprot.readString();
14303 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 14304 
          iprot.readListEnd()
14305 
        else:
14306 
          iprot.skip(ftype)
14307 
      elif fid == 2:
14308 
        if ftype == TType.I64:
14309 
          self.offset = iprot.readI64();
14310 
        else:
14311 
          iprot.skip(ftype)
14312 
      elif fid == 3:
14313 
        if ftype == TType.I64:
14314 
          self.limit = iprot.readI64();
14315 
        else:
14316 
          iprot.skip(ftype)
14317 
      else:
14318 
        iprot.skip(ftype)
14319 
      iprot.readFieldEnd()
14320 
    iprot.readStructEnd()
14321 
 
14322 
  def write(self, oprot):
14323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14325 
      return
14326 
    oprot.writeStructBegin('searchItemsInRange_args')
14327 
    if self.searchTerms is not None:
14328 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14329 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14330 
      for iter257 in self.searchTerms:
14331 
        oprot.writeString(iter257)
5944 mandeep.dh 14332 
      oprot.writeListEnd()
14333 
      oprot.writeFieldEnd()
14334 
    if self.offset is not None:
14335 
      oprot.writeFieldBegin('offset', TType.I64, 2)
14336 
      oprot.writeI64(self.offset)
14337 
      oprot.writeFieldEnd()
14338 
    if self.limit is not None:
14339 
      oprot.writeFieldBegin('limit', TType.I64, 3)
14340 
      oprot.writeI64(self.limit)
14341 
      oprot.writeFieldEnd()
14342 
    oprot.writeFieldStop()
14343 
    oprot.writeStructEnd()
14344 
 
14345 
  def validate(self):
14346 
    return
14347 
 
14348 
 
14349 
  def __repr__(self):
14350 
    L = ['%s=%r' % (key, value)
14351 
      for key, value in self.__dict__.iteritems()]
14352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14353 
 
14354 
  def __eq__(self, other):
14355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14356 
 
14357 
  def __ne__(self, other):
14358 
    return not (self == other)
14359 
 
14360 
class searchItemsInRange_result:
14361 
  """
14362 
  Attributes:
14363 
   - success
14364 
  """
14365 
 
14366 
  thrift_spec = (
14367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14368 
  )
14369 
 
14370 
  def __init__(self, success=None,):
14371 
    self.success = success
14372 
 
14373 
  def read(self, iprot):
14374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14376 
      return
14377 
    iprot.readStructBegin()
14378 
    while True:
14379 
      (fname, ftype, fid) = iprot.readFieldBegin()
14380 
      if ftype == TType.STOP:
14381 
        break
14382 
      if fid == 0:
14383 
        if ftype == TType.LIST:
14384 
          self.success = []
7438 amit.gupta 14385 
          (_etype261, _size258) = iprot.readListBegin()
14386 
          for _i262 in xrange(_size258):
14387 
            _elem263 = Item()
14388 
            _elem263.read(iprot)
14389 
            self.success.append(_elem263)
5944 mandeep.dh 14390 
          iprot.readListEnd()
14391 
        else:
14392 
          iprot.skip(ftype)
14393 
      else:
14394 
        iprot.skip(ftype)
14395 
      iprot.readFieldEnd()
14396 
    iprot.readStructEnd()
14397 
 
14398 
  def write(self, oprot):
14399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14401 
      return
14402 
    oprot.writeStructBegin('searchItemsInRange_result')
14403 
    if self.success is not None:
14404 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14405 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14406 
      for iter264 in self.success:
14407 
        iter264.write(oprot)
5944 mandeep.dh 14408 
      oprot.writeListEnd()
14409 
      oprot.writeFieldEnd()
14410 
    oprot.writeFieldStop()
14411 
    oprot.writeStructEnd()
14412 
 
14413 
  def validate(self):
14414 
    return
14415 
 
14416 
 
14417 
  def __repr__(self):
14418 
    L = ['%s=%r' % (key, value)
14419 
      for key, value in self.__dict__.iteritems()]
14420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14421 
 
14422 
  def __eq__(self, other):
14423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14424 
 
14425 
  def __ne__(self, other):
14426 
    return not (self == other)
14427 
 
14428 
class getSearchResultCount_args:
14429 
  """
14430 
  Attributes:
14431 
   - searchTerms
14432 
  """
14433 
 
14434 
  thrift_spec = (
14435 
    None, # 0
14436 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14437 
  )
14438 
 
14439 
  def __init__(self, searchTerms=None,):
14440 
    self.searchTerms = searchTerms
14441 
 
14442 
  def read(self, iprot):
14443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14445 
      return
14446 
    iprot.readStructBegin()
14447 
    while True:
14448 
      (fname, ftype, fid) = iprot.readFieldBegin()
14449 
      if ftype == TType.STOP:
14450 
        break
14451 
      if fid == 1:
14452 
        if ftype == TType.LIST:
14453 
          self.searchTerms = []
7438 amit.gupta 14454 
          (_etype268, _size265) = iprot.readListBegin()
14455 
          for _i269 in xrange(_size265):
14456 
            _elem270 = iprot.readString();
14457 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 14458 
          iprot.readListEnd()
14459 
        else:
14460 
          iprot.skip(ftype)
14461 
      else:
14462 
        iprot.skip(ftype)
14463 
      iprot.readFieldEnd()
14464 
    iprot.readStructEnd()
14465 
 
14466 
  def write(self, oprot):
14467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14469 
      return
14470 
    oprot.writeStructBegin('getSearchResultCount_args')
14471 
    if self.searchTerms is not None:
14472 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14473 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14474 
      for iter271 in self.searchTerms:
14475 
        oprot.writeString(iter271)
5944 mandeep.dh 14476 
      oprot.writeListEnd()
14477 
      oprot.writeFieldEnd()
14478 
    oprot.writeFieldStop()
14479 
    oprot.writeStructEnd()
14480 
 
14481 
  def validate(self):
14482 
    return
14483 
 
14484 
 
14485 
  def __repr__(self):
14486 
    L = ['%s=%r' % (key, value)
14487 
      for key, value in self.__dict__.iteritems()]
14488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14489 
 
14490 
  def __eq__(self, other):
14491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14492 
 
14493 
  def __ne__(self, other):
14494 
    return not (self == other)
14495 
 
14496 
class getSearchResultCount_result:
14497 
  """
14498 
  Attributes:
14499 
   - success
14500 
  """
14501 
 
14502 
  thrift_spec = (
14503 
    (0, TType.I32, 'success', None, None, ), # 0
14504 
  )
14505 
 
14506 
  def __init__(self, success=None,):
14507 
    self.success = success
14508 
 
14509 
  def read(self, iprot):
14510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14512 
      return
14513 
    iprot.readStructBegin()
14514 
    while True:
14515 
      (fname, ftype, fid) = iprot.readFieldBegin()
14516 
      if ftype == TType.STOP:
14517 
        break
14518 
      if fid == 0:
14519 
        if ftype == TType.I32:
14520 
          self.success = iprot.readI32();
14521 
        else:
14522 
          iprot.skip(ftype)
14523 
      else:
14524 
        iprot.skip(ftype)
14525 
      iprot.readFieldEnd()
14526 
    iprot.readStructEnd()
14527 
 
14528 
  def write(self, oprot):
14529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14531 
      return
14532 
    oprot.writeStructBegin('getSearchResultCount_result')
14533 
    if self.success is not None:
14534 
      oprot.writeFieldBegin('success', TType.I32, 0)
14535 
      oprot.writeI32(self.success)
14536 
      oprot.writeFieldEnd()
14537 
    oprot.writeFieldStop()
14538 
    oprot.writeStructEnd()
14539 
 
14540 
  def validate(self):
14541 
    return
14542 
 
14543 
 
14544 
  def __repr__(self):
14545 
    L = ['%s=%r' % (key, value)
14546 
      for key, value in self.__dict__.iteritems()]
14547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14548 
 
14549 
  def __eq__(self, other):
14550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14551 
 
14552 
  def __ne__(self, other):
14553 
    return not (self == other)
14554 
 
14555 
class getProductNotifications_args:
14556 
  """
14557 
  Attributes:
14558 
   - startDateTime
14559 
  """
14560 
 
14561 
  thrift_spec = (
14562 
    None, # 0
14563 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14564 
  )
14565 
 
14566 
  def __init__(self, startDateTime=None,):
14567 
    self.startDateTime = startDateTime
14568 
 
14569 
  def read(self, iprot):
14570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14572 
      return
14573 
    iprot.readStructBegin()
14574 
    while True:
14575 
      (fname, ftype, fid) = iprot.readFieldBegin()
14576 
      if ftype == TType.STOP:
14577 
        break
14578 
      if fid == 1:
14579 
        if ftype == TType.I64:
14580 
          self.startDateTime = iprot.readI64();
14581 
        else:
14582 
          iprot.skip(ftype)
14583 
      else:
14584 
        iprot.skip(ftype)
14585 
      iprot.readFieldEnd()
14586 
    iprot.readStructEnd()
14587 
 
14588 
  def write(self, oprot):
14589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14591 
      return
14592 
    oprot.writeStructBegin('getProductNotifications_args')
14593 
    if self.startDateTime is not None:
14594 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14595 
      oprot.writeI64(self.startDateTime)
14596 
      oprot.writeFieldEnd()
14597 
    oprot.writeFieldStop()
14598 
    oprot.writeStructEnd()
14599 
 
14600 
  def validate(self):
14601 
    return
14602 
 
14603 
 
14604 
  def __repr__(self):
14605 
    L = ['%s=%r' % (key, value)
14606 
      for key, value in self.__dict__.iteritems()]
14607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14608 
 
14609 
  def __eq__(self, other):
14610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14611 
 
14612 
  def __ne__(self, other):
14613 
    return not (self == other)
14614 
 
14615 
class getProductNotifications_result:
14616 
  """
14617 
  Attributes:
14618 
   - success
14619 
  """
14620 
 
14621 
  thrift_spec = (
14622 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14623 
  )
14624 
 
14625 
  def __init__(self, success=None,):
14626 
    self.success = success
14627 
 
14628 
  def read(self, iprot):
14629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14631 
      return
14632 
    iprot.readStructBegin()
14633 
    while True:
14634 
      (fname, ftype, fid) = iprot.readFieldBegin()
14635 
      if ftype == TType.STOP:
14636 
        break
14637 
      if fid == 0:
14638 
        if ftype == TType.LIST:
14639 
          self.success = []
7438 amit.gupta 14640 
          (_etype275, _size272) = iprot.readListBegin()
14641 
          for _i276 in xrange(_size272):
14642 
            _elem277 = ProductNotificationRequest()
14643 
            _elem277.read(iprot)
14644 
            self.success.append(_elem277)
5944 mandeep.dh 14645 
          iprot.readListEnd()
14646 
        else:
14647 
          iprot.skip(ftype)
14648 
      else:
14649 
        iprot.skip(ftype)
14650 
      iprot.readFieldEnd()
14651 
    iprot.readStructEnd()
14652 
 
14653 
  def write(self, oprot):
14654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14656 
      return
14657 
    oprot.writeStructBegin('getProductNotifications_result')
14658 
    if self.success is not None:
14659 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14660 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14661 
      for iter278 in self.success:
14662 
        iter278.write(oprot)
5944 mandeep.dh 14663 
      oprot.writeListEnd()
14664 
      oprot.writeFieldEnd()
14665 
    oprot.writeFieldStop()
14666 
    oprot.writeStructEnd()
14667 
 
14668 
  def validate(self):
14669 
    return
14670 
 
14671 
 
14672 
  def __repr__(self):
14673 
    L = ['%s=%r' % (key, value)
14674 
      for key, value in self.__dict__.iteritems()]
14675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14676 
 
14677 
  def __eq__(self, other):
14678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14679 
 
14680 
  def __ne__(self, other):
14681 
    return not (self == other)
14682 
 
14683 
class getProductNotificationRequestCount_args:
14684 
  """
14685 
  Attributes:
14686 
   - startDateTime
7897 amar.kumar 14687 
   - categoryId
5944 mandeep.dh 14688 
  """
14689 
 
14690 
  thrift_spec = (
14691 
    None, # 0
14692 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 14693 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 14694 
  )
14695 
 
7897 amar.kumar 14696 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 14697 
    self.startDateTime = startDateTime
7897 amar.kumar 14698 
    self.categoryId = categoryId
5944 mandeep.dh 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 
      if fid == 1:
14710 
        if ftype == TType.I64:
14711 
          self.startDateTime = iprot.readI64();
14712 
        else:
14713 
          iprot.skip(ftype)
7897 amar.kumar 14714 
      elif fid == 2:
14715 
        if ftype == TType.I64:
14716 
          self.categoryId = iprot.readI64();
14717 
        else:
14718 
          iprot.skip(ftype)
5944 mandeep.dh 14719 
      else:
14720 
        iprot.skip(ftype)
14721 
      iprot.readFieldEnd()
14722 
    iprot.readStructEnd()
14723 
 
14724 
  def write(self, oprot):
14725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14727 
      return
14728 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14729 
    if self.startDateTime is not None:
14730 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14731 
      oprot.writeI64(self.startDateTime)
14732 
      oprot.writeFieldEnd()
7897 amar.kumar 14733 
    if self.categoryId is not None:
14734 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
14735 
      oprot.writeI64(self.categoryId)
14736 
      oprot.writeFieldEnd()
5944 mandeep.dh 14737 
    oprot.writeFieldStop()
14738 
    oprot.writeStructEnd()
14739 
 
14740 
  def validate(self):
14741 
    return
14742 
 
14743 
 
14744 
  def __repr__(self):
14745 
    L = ['%s=%r' % (key, value)
14746 
      for key, value in self.__dict__.iteritems()]
14747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14748 
 
14749 
  def __eq__(self, other):
14750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14751 
 
14752 
  def __ne__(self, other):
14753 
    return not (self == other)
14754 
 
14755 
class getProductNotificationRequestCount_result:
14756 
  """
14757 
  Attributes:
14758 
   - success
14759 
  """
14760 
 
14761 
  thrift_spec = (
14762 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14763 
  )
14764 
 
14765 
  def __init__(self, success=None,):
14766 
    self.success = success
14767 
 
14768 
  def read(self, iprot):
14769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14771 
      return
14772 
    iprot.readStructBegin()
14773 
    while True:
14774 
      (fname, ftype, fid) = iprot.readFieldBegin()
14775 
      if ftype == TType.STOP:
14776 
        break
14777 
      if fid == 0:
14778 
        if ftype == TType.LIST:
14779 
          self.success = []
7438 amit.gupta 14780 
          (_etype282, _size279) = iprot.readListBegin()
14781 
          for _i283 in xrange(_size279):
14782 
            _elem284 = ProductNotificationRequestCount()
14783 
            _elem284.read(iprot)
14784 
            self.success.append(_elem284)
5944 mandeep.dh 14785 
          iprot.readListEnd()
14786 
        else:
14787 
          iprot.skip(ftype)
14788 
      else:
14789 
        iprot.skip(ftype)
14790 
      iprot.readFieldEnd()
14791 
    iprot.readStructEnd()
14792 
 
14793 
  def write(self, oprot):
14794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14796 
      return
14797 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14798 
    if self.success is not None:
14799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14800 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14801 
      for iter285 in self.success:
14802 
        iter285.write(oprot)
5944 mandeep.dh 14803 
      oprot.writeListEnd()
14804 
      oprot.writeFieldEnd()
14805 
    oprot.writeFieldStop()
14806 
    oprot.writeStructEnd()
14807 
 
14808 
  def validate(self):
14809 
    return
14810 
 
14811 
 
14812 
  def __repr__(self):
14813 
    L = ['%s=%r' % (key, value)
14814 
      for key, value in self.__dict__.iteritems()]
14815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14816 
 
14817 
  def __eq__(self, other):
14818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14819 
 
14820 
  def __ne__(self, other):
14821 
    return not (self == other)
14822 
 
14823 
class addAuthorizationLog_args:
14824 
  """
14825 
  Attributes:
14826 
   - itemId
14827 
   - username
14828 
   - reason
14829 
  """
14830 
 
14831 
  thrift_spec = (
14832 
    None, # 0
14833 
    (1, TType.I64, 'itemId', None, None, ), # 1
14834 
    (2, TType.STRING, 'username', None, None, ), # 2
14835 
    (3, TType.STRING, 'reason', None, None, ), # 3
14836 
  )
14837 
 
14838 
  def __init__(self, itemId=None, username=None, reason=None,):
14839 
    self.itemId = itemId
14840 
    self.username = username
14841 
    self.reason = reason
14842 
 
14843 
  def read(self, iprot):
14844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14846 
      return
14847 
    iprot.readStructBegin()
14848 
    while True:
14849 
      (fname, ftype, fid) = iprot.readFieldBegin()
14850 
      if ftype == TType.STOP:
14851 
        break
14852 
      if fid == 1:
14853 
        if ftype == TType.I64:
14854 
          self.itemId = iprot.readI64();
14855 
        else:
14856 
          iprot.skip(ftype)
14857 
      elif fid == 2:
14858 
        if ftype == TType.STRING:
14859 
          self.username = iprot.readString();
14860 
        else:
14861 
          iprot.skip(ftype)
14862 
      elif fid == 3:
14863 
        if ftype == TType.STRING:
14864 
          self.reason = iprot.readString();
14865 
        else:
14866 
          iprot.skip(ftype)
14867 
      else:
14868 
        iprot.skip(ftype)
14869 
      iprot.readFieldEnd()
14870 
    iprot.readStructEnd()
14871 
 
14872 
  def write(self, oprot):
14873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14875 
      return
14876 
    oprot.writeStructBegin('addAuthorizationLog_args')
14877 
    if self.itemId is not None:
14878 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14879 
      oprot.writeI64(self.itemId)
14880 
      oprot.writeFieldEnd()
14881 
    if self.username is not None:
14882 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14883 
      oprot.writeString(self.username)
14884 
      oprot.writeFieldEnd()
14885 
    if self.reason is not None:
14886 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14887 
      oprot.writeString(self.reason)
14888 
      oprot.writeFieldEnd()
14889 
    oprot.writeFieldStop()
14890 
    oprot.writeStructEnd()
14891 
 
14892 
  def validate(self):
14893 
    return
14894 
 
14895 
 
14896 
  def __repr__(self):
14897 
    L = ['%s=%r' % (key, value)
14898 
      for key, value in self.__dict__.iteritems()]
14899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14900 
 
14901 
  def __eq__(self, other):
14902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14903 
 
14904 
  def __ne__(self, other):
14905 
    return not (self == other)
14906 
 
14907 
class addAuthorizationLog_result:
14908 
  """
14909 
  Attributes:
14910 
   - success
14911 
   - cex
14912 
  """
14913 
 
14914 
  thrift_spec = (
14915 
    (0, TType.BOOL, 'success', None, None, ), # 0
14916 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14917 
  )
14918 
 
14919 
  def __init__(self, success=None, cex=None,):
14920 
    self.success = success
14921 
    self.cex = cex
14922 
 
14923 
  def read(self, iprot):
14924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14926 
      return
14927 
    iprot.readStructBegin()
14928 
    while True:
14929 
      (fname, ftype, fid) = iprot.readFieldBegin()
14930 
      if ftype == TType.STOP:
14931 
        break
14932 
      if fid == 0:
14933 
        if ftype == TType.BOOL:
14934 
          self.success = iprot.readBool();
14935 
        else:
14936 
          iprot.skip(ftype)
14937 
      elif fid == 1:
14938 
        if ftype == TType.STRUCT:
14939 
          self.cex = CatalogServiceException()
14940 
          self.cex.read(iprot)
14941 
        else:
14942 
          iprot.skip(ftype)
14943 
      else:
14944 
        iprot.skip(ftype)
14945 
      iprot.readFieldEnd()
14946 
    iprot.readStructEnd()
14947 
 
14948 
  def write(self, oprot):
14949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14951 
      return
14952 
    oprot.writeStructBegin('addAuthorizationLog_result')
14953 
    if self.success is not None:
14954 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14955 
      oprot.writeBool(self.success)
14956 
      oprot.writeFieldEnd()
14957 
    if self.cex is not None:
14958 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14959 
      self.cex.write(oprot)
14960 
      oprot.writeFieldEnd()
14961 
    oprot.writeFieldStop()
14962 
    oprot.writeStructEnd()
14963 
 
14964 
  def validate(self):
14965 
    return
14966 
 
14967 
 
14968 
  def __repr__(self):
14969 
    L = ['%s=%r' % (key, value)
14970 
      for key, value in self.__dict__.iteritems()]
14971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14972 
 
14973 
  def __eq__(self, other):
14974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14975 
 
14976 
  def __ne__(self, other):
14977 
    return not (self == other)
14978 
 
14979 
class addupdateVoucherForItem_args:
14980 
  """
14981 
  Attributes:
14982 
   - catalog_item_id
14983 
   - voucherType
14984 
   - voucherAmount
14985 
  """
14986 
 
14987 
  thrift_spec = (
14988 
    None, # 0
14989 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14990 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14991 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14992 
  )
14993 
 
14994 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14995 
    self.catalog_item_id = catalog_item_id
14996 
    self.voucherType = voucherType
14997 
    self.voucherAmount = voucherAmount
14998 
 
14999 
  def read(self, iprot):
15000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15002 
      return
15003 
    iprot.readStructBegin()
15004 
    while True:
15005 
      (fname, ftype, fid) = iprot.readFieldBegin()
15006 
      if ftype == TType.STOP:
15007 
        break
15008 
      if fid == 1:
15009 
        if ftype == TType.I64:
15010 
          self.catalog_item_id = iprot.readI64();
15011 
        else:
15012 
          iprot.skip(ftype)
15013 
      elif fid == 2:
15014 
        if ftype == TType.I64:
15015 
          self.voucherType = iprot.readI64();
15016 
        else:
15017 
          iprot.skip(ftype)
15018 
      elif fid == 3:
15019 
        if ftype == TType.I64:
15020 
          self.voucherAmount = iprot.readI64();
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('addupdateVoucherForItem_args')
15033 
    if self.catalog_item_id is not None:
15034 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15035 
      oprot.writeI64(self.catalog_item_id)
15036 
      oprot.writeFieldEnd()
15037 
    if self.voucherType is not None:
15038 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15039 
      oprot.writeI64(self.voucherType)
15040 
      oprot.writeFieldEnd()
15041 
    if self.voucherAmount is not None:
15042 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
15043 
      oprot.writeI64(self.voucherAmount)
15044 
      oprot.writeFieldEnd()
15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
15063 
class addupdateVoucherForItem_result:
15064 
  """
15065 
  Attributes:
15066 
   - success
15067 
   - cex
15068 
  """
15069 
 
15070 
  thrift_spec = (
15071 
    (0, TType.BOOL, 'success', None, None, ), # 0
15072 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15073 
  )
15074 
 
15075 
  def __init__(self, success=None, cex=None,):
15076 
    self.success = success
15077 
    self.cex = cex
15078 
 
15079 
  def read(self, iprot):
15080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15082 
      return
15083 
    iprot.readStructBegin()
15084 
    while True:
15085 
      (fname, ftype, fid) = iprot.readFieldBegin()
15086 
      if ftype == TType.STOP:
15087 
        break
15088 
      if fid == 0:
15089 
        if ftype == TType.BOOL:
15090 
          self.success = iprot.readBool();
15091 
        else:
15092 
          iprot.skip(ftype)
15093 
      elif fid == 1:
15094 
        if ftype == TType.STRUCT:
15095 
          self.cex = CatalogServiceException()
15096 
          self.cex.read(iprot)
15097 
        else:
15098 
          iprot.skip(ftype)
15099 
      else:
15100 
        iprot.skip(ftype)
15101 
      iprot.readFieldEnd()
15102 
    iprot.readStructEnd()
15103 
 
15104 
  def write(self, oprot):
15105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15107 
      return
15108 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
15109 
    if self.success is not None:
15110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15111 
      oprot.writeBool(self.success)
15112 
      oprot.writeFieldEnd()
15113 
    if self.cex is not None:
15114 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15115 
      self.cex.write(oprot)
15116 
      oprot.writeFieldEnd()
15117 
    oprot.writeFieldStop()
15118 
    oprot.writeStructEnd()
15119 
 
15120 
  def validate(self):
15121 
    return
15122 
 
15123 
 
15124 
  def __repr__(self):
15125 
    L = ['%s=%r' % (key, value)
15126 
      for key, value in self.__dict__.iteritems()]
15127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15128 
 
15129 
  def __eq__(self, other):
15130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15131 
 
15132 
  def __ne__(self, other):
15133 
    return not (self == other)
15134 
 
15135 
class deleteVoucherForItem_args:
15136 
  """
15137 
  Attributes:
15138 
   - catalog_item_id
15139 
   - voucherType
15140 
  """
15141 
 
15142 
  thrift_spec = (
15143 
    None, # 0
15144 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15145 
    (2, TType.I64, 'voucherType', None, None, ), # 2
15146 
  )
15147 
 
15148 
  def __init__(self, catalog_item_id=None, voucherType=None,):
15149 
    self.catalog_item_id = catalog_item_id
15150 
    self.voucherType = voucherType
15151 
 
15152 
  def read(self, iprot):
15153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15155 
      return
15156 
    iprot.readStructBegin()
15157 
    while True:
15158 
      (fname, ftype, fid) = iprot.readFieldBegin()
15159 
      if ftype == TType.STOP:
15160 
        break
15161 
      if fid == 1:
15162 
        if ftype == TType.I64:
15163 
          self.catalog_item_id = iprot.readI64();
15164 
        else:
15165 
          iprot.skip(ftype)
15166 
      elif fid == 2:
15167 
        if ftype == TType.I64:
15168 
          self.voucherType = iprot.readI64();
15169 
        else:
15170 
          iprot.skip(ftype)
15171 
      else:
15172 
        iprot.skip(ftype)
15173 
      iprot.readFieldEnd()
15174 
    iprot.readStructEnd()
15175 
 
15176 
  def write(self, oprot):
15177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15179 
      return
15180 
    oprot.writeStructBegin('deleteVoucherForItem_args')
15181 
    if self.catalog_item_id is not None:
15182 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15183 
      oprot.writeI64(self.catalog_item_id)
15184 
      oprot.writeFieldEnd()
15185 
    if self.voucherType is not None:
15186 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15187 
      oprot.writeI64(self.voucherType)
15188 
      oprot.writeFieldEnd()
15189 
    oprot.writeFieldStop()
15190 
    oprot.writeStructEnd()
15191 
 
15192 
  def validate(self):
15193 
    return
15194 
 
15195 
 
15196 
  def __repr__(self):
15197 
    L = ['%s=%r' % (key, value)
15198 
      for key, value in self.__dict__.iteritems()]
15199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15200 
 
15201 
  def __eq__(self, other):
15202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15203 
 
15204 
  def __ne__(self, other):
15205 
    return not (self == other)
15206 
 
15207 
class deleteVoucherForItem_result:
15208 
  """
15209 
  Attributes:
15210 
   - success
15211 
   - cex
15212 
  """
15213 
 
15214 
  thrift_spec = (
15215 
    (0, TType.BOOL, 'success', None, None, ), # 0
15216 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15217 
  )
15218 
 
15219 
  def __init__(self, success=None, cex=None,):
15220 
    self.success = success
15221 
    self.cex = cex
15222 
 
15223 
  def read(self, iprot):
15224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15226 
      return
15227 
    iprot.readStructBegin()
15228 
    while True:
15229 
      (fname, ftype, fid) = iprot.readFieldBegin()
15230 
      if ftype == TType.STOP:
15231 
        break
15232 
      if fid == 0:
15233 
        if ftype == TType.BOOL:
15234 
          self.success = iprot.readBool();
15235 
        else:
15236 
          iprot.skip(ftype)
15237 
      elif fid == 1:
15238 
        if ftype == TType.STRUCT:
15239 
          self.cex = CatalogServiceException()
15240 
          self.cex.read(iprot)
15241 
        else:
15242 
          iprot.skip(ftype)
15243 
      else:
15244 
        iprot.skip(ftype)
15245 
      iprot.readFieldEnd()
15246 
    iprot.readStructEnd()
15247 
 
15248 
  def write(self, oprot):
15249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15251 
      return
15252 
    oprot.writeStructBegin('deleteVoucherForItem_result')
15253 
    if self.success is not None:
15254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15255 
      oprot.writeBool(self.success)
15256 
      oprot.writeFieldEnd()
15257 
    if self.cex is not None:
15258 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15259 
      self.cex.write(oprot)
15260 
      oprot.writeFieldEnd()
15261 
    oprot.writeFieldStop()
15262 
    oprot.writeStructEnd()
15263 
 
15264 
  def validate(self):
15265 
    return
15266 
 
15267 
 
15268 
  def __repr__(self):
15269 
    L = ['%s=%r' % (key, value)
15270 
      for key, value in self.__dict__.iteritems()]
15271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15272 
 
15273 
  def __eq__(self, other):
15274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15275 
 
15276 
  def __ne__(self, other):
15277 
    return not (self == other)
15278 
 
15279 
class getVoucherAmount_args:
15280 
  """
15281 
  Attributes:
15282 
   - itemId
15283 
   - voucherType
15284 
  """
15285 
 
15286 
  thrift_spec = (
15287 
    None, # 0
15288 
    (1, TType.I64, 'itemId', None, None, ), # 1
15289 
    (2, TType.I64, 'voucherType', None, None, ), # 2
15290 
  )
15291 
 
15292 
  def __init__(self, itemId=None, voucherType=None,):
15293 
    self.itemId = itemId
15294 
    self.voucherType = voucherType
15295 
 
15296 
  def read(self, iprot):
15297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15299 
      return
15300 
    iprot.readStructBegin()
15301 
    while True:
15302 
      (fname, ftype, fid) = iprot.readFieldBegin()
15303 
      if ftype == TType.STOP:
15304 
        break
15305 
      if fid == 1:
15306 
        if ftype == TType.I64:
15307 
          self.itemId = iprot.readI64();
15308 
        else:
15309 
          iprot.skip(ftype)
15310 
      elif fid == 2:
15311 
        if ftype == TType.I64:
15312 
          self.voucherType = iprot.readI64();
15313 
        else:
15314 
          iprot.skip(ftype)
15315 
      else:
15316 
        iprot.skip(ftype)
15317 
      iprot.readFieldEnd()
15318 
    iprot.readStructEnd()
15319 
 
15320 
  def write(self, oprot):
15321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15323 
      return
15324 
    oprot.writeStructBegin('getVoucherAmount_args')
15325 
    if self.itemId is not None:
15326 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15327 
      oprot.writeI64(self.itemId)
15328 
      oprot.writeFieldEnd()
15329 
    if self.voucherType is not None:
15330 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15331 
      oprot.writeI64(self.voucherType)
15332 
      oprot.writeFieldEnd()
15333 
    oprot.writeFieldStop()
15334 
    oprot.writeStructEnd()
15335 
 
15336 
  def validate(self):
15337 
    return
15338 
 
15339 
 
15340 
  def __repr__(self):
15341 
    L = ['%s=%r' % (key, value)
15342 
      for key, value in self.__dict__.iteritems()]
15343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15344 
 
15345 
  def __eq__(self, other):
15346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15347 
 
15348 
  def __ne__(self, other):
15349 
    return not (self == other)
15350 
 
15351 
class getVoucherAmount_result:
15352 
  """
15353 
  Attributes:
15354 
   - success
15355 
  """
15356 
 
15357 
  thrift_spec = (
15358 
    (0, TType.I64, 'success', None, None, ), # 0
15359 
  )
15360 
 
15361 
  def __init__(self, success=None,):
15362 
    self.success = success
15363 
 
15364 
  def read(self, iprot):
15365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15367 
      return
15368 
    iprot.readStructBegin()
15369 
    while True:
15370 
      (fname, ftype, fid) = iprot.readFieldBegin()
15371 
      if ftype == TType.STOP:
15372 
        break
15373 
      if fid == 0:
15374 
        if ftype == TType.I64:
15375 
          self.success = iprot.readI64();
15376 
        else:
15377 
          iprot.skip(ftype)
15378 
      else:
15379 
        iprot.skip(ftype)
15380 
      iprot.readFieldEnd()
15381 
    iprot.readStructEnd()
15382 
 
15383 
  def write(self, oprot):
15384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15386 
      return
15387 
    oprot.writeStructBegin('getVoucherAmount_result')
15388 
    if self.success is not None:
15389 
      oprot.writeFieldBegin('success', TType.I64, 0)
15390 
      oprot.writeI64(self.success)
15391 
      oprot.writeFieldEnd()
15392 
    oprot.writeFieldStop()
15393 
    oprot.writeStructEnd()
15394 
 
15395 
  def validate(self):
15396 
    return
15397 
 
15398 
 
15399 
  def __repr__(self):
15400 
    L = ['%s=%r' % (key, value)
15401 
      for key, value in self.__dict__.iteritems()]
15402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15403 
 
15404 
  def __eq__(self, other):
15405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15406 
 
15407 
  def __ne__(self, other):
15408 
    return not (self == other)
15409 
 
15410 
class getAllItemVouchers_args:
15411 
  """
15412 
  Attributes:
15413 
   - itemId
15414 
  """
15415 
 
15416 
  thrift_spec = (
15417 
    None, # 0
15418 
    (1, TType.I64, 'itemId', None, None, ), # 1
15419 
  )
15420 
 
15421 
  def __init__(self, itemId=None,):
15422 
    self.itemId = itemId
15423 
 
15424 
  def read(self, iprot):
15425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15427 
      return
15428 
    iprot.readStructBegin()
15429 
    while True:
15430 
      (fname, ftype, fid) = iprot.readFieldBegin()
15431 
      if ftype == TType.STOP:
15432 
        break
15433 
      if fid == 1:
15434 
        if ftype == TType.I64:
15435 
          self.itemId = iprot.readI64();
15436 
        else:
15437 
          iprot.skip(ftype)
15438 
      else:
15439 
        iprot.skip(ftype)
15440 
      iprot.readFieldEnd()
15441 
    iprot.readStructEnd()
15442 
 
15443 
  def write(self, oprot):
15444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15446 
      return
15447 
    oprot.writeStructBegin('getAllItemVouchers_args')
15448 
    if self.itemId is not None:
15449 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15450 
      oprot.writeI64(self.itemId)
15451 
      oprot.writeFieldEnd()
15452 
    oprot.writeFieldStop()
15453 
    oprot.writeStructEnd()
15454 
 
15455 
  def validate(self):
15456 
    return
15457 
 
15458 
 
15459 
  def __repr__(self):
15460 
    L = ['%s=%r' % (key, value)
15461 
      for key, value in self.__dict__.iteritems()]
15462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15463 
 
15464 
  def __eq__(self, other):
15465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15466 
 
15467 
  def __ne__(self, other):
15468 
    return not (self == other)
15469 
 
15470 
class getAllItemVouchers_result:
15471 
  """
15472 
  Attributes:
15473 
   - success
15474 
  """
15475 
 
15476 
  thrift_spec = (
15477 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
15478 
  )
15479 
 
15480 
  def __init__(self, success=None,):
15481 
    self.success = success
15482 
 
15483 
  def read(self, iprot):
15484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15486 
      return
15487 
    iprot.readStructBegin()
15488 
    while True:
15489 
      (fname, ftype, fid) = iprot.readFieldBegin()
15490 
      if ftype == TType.STOP:
15491 
        break
15492 
      if fid == 0:
15493 
        if ftype == TType.LIST:
15494 
          self.success = []
7438 amit.gupta 15495 
          (_etype289, _size286) = iprot.readListBegin()
15496 
          for _i290 in xrange(_size286):
15497 
            _elem291 = VoucherItemMapping()
15498 
            _elem291.read(iprot)
15499 
            self.success.append(_elem291)
5944 mandeep.dh 15500 
          iprot.readListEnd()
15501 
        else:
15502 
          iprot.skip(ftype)
15503 
      else:
15504 
        iprot.skip(ftype)
15505 
      iprot.readFieldEnd()
15506 
    iprot.readStructEnd()
15507 
 
15508 
  def write(self, oprot):
15509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15511 
      return
15512 
    oprot.writeStructBegin('getAllItemVouchers_result')
15513 
    if self.success is not None:
15514 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15515 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15516 
      for iter292 in self.success:
15517 
        iter292.write(oprot)
5944 mandeep.dh 15518 
      oprot.writeListEnd()
15519 
      oprot.writeFieldEnd()
15520 
    oprot.writeFieldStop()
15521 
    oprot.writeStructEnd()
15522 
 
15523 
  def validate(self):
15524 
    return
15525 
 
15526 
 
15527 
  def __repr__(self):
15528 
    L = ['%s=%r' % (key, value)
15529 
      for key, value in self.__dict__.iteritems()]
15530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15531 
 
15532 
  def __eq__(self, other):
15533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15534 
 
15535 
  def __ne__(self, other):
15536 
    return not (self == other)
15537 
 
15538 
class isValidCatalogItemId_args:
15539 
  """
15540 
  Attributes:
15541 
   - catalog_item_id
15542 
  """
15543 
 
15544 
  thrift_spec = (
15545 
    None, # 0
15546 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15547 
  )
15548 
 
15549 
  def __init__(self, catalog_item_id=None,):
15550 
    self.catalog_item_id = catalog_item_id
15551 
 
15552 
  def read(self, iprot):
15553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15555 
      return
15556 
    iprot.readStructBegin()
15557 
    while True:
15558 
      (fname, ftype, fid) = iprot.readFieldBegin()
15559 
      if ftype == TType.STOP:
15560 
        break
15561 
      if fid == 1:
15562 
        if ftype == TType.I64:
15563 
          self.catalog_item_id = iprot.readI64();
15564 
        else:
15565 
          iprot.skip(ftype)
15566 
      else:
15567 
        iprot.skip(ftype)
15568 
      iprot.readFieldEnd()
15569 
    iprot.readStructEnd()
15570 
 
15571 
  def write(self, oprot):
15572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15574 
      return
15575 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15576 
    if self.catalog_item_id is not None:
15577 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15578 
      oprot.writeI64(self.catalog_item_id)
15579 
      oprot.writeFieldEnd()
15580 
    oprot.writeFieldStop()
15581 
    oprot.writeStructEnd()
15582 
 
15583 
  def validate(self):
15584 
    return
15585 
 
15586 
 
15587 
  def __repr__(self):
15588 
    L = ['%s=%r' % (key, value)
15589 
      for key, value in self.__dict__.iteritems()]
15590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15591 
 
15592 
  def __eq__(self, other):
15593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15594 
 
15595 
  def __ne__(self, other):
15596 
    return not (self == other)
15597 
 
15598 
class isValidCatalogItemId_result:
15599 
  """
15600 
  Attributes:
15601 
   - success
15602 
  """
15603 
 
15604 
  thrift_spec = (
15605 
    (0, TType.BOOL, 'success', None, None, ), # 0
15606 
  )
15607 
 
15608 
  def __init__(self, success=None,):
15609 
    self.success = success
15610 
 
15611 
  def read(self, iprot):
15612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15614 
      return
15615 
    iprot.readStructBegin()
15616 
    while True:
15617 
      (fname, ftype, fid) = iprot.readFieldBegin()
15618 
      if ftype == TType.STOP:
15619 
        break
15620 
      if fid == 0:
15621 
        if ftype == TType.BOOL:
15622 
          self.success = iprot.readBool();
15623 
        else:
15624 
          iprot.skip(ftype)
15625 
      else:
15626 
        iprot.skip(ftype)
15627 
      iprot.readFieldEnd()
15628 
    iprot.readStructEnd()
15629 
 
15630 
  def write(self, oprot):
15631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15633 
      return
15634 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15635 
    if self.success is not None:
15636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15637 
      oprot.writeBool(self.success)
15638 
      oprot.writeFieldEnd()
15639 
    oprot.writeFieldStop()
15640 
    oprot.writeStructEnd()
15641 
 
15642 
  def validate(self):
15643 
    return
15644 
 
15645 
 
15646 
  def __repr__(self):
15647 
    L = ['%s=%r' % (key, value)
15648 
      for key, value in self.__dict__.iteritems()]
15649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15650 
 
15651 
  def __eq__(self, other):
15652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15653 
 
15654 
  def __ne__(self, other):
15655 
    return not (self == other)
6039 amit.gupta 15656 
 
15657 
class getVatPercentageForItem_args:
15658 
  """
15659 
  Attributes:
15660 
   - itemId
7330 amit.gupta 15661 
   - stateId
6039 amit.gupta 15662 
   - price
15663 
  """
15664 
 
15665 
  thrift_spec = (
15666 
    None, # 0
15667 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15668 
    (2, TType.I64, 'stateId', None, None, ), # 2
15669 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15670 
  )
15671 
 
7330 amit.gupta 15672 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15673 
    self.itemId = itemId
7330 amit.gupta 15674 
    self.stateId = stateId
6039 amit.gupta 15675 
    self.price = price
15676 
 
15677 
  def read(self, iprot):
15678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15680 
      return
15681 
    iprot.readStructBegin()
15682 
    while True:
15683 
      (fname, ftype, fid) = iprot.readFieldBegin()
15684 
      if ftype == TType.STOP:
15685 
        break
15686 
      if fid == 1:
15687 
        if ftype == TType.I64:
15688 
          self.itemId = iprot.readI64();
15689 
        else:
15690 
          iprot.skip(ftype)
15691 
      elif fid == 2:
7330 amit.gupta 15692 
        if ftype == TType.I64:
15693 
          self.stateId = iprot.readI64();
15694 
        else:
15695 
          iprot.skip(ftype)
15696 
      elif fid == 3:
6039 amit.gupta 15697 
        if ftype == TType.DOUBLE:
15698 
          self.price = iprot.readDouble();
15699 
        else:
15700 
          iprot.skip(ftype)
15701 
      else:
15702 
        iprot.skip(ftype)
15703 
      iprot.readFieldEnd()
15704 
    iprot.readStructEnd()
15705 
 
15706 
  def write(self, oprot):
15707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15709 
      return
15710 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15711 
    if self.itemId is not None:
15712 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15713 
      oprot.writeI64(self.itemId)
15714 
      oprot.writeFieldEnd()
7330 amit.gupta 15715 
    if self.stateId is not None:
15716 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15717 
      oprot.writeI64(self.stateId)
15718 
      oprot.writeFieldEnd()
6039 amit.gupta 15719 
    if self.price is not None:
7330 amit.gupta 15720 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15721 
      oprot.writeDouble(self.price)
15722 
      oprot.writeFieldEnd()
15723 
    oprot.writeFieldStop()
15724 
    oprot.writeStructEnd()
15725 
 
15726 
  def validate(self):
15727 
    return
15728 
 
15729 
 
15730 
  def __repr__(self):
15731 
    L = ['%s=%r' % (key, value)
15732 
      for key, value in self.__dict__.iteritems()]
15733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15734 
 
15735 
  def __eq__(self, other):
15736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15737 
 
15738 
  def __ne__(self, other):
15739 
    return not (self == other)
15740 
 
15741 
class getVatPercentageForItem_result:
15742 
  """
15743 
  Attributes:
15744 
   - success
7340 amit.gupta 15745 
   - cex
6039 amit.gupta 15746 
  """
15747 
 
15748 
  thrift_spec = (
15749 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15750 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15751 
  )
15752 
 
7340 amit.gupta 15753 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15754 
    self.success = success
7340 amit.gupta 15755 
    self.cex = cex
6039 amit.gupta 15756 
 
15757 
  def read(self, iprot):
15758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15760 
      return
15761 
    iprot.readStructBegin()
15762 
    while True:
15763 
      (fname, ftype, fid) = iprot.readFieldBegin()
15764 
      if ftype == TType.STOP:
15765 
        break
15766 
      if fid == 0:
15767 
        if ftype == TType.DOUBLE:
15768 
          self.success = iprot.readDouble();
15769 
        else:
15770 
          iprot.skip(ftype)
7340 amit.gupta 15771 
      elif fid == 1:
15772 
        if ftype == TType.STRUCT:
15773 
          self.cex = CatalogServiceException()
15774 
          self.cex.read(iprot)
15775 
        else:
15776 
          iprot.skip(ftype)
6039 amit.gupta 15777 
      else:
15778 
        iprot.skip(ftype)
15779 
      iprot.readFieldEnd()
15780 
    iprot.readStructEnd()
15781 
 
15782 
  def write(self, oprot):
15783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15785 
      return
15786 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15787 
    if self.success is not None:
15788 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15789 
      oprot.writeDouble(self.success)
15790 
      oprot.writeFieldEnd()
7340 amit.gupta 15791 
    if self.cex is not None:
15792 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15793 
      self.cex.write(oprot)
15794 
      oprot.writeFieldEnd()
6039 amit.gupta 15795 
    oprot.writeFieldStop()
15796 
    oprot.writeStructEnd()
15797 
 
15798 
  def validate(self):
15799 
    return
15800 
 
15801 
 
15802 
  def __repr__(self):
15803 
    L = ['%s=%r' % (key, value)
15804 
      for key, value in self.__dict__.iteritems()]
15805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15806 
 
15807 
  def __eq__(self, other):
15808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15809 
 
15810 
  def __ne__(self, other):
15811 
    return not (self == other)
15812 
 
15813 
class getVatAmountForItem_args:
15814 
  """
15815 
  Attributes:
15816 
   - itemId
15817 
   - price
15818 
  """
15819 
 
15820 
  thrift_spec = (
15821 
    None, # 0
15822 
    (1, TType.I64, 'itemId', None, None, ), # 1
15823 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15824 
  )
15825 
 
15826 
  def __init__(self, itemId=None, price=None,):
15827 
    self.itemId = itemId
15828 
    self.price = price
15829 
 
15830 
  def read(self, iprot):
15831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15833 
      return
15834 
    iprot.readStructBegin()
15835 
    while True:
15836 
      (fname, ftype, fid) = iprot.readFieldBegin()
15837 
      if ftype == TType.STOP:
15838 
        break
15839 
      if fid == 1:
15840 
        if ftype == TType.I64:
15841 
          self.itemId = iprot.readI64();
15842 
        else:
15843 
          iprot.skip(ftype)
15844 
      elif fid == 2:
15845 
        if ftype == TType.DOUBLE:
15846 
          self.price = iprot.readDouble();
15847 
        else:
15848 
          iprot.skip(ftype)
15849 
      else:
15850 
        iprot.skip(ftype)
15851 
      iprot.readFieldEnd()
15852 
    iprot.readStructEnd()
15853 
 
15854 
  def write(self, oprot):
15855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15857 
      return
15858 
    oprot.writeStructBegin('getVatAmountForItem_args')
15859 
    if self.itemId is not None:
15860 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15861 
      oprot.writeI64(self.itemId)
15862 
      oprot.writeFieldEnd()
15863 
    if self.price is not None:
15864 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15865 
      oprot.writeDouble(self.price)
15866 
      oprot.writeFieldEnd()
15867 
    oprot.writeFieldStop()
15868 
    oprot.writeStructEnd()
15869 
 
15870 
  def validate(self):
15871 
    return
15872 
 
15873 
 
15874 
  def __repr__(self):
15875 
    L = ['%s=%r' % (key, value)
15876 
      for key, value in self.__dict__.iteritems()]
15877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15878 
 
15879 
  def __eq__(self, other):
15880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15881 
 
15882 
  def __ne__(self, other):
15883 
    return not (self == other)
15884 
 
15885 
class getVatAmountForItem_result:
15886 
  """
15887 
  Attributes:
15888 
   - success
15889 
  """
15890 
 
15891 
  thrift_spec = (
15892 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15893 
  )
15894 
 
15895 
  def __init__(self, success=None,):
15896 
    self.success = success
15897 
 
15898 
  def read(self, iprot):
15899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15901 
      return
15902 
    iprot.readStructBegin()
15903 
    while True:
15904 
      (fname, ftype, fid) = iprot.readFieldBegin()
15905 
      if ftype == TType.STOP:
15906 
        break
15907 
      if fid == 0:
15908 
        if ftype == TType.DOUBLE:
15909 
          self.success = iprot.readDouble();
15910 
        else:
15911 
          iprot.skip(ftype)
15912 
      else:
15913 
        iprot.skip(ftype)
15914 
      iprot.readFieldEnd()
15915 
    iprot.readStructEnd()
15916 
 
15917 
  def write(self, oprot):
15918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15920 
      return
15921 
    oprot.writeStructBegin('getVatAmountForItem_result')
15922 
    if self.success is not None:
15923 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15924 
      oprot.writeDouble(self.success)
15925 
      oprot.writeFieldEnd()
15926 
    oprot.writeFieldStop()
15927 
    oprot.writeStructEnd()
15928 
 
15929 
  def validate(self):
15930 
    return
15931 
 
15932 
 
15933 
  def __repr__(self):
15934 
    L = ['%s=%r' % (key, value)
15935 
      for key, value in self.__dict__.iteritems()]
15936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15937 
 
15938 
  def __eq__(self, other):
15939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15940 
 
15941 
  def __ne__(self, other):
15942 
    return not (self == other)
6531 vikram.rag 15943 
 
15944 
class getAllIgnoredInventoryUpdateItemsList_args:
15945 
  """
15946 
  Attributes:
15947 
   - offset
15948 
   - limit
15949 
  """
15950 
 
15951 
  thrift_spec = (
15952 
    None, # 0
15953 
    (1, TType.I32, 'offset', None, None, ), # 1
15954 
    (2, TType.I32, 'limit', None, None, ), # 2
15955 
  )
15956 
 
15957 
  def __init__(self, offset=None, limit=None,):
15958 
    self.offset = offset
15959 
    self.limit = limit
15960 
 
15961 
  def read(self, iprot):
15962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15964 
      return
15965 
    iprot.readStructBegin()
15966 
    while True:
15967 
      (fname, ftype, fid) = iprot.readFieldBegin()
15968 
      if ftype == TType.STOP:
15969 
        break
15970 
      if fid == 1:
15971 
        if ftype == TType.I32:
15972 
          self.offset = iprot.readI32();
15973 
        else:
15974 
          iprot.skip(ftype)
15975 
      elif fid == 2:
15976 
        if ftype == TType.I32:
15977 
          self.limit = iprot.readI32();
15978 
        else:
15979 
          iprot.skip(ftype)
15980 
      else:
15981 
        iprot.skip(ftype)
15982 
      iprot.readFieldEnd()
15983 
    iprot.readStructEnd()
15984 
 
15985 
  def write(self, oprot):
15986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15988 
      return
15989 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15990 
    if self.offset is not None:
15991 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15992 
      oprot.writeI32(self.offset)
15993 
      oprot.writeFieldEnd()
15994 
    if self.limit is not None:
15995 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15996 
      oprot.writeI32(self.limit)
15997 
      oprot.writeFieldEnd()
15998 
    oprot.writeFieldStop()
15999 
    oprot.writeStructEnd()
16000 
 
16001 
  def validate(self):
16002 
    return
16003 
 
16004 
 
16005 
  def __repr__(self):
16006 
    L = ['%s=%r' % (key, value)
16007 
      for key, value in self.__dict__.iteritems()]
16008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16009 
 
16010 
  def __eq__(self, other):
16011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16012 
 
16013 
  def __ne__(self, other):
16014 
    return not (self == other)
16015 
 
16016 
class getAllIgnoredInventoryUpdateItemsList_result:
16017 
  """
16018 
  Attributes:
16019 
   - success
16020 
  """
16021 
 
16022 
  thrift_spec = (
16023 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16024 
  )
16025 
 
16026 
  def __init__(self, success=None,):
16027 
    self.success = success
16028 
 
16029 
  def read(self, iprot):
16030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16032 
      return
16033 
    iprot.readStructBegin()
16034 
    while True:
16035 
      (fname, ftype, fid) = iprot.readFieldBegin()
16036 
      if ftype == TType.STOP:
16037 
        break
16038 
      if fid == 0:
16039 
        if ftype == TType.LIST:
16040 
          self.success = []
7438 amit.gupta 16041 
          (_etype296, _size293) = iprot.readListBegin()
16042 
          for _i297 in xrange(_size293):
16043 
            _elem298 = Item()
16044 
            _elem298.read(iprot)
16045 
            self.success.append(_elem298)
6531 vikram.rag 16046 
          iprot.readListEnd()
16047 
        else:
16048 
          iprot.skip(ftype)
16049 
      else:
16050 
        iprot.skip(ftype)
16051 
      iprot.readFieldEnd()
16052 
    iprot.readStructEnd()
16053 
 
16054 
  def write(self, oprot):
16055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16057 
      return
16058 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
16059 
    if self.success is not None:
16060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16061 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16062 
      for iter299 in self.success:
16063 
        iter299.write(oprot)
6531 vikram.rag 16064 
      oprot.writeListEnd()
16065 
      oprot.writeFieldEnd()
16066 
    oprot.writeFieldStop()
16067 
    oprot.writeStructEnd()
16068 
 
16069 
  def validate(self):
16070 
    return
16071 
 
16072 
 
16073 
  def __repr__(self):
16074 
    L = ['%s=%r' % (key, value)
16075 
      for key, value in self.__dict__.iteritems()]
16076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16077 
 
16078 
  def __eq__(self, other):
16079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16080 
 
16081 
  def __ne__(self, other):
16082 
    return not (self == other)
6805 anupam.sin 16083 
 
6821 amar.kumar 16084 
class getAllAliveItems_args:
16085 
 
16086 
  thrift_spec = (
16087 
  )
16088 
 
16089 
  def read(self, iprot):
16090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16092 
      return
16093 
    iprot.readStructBegin()
16094 
    while True:
16095 
      (fname, ftype, fid) = iprot.readFieldBegin()
16096 
      if ftype == TType.STOP:
16097 
        break
16098 
      else:
16099 
        iprot.skip(ftype)
16100 
      iprot.readFieldEnd()
16101 
    iprot.readStructEnd()
16102 
 
16103 
  def write(self, oprot):
16104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16106 
      return
16107 
    oprot.writeStructBegin('getAllAliveItems_args')
16108 
    oprot.writeFieldStop()
16109 
    oprot.writeStructEnd()
16110 
 
16111 
  def validate(self):
16112 
    return
16113 
 
16114 
 
16115 
  def __repr__(self):
16116 
    L = ['%s=%r' % (key, value)
16117 
      for key, value in self.__dict__.iteritems()]
16118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16119 
 
16120 
  def __eq__(self, other):
16121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16122 
 
16123 
  def __ne__(self, other):
16124 
    return not (self == other)
16125 
 
16126 
class getAllAliveItems_result:
16127 
  """
16128 
  Attributes:
16129 
   - success
16130 
  """
16131 
 
16132 
  thrift_spec = (
16133 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
16134 
  )
16135 
 
16136 
  def __init__(self, success=None,):
16137 
    self.success = success
16138 
 
16139 
  def read(self, iprot):
16140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16142 
      return
16143 
    iprot.readStructBegin()
16144 
    while True:
16145 
      (fname, ftype, fid) = iprot.readFieldBegin()
16146 
      if ftype == TType.STOP:
16147 
        break
16148 
      if fid == 0:
16149 
        if ftype == TType.LIST:
16150 
          self.success = []
7438 amit.gupta 16151 
          (_etype303, _size300) = iprot.readListBegin()
16152 
          for _i304 in xrange(_size300):
16153 
            _elem305 = Item()
16154 
            _elem305.read(iprot)
16155 
            self.success.append(_elem305)
6821 amar.kumar 16156 
          iprot.readListEnd()
16157 
        else:
16158 
          iprot.skip(ftype)
16159 
      else:
16160 
        iprot.skip(ftype)
16161 
      iprot.readFieldEnd()
16162 
    iprot.readStructEnd()
16163 
 
16164 
  def write(self, oprot):
16165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16167 
      return
16168 
    oprot.writeStructBegin('getAllAliveItems_result')
16169 
    if self.success is not None:
16170 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16171 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16172 
      for iter306 in self.success:
16173 
        iter306.write(oprot)
6821 amar.kumar 16174 
      oprot.writeListEnd()
16175 
      oprot.writeFieldEnd()
16176 
    oprot.writeFieldStop()
16177 
    oprot.writeStructEnd()
16178 
 
16179 
  def validate(self):
16180 
    return
16181 
 
16182 
 
16183 
  def __repr__(self):
16184 
    L = ['%s=%r' % (key, value)
16185 
      for key, value in self.__dict__.iteritems()]
16186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16187 
 
16188 
  def __eq__(self, other):
16189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16190 
 
16191 
  def __ne__(self, other):
16192 
    return not (self == other)
16193 
 
6805 anupam.sin 16194 
class getInsuranceAmount_args:
16195 
  """
16196 
  Attributes:
16197 
   - itemId
6921 anupam.sin 16198 
   - price
6805 anupam.sin 16199 
   - insurerId
16200 
   - quantity
16201 
  """
16202 
 
16203 
  thrift_spec = (
16204 
    None, # 0
16205 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 16206 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
16207 
    (3, TType.I64, 'insurerId', None, None, ), # 3
16208 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 16209 
  )
16210 
 
6921 anupam.sin 16211 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 16212 
    self.itemId = itemId
6921 anupam.sin 16213 
    self.price = price
6805 anupam.sin 16214 
    self.insurerId = insurerId
16215 
    self.quantity = quantity
16216 
 
16217 
  def read(self, iprot):
16218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16220 
      return
16221 
    iprot.readStructBegin()
16222 
    while True:
16223 
      (fname, ftype, fid) = iprot.readFieldBegin()
16224 
      if ftype == TType.STOP:
16225 
        break
16226 
      if fid == 1:
16227 
        if ftype == TType.I64:
16228 
          self.itemId = iprot.readI64();
16229 
        else:
16230 
          iprot.skip(ftype)
16231 
      elif fid == 2:
6921 anupam.sin 16232 
        if ftype == TType.DOUBLE:
16233 
          self.price = iprot.readDouble();
16234 
        else:
16235 
          iprot.skip(ftype)
16236 
      elif fid == 3:
6805 anupam.sin 16237 
        if ftype == TType.I64:
16238 
          self.insurerId = iprot.readI64();
16239 
        else:
16240 
          iprot.skip(ftype)
6921 anupam.sin 16241 
      elif fid == 4:
6805 anupam.sin 16242 
        if ftype == TType.I64:
16243 
          self.quantity = iprot.readI64();
16244 
        else:
16245 
          iprot.skip(ftype)
16246 
      else:
16247 
        iprot.skip(ftype)
16248 
      iprot.readFieldEnd()
16249 
    iprot.readStructEnd()
16250 
 
16251 
  def write(self, oprot):
16252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16254 
      return
16255 
    oprot.writeStructBegin('getInsuranceAmount_args')
16256 
    if self.itemId is not None:
16257 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16258 
      oprot.writeI64(self.itemId)
16259 
      oprot.writeFieldEnd()
6921 anupam.sin 16260 
    if self.price is not None:
16261 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
16262 
      oprot.writeDouble(self.price)
16263 
      oprot.writeFieldEnd()
6805 anupam.sin 16264 
    if self.insurerId is not None:
6921 anupam.sin 16265 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 16266 
      oprot.writeI64(self.insurerId)
16267 
      oprot.writeFieldEnd()
16268 
    if self.quantity is not None:
6921 anupam.sin 16269 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 16270 
      oprot.writeI64(self.quantity)
16271 
      oprot.writeFieldEnd()
16272 
    oprot.writeFieldStop()
16273 
    oprot.writeStructEnd()
16274 
 
16275 
  def validate(self):
16276 
    return
16277 
 
16278 
 
16279 
  def __repr__(self):
16280 
    L = ['%s=%r' % (key, value)
16281 
      for key, value in self.__dict__.iteritems()]
16282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16283 
 
16284 
  def __eq__(self, other):
16285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16286 
 
16287 
  def __ne__(self, other):
16288 
    return not (self == other)
16289 
 
16290 
class getInsuranceAmount_result:
16291 
  """
16292 
  Attributes:
16293 
   - success
16294 
  """
16295 
 
16296 
  thrift_spec = (
16297 
    (0, TType.I64, 'success', None, None, ), # 0
16298 
  )
16299 
 
16300 
  def __init__(self, success=None,):
16301 
    self.success = success
16302 
 
16303 
  def read(self, iprot):
16304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16306 
      return
16307 
    iprot.readStructBegin()
16308 
    while True:
16309 
      (fname, ftype, fid) = iprot.readFieldBegin()
16310 
      if ftype == TType.STOP:
16311 
        break
16312 
      if fid == 0:
16313 
        if ftype == TType.I64:
16314 
          self.success = iprot.readI64();
16315 
        else:
16316 
          iprot.skip(ftype)
16317 
      else:
16318 
        iprot.skip(ftype)
16319 
      iprot.readFieldEnd()
16320 
    iprot.readStructEnd()
16321 
 
16322 
  def write(self, oprot):
16323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16325 
      return
16326 
    oprot.writeStructBegin('getInsuranceAmount_result')
16327 
    if self.success is not None:
16328 
      oprot.writeFieldBegin('success', TType.I64, 0)
16329 
      oprot.writeI64(self.success)
16330 
      oprot.writeFieldEnd()
16331 
    oprot.writeFieldStop()
16332 
    oprot.writeStructEnd()
16333 
 
16334 
  def validate(self):
16335 
    return
16336 
 
16337 
 
16338 
  def __repr__(self):
16339 
    L = ['%s=%r' % (key, value)
16340 
      for key, value in self.__dict__.iteritems()]
16341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16342 
 
16343 
  def __eq__(self, other):
16344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16345 
 
16346 
  def __ne__(self, other):
16347 
    return not (self == other)
16348 
 
16349 
class getInsurer_args:
16350 
  """
16351 
  Attributes:
16352 
   - insurerId
16353 
  """
16354 
 
16355 
  thrift_spec = (
16356 
    None, # 0
16357 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16358 
  )
16359 
 
16360 
  def __init__(self, insurerId=None,):
16361 
    self.insurerId = insurerId
16362 
 
16363 
  def read(self, iprot):
16364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16366 
      return
16367 
    iprot.readStructBegin()
16368 
    while True:
16369 
      (fname, ftype, fid) = iprot.readFieldBegin()
16370 
      if ftype == TType.STOP:
16371 
        break
16372 
      if fid == 1:
16373 
        if ftype == TType.I64:
16374 
          self.insurerId = iprot.readI64();
16375 
        else:
16376 
          iprot.skip(ftype)
16377 
      else:
16378 
        iprot.skip(ftype)
16379 
      iprot.readFieldEnd()
16380 
    iprot.readStructEnd()
16381 
 
16382 
  def write(self, oprot):
16383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16385 
      return
16386 
    oprot.writeStructBegin('getInsurer_args')
16387 
    if self.insurerId is not None:
16388 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16389 
      oprot.writeI64(self.insurerId)
16390 
      oprot.writeFieldEnd()
16391 
    oprot.writeFieldStop()
16392 
    oprot.writeStructEnd()
16393 
 
16394 
  def validate(self):
16395 
    return
16396 
 
16397 
 
16398 
  def __repr__(self):
16399 
    L = ['%s=%r' % (key, value)
16400 
      for key, value in self.__dict__.iteritems()]
16401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16402 
 
16403 
  def __eq__(self, other):
16404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16405 
 
16406 
  def __ne__(self, other):
16407 
    return not (self == other)
16408 
 
16409 
class getInsurer_result:
16410 
  """
16411 
  Attributes:
16412 
   - success
16413 
  """
16414 
 
16415 
  thrift_spec = (
16416 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
16417 
  )
16418 
 
16419 
  def __init__(self, success=None,):
16420 
    self.success = success
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.STRUCT:
16433 
          self.success = Insurer()
16434 
          self.success.read(iprot)
16435 
        else:
16436 
          iprot.skip(ftype)
16437 
      else:
16438 
        iprot.skip(ftype)
16439 
      iprot.readFieldEnd()
16440 
    iprot.readStructEnd()
16441 
 
16442 
  def write(self, oprot):
16443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16445 
      return
16446 
    oprot.writeStructBegin('getInsurer_result')
16447 
    if self.success is not None:
16448 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16449 
      self.success.write(oprot)
16450 
      oprot.writeFieldEnd()
16451 
    oprot.writeFieldStop()
16452 
    oprot.writeStructEnd()
16453 
 
16454 
  def validate(self):
16455 
    return
16456 
 
16457 
 
16458 
  def __repr__(self):
16459 
    L = ['%s=%r' % (key, value)
16460 
      for key, value in self.__dict__.iteritems()]
16461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16462 
 
16463 
  def __eq__(self, other):
16464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16465 
 
16466 
  def __ne__(self, other):
16467 
    return not (self == other)
6838 vikram.rag 16468 
 
16469 
class getAllInsurers_args:
16470 
 
16471 
  thrift_spec = (
16472 
  )
16473 
 
16474 
  def read(self, iprot):
16475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16477 
      return
16478 
    iprot.readStructBegin()
16479 
    while True:
16480 
      (fname, ftype, fid) = iprot.readFieldBegin()
16481 
      if ftype == TType.STOP:
16482 
        break
16483 
      else:
16484 
        iprot.skip(ftype)
16485 
      iprot.readFieldEnd()
16486 
    iprot.readStructEnd()
16487 
 
16488 
  def write(self, oprot):
16489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16491 
      return
16492 
    oprot.writeStructBegin('getAllInsurers_args')
16493 
    oprot.writeFieldStop()
16494 
    oprot.writeStructEnd()
16495 
 
16496 
  def validate(self):
16497 
    return
16498 
 
16499 
 
16500 
  def __repr__(self):
16501 
    L = ['%s=%r' % (key, value)
16502 
      for key, value in self.__dict__.iteritems()]
16503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16504 
 
16505 
  def __eq__(self, other):
16506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16507 
 
16508 
  def __ne__(self, other):
16509 
    return not (self == other)
16510 
 
16511 
class getAllInsurers_result:
16512 
  """
16513 
  Attributes:
16514 
   - success
16515 
  """
16516 
 
16517 
  thrift_spec = (
16518 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16519 
  )
16520 
 
16521 
  def __init__(self, success=None,):
16522 
    self.success = success
16523 
 
16524 
  def read(self, iprot):
16525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16527 
      return
16528 
    iprot.readStructBegin()
16529 
    while True:
16530 
      (fname, ftype, fid) = iprot.readFieldBegin()
16531 
      if ftype == TType.STOP:
16532 
        break
16533 
      if fid == 0:
16534 
        if ftype == TType.LIST:
16535 
          self.success = []
7438 amit.gupta 16536 
          (_etype310, _size307) = iprot.readListBegin()
16537 
          for _i311 in xrange(_size307):
16538 
            _elem312 = Insurer()
16539 
            _elem312.read(iprot)
16540 
            self.success.append(_elem312)
6838 vikram.rag 16541 
          iprot.readListEnd()
16542 
        else:
16543 
          iprot.skip(ftype)
16544 
      else:
16545 
        iprot.skip(ftype)
16546 
      iprot.readFieldEnd()
16547 
    iprot.readStructEnd()
16548 
 
16549 
  def write(self, oprot):
16550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16552 
      return
16553 
    oprot.writeStructBegin('getAllInsurers_result')
16554 
    if self.success is not None:
16555 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16556 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16557 
      for iter313 in self.success:
16558 
        iter313.write(oprot)
6838 vikram.rag 16559 
      oprot.writeListEnd()
16560 
      oprot.writeFieldEnd()
16561 
    oprot.writeFieldStop()
16562 
    oprot.writeStructEnd()
16563 
 
16564 
  def validate(self):
16565 
    return
16566 
 
16567 
 
16568 
  def __repr__(self):
16569 
    L = ['%s=%r' % (key, value)
16570 
      for key, value in self.__dict__.iteritems()]
16571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16572 
 
16573 
  def __eq__(self, other):
16574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16575 
 
16576 
  def __ne__(self, other):
16577 
    return not (self == other)
6962 rajveer 16578 
 
16579 
class updateInsuranceDeclaredAmount_args:
16580 
  """
16581 
  Attributes:
16582 
   - insurerId
16583 
   - amount
16584 
  """
16585 
 
16586 
  thrift_spec = (
16587 
    None, # 0
16588 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16589 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16590 
  )
16591 
 
16592 
  def __init__(self, insurerId=None, amount=None,):
16593 
    self.insurerId = insurerId
16594 
    self.amount = amount
16595 
 
16596 
  def read(self, iprot):
16597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16599 
      return
16600 
    iprot.readStructBegin()
16601 
    while True:
16602 
      (fname, ftype, fid) = iprot.readFieldBegin()
16603 
      if ftype == TType.STOP:
16604 
        break
16605 
      if fid == 1:
16606 
        if ftype == TType.I64:
16607 
          self.insurerId = iprot.readI64();
16608 
        else:
16609 
          iprot.skip(ftype)
16610 
      elif fid == 2:
16611 
        if ftype == TType.DOUBLE:
16612 
          self.amount = iprot.readDouble();
16613 
        else:
16614 
          iprot.skip(ftype)
16615 
      else:
16616 
        iprot.skip(ftype)
16617 
      iprot.readFieldEnd()
16618 
    iprot.readStructEnd()
16619 
 
16620 
  def write(self, oprot):
16621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16623 
      return
16624 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16625 
    if self.insurerId is not None:
16626 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16627 
      oprot.writeI64(self.insurerId)
16628 
      oprot.writeFieldEnd()
16629 
    if self.amount is not None:
16630 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16631 
      oprot.writeDouble(self.amount)
16632 
      oprot.writeFieldEnd()
16633 
    oprot.writeFieldStop()
16634 
    oprot.writeStructEnd()
16635 
 
16636 
  def validate(self):
16637 
    return
16638 
 
16639 
 
16640 
  def __repr__(self):
16641 
    L = ['%s=%r' % (key, value)
16642 
      for key, value in self.__dict__.iteritems()]
16643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16644 
 
16645 
  def __eq__(self, other):
16646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16647 
 
16648 
  def __ne__(self, other):
16649 
    return not (self == other)
16650 
 
16651 
class updateInsuranceDeclaredAmount_result:
16652 
 
16653 
  thrift_spec = (
16654 
  )
16655 
 
16656 
  def read(self, iprot):
16657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16659 
      return
16660 
    iprot.readStructBegin()
16661 
    while True:
16662 
      (fname, ftype, fid) = iprot.readFieldBegin()
16663 
      if ftype == TType.STOP:
16664 
        break
16665 
      else:
16666 
        iprot.skip(ftype)
16667 
      iprot.readFieldEnd()
16668 
    iprot.readStructEnd()
16669 
 
16670 
  def write(self, oprot):
16671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16673 
      return
16674 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16675 
    oprot.writeFieldStop()
16676 
    oprot.writeStructEnd()
16677 
 
16678 
  def validate(self):
16679 
    return
16680 
 
16681 
 
16682 
  def __repr__(self):
16683 
    L = ['%s=%r' % (key, value)
16684 
      for key, value in self.__dict__.iteritems()]
16685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16686 
 
16687 
  def __eq__(self, other):
16688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16689 
 
16690 
  def __ne__(self, other):
16691 
    return not (self == other)
7190 amar.kumar 16692 
 
16693 
class getFreebieForItem_args:
16694 
  """
16695 
  Attributes:
16696 
   - itemId
16697 
  """
16698 
 
16699 
  thrift_spec = (
16700 
    None, # 0
16701 
    (1, TType.I64, 'itemId', None, None, ), # 1
16702 
  )
16703 
 
16704 
  def __init__(self, itemId=None,):
16705 
    self.itemId = itemId
16706 
 
16707 
  def read(self, iprot):
16708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16710 
      return
16711 
    iprot.readStructBegin()
16712 
    while True:
16713 
      (fname, ftype, fid) = iprot.readFieldBegin()
16714 
      if ftype == TType.STOP:
16715 
        break
16716 
      if fid == 1:
16717 
        if ftype == TType.I64:
16718 
          self.itemId = iprot.readI64();
16719 
        else:
16720 
          iprot.skip(ftype)
16721 
      else:
16722 
        iprot.skip(ftype)
16723 
      iprot.readFieldEnd()
16724 
    iprot.readStructEnd()
16725 
 
16726 
  def write(self, oprot):
16727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16729 
      return
16730 
    oprot.writeStructBegin('getFreebieForItem_args')
16731 
    if self.itemId is not None:
16732 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16733 
      oprot.writeI64(self.itemId)
16734 
      oprot.writeFieldEnd()
16735 
    oprot.writeFieldStop()
16736 
    oprot.writeStructEnd()
16737 
 
16738 
  def validate(self):
16739 
    return
16740 
 
16741 
 
16742 
  def __repr__(self):
16743 
    L = ['%s=%r' % (key, value)
16744 
      for key, value in self.__dict__.iteritems()]
16745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16746 
 
16747 
  def __eq__(self, other):
16748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16749 
 
16750 
  def __ne__(self, other):
16751 
    return not (self == other)
16752 
 
16753 
class getFreebieForItem_result:
16754 
  """
16755 
  Attributes:
16756 
   - success
16757 
  """
16758 
 
16759 
  thrift_spec = (
16760 
    (0, TType.I64, 'success', None, None, ), # 0
16761 
  )
16762 
 
16763 
  def __init__(self, success=None,):
16764 
    self.success = success
16765 
 
16766 
  def read(self, iprot):
16767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16769 
      return
16770 
    iprot.readStructBegin()
16771 
    while True:
16772 
      (fname, ftype, fid) = iprot.readFieldBegin()
16773 
      if ftype == TType.STOP:
16774 
        break
16775 
      if fid == 0:
16776 
        if ftype == TType.I64:
16777 
          self.success = iprot.readI64();
16778 
        else:
16779 
          iprot.skip(ftype)
16780 
      else:
16781 
        iprot.skip(ftype)
16782 
      iprot.readFieldEnd()
16783 
    iprot.readStructEnd()
16784 
 
16785 
  def write(self, oprot):
16786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16788 
      return
16789 
    oprot.writeStructBegin('getFreebieForItem_result')
16790 
    if self.success is not None:
16791 
      oprot.writeFieldBegin('success', TType.I64, 0)
16792 
      oprot.writeI64(self.success)
16793 
      oprot.writeFieldEnd()
16794 
    oprot.writeFieldStop()
16795 
    oprot.writeStructEnd()
16796 
 
16797 
  def validate(self):
16798 
    return
16799 
 
16800 
 
16801 
  def __repr__(self):
16802 
    L = ['%s=%r' % (key, value)
16803 
      for key, value in self.__dict__.iteritems()]
16804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16805 
 
16806 
  def __eq__(self, other):
16807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16808 
 
16809 
  def __ne__(self, other):
16810 
    return not (self == other)
16811 
 
16812 
class addOrUpdateFreebieForItem_args:
16813 
  """
16814 
  Attributes:
16815 
   - freebieItem
16816 
  """
16817 
 
16818 
  thrift_spec = (
16819 
    None, # 0
16820 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16821 
  )
16822 
 
16823 
  def __init__(self, freebieItem=None,):
16824 
    self.freebieItem = freebieItem
16825 
 
16826 
  def read(self, iprot):
16827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16829 
      return
16830 
    iprot.readStructBegin()
16831 
    while True:
16832 
      (fname, ftype, fid) = iprot.readFieldBegin()
16833 
      if ftype == TType.STOP:
16834 
        break
16835 
      if fid == 1:
16836 
        if ftype == TType.STRUCT:
16837 
          self.freebieItem = FreebieItem()
16838 
          self.freebieItem.read(iprot)
16839 
        else:
16840 
          iprot.skip(ftype)
16841 
      else:
16842 
        iprot.skip(ftype)
16843 
      iprot.readFieldEnd()
16844 
    iprot.readStructEnd()
16845 
 
16846 
  def write(self, oprot):
16847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16849 
      return
16850 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16851 
    if self.freebieItem is not None:
16852 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16853 
      self.freebieItem.write(oprot)
16854 
      oprot.writeFieldEnd()
16855 
    oprot.writeFieldStop()
16856 
    oprot.writeStructEnd()
16857 
 
16858 
  def validate(self):
16859 
    return
16860 
 
16861 
 
16862 
  def __repr__(self):
16863 
    L = ['%s=%r' % (key, value)
16864 
      for key, value in self.__dict__.iteritems()]
16865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16866 
 
16867 
  def __eq__(self, other):
16868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16869 
 
16870 
  def __ne__(self, other):
16871 
    return not (self == other)
16872 
 
16873 
class addOrUpdateFreebieForItem_result:
16874 
 
16875 
  thrift_spec = (
16876 
  )
16877 
 
16878 
  def read(self, iprot):
16879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16881 
      return
16882 
    iprot.readStructBegin()
16883 
    while True:
16884 
      (fname, ftype, fid) = iprot.readFieldBegin()
16885 
      if ftype == TType.STOP:
16886 
        break
16887 
      else:
16888 
        iprot.skip(ftype)
16889 
      iprot.readFieldEnd()
16890 
    iprot.readStructEnd()
16891 
 
16892 
  def write(self, oprot):
16893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16895 
      return
16896 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16897 
    oprot.writeFieldStop()
16898 
    oprot.writeStructEnd()
16899 
 
16900 
  def validate(self):
16901 
    return
16902 
 
16903 
 
16904 
  def __repr__(self):
16905 
    L = ['%s=%r' % (key, value)
16906 
      for key, value in self.__dict__.iteritems()]
16907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16908 
 
16909 
  def __eq__(self, other):
16910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16911 
 
16912 
  def __ne__(self, other):
16913 
    return not (self == other)
7256 rajveer 16914 
 
7272 amit.gupta 16915 
class addOrUpdateBrandInfo_args:
16916 
  """
16917 
  Attributes:
16918 
   - brandInfo
16919 
  """
16920 
 
16921 
  thrift_spec = (
16922 
    None, # 0
16923 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16924 
  )
16925 
 
16926 
  def __init__(self, brandInfo=None,):
16927 
    self.brandInfo = brandInfo
16928 
 
16929 
  def read(self, iprot):
16930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16932 
      return
16933 
    iprot.readStructBegin()
16934 
    while True:
16935 
      (fname, ftype, fid) = iprot.readFieldBegin()
16936 
      if ftype == TType.STOP:
16937 
        break
16938 
      if fid == 1:
16939 
        if ftype == TType.STRUCT:
16940 
          self.brandInfo = BrandInfo()
16941 
          self.brandInfo.read(iprot)
16942 
        else:
16943 
          iprot.skip(ftype)
16944 
      else:
16945 
        iprot.skip(ftype)
16946 
      iprot.readFieldEnd()
16947 
    iprot.readStructEnd()
16948 
 
16949 
  def write(self, oprot):
16950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16952 
      return
16953 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16954 
    if self.brandInfo is not None:
16955 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16956 
      self.brandInfo.write(oprot)
16957 
      oprot.writeFieldEnd()
16958 
    oprot.writeFieldStop()
16959 
    oprot.writeStructEnd()
16960 
 
16961 
  def validate(self):
16962 
    return
16963 
 
16964 
 
16965 
  def __repr__(self):
16966 
    L = ['%s=%r' % (key, value)
16967 
      for key, value in self.__dict__.iteritems()]
16968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16969 
 
16970 
  def __eq__(self, other):
16971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16972 
 
16973 
  def __ne__(self, other):
16974 
    return not (self == other)
16975 
 
16976 
class addOrUpdateBrandInfo_result:
16977 
 
16978 
  thrift_spec = (
16979 
  )
16980 
 
16981 
  def read(self, iprot):
16982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16984 
      return
16985 
    iprot.readStructBegin()
16986 
    while True:
16987 
      (fname, ftype, fid) = iprot.readFieldBegin()
16988 
      if ftype == TType.STOP:
16989 
        break
16990 
      else:
16991 
        iprot.skip(ftype)
16992 
      iprot.readFieldEnd()
16993 
    iprot.readStructEnd()
16994 
 
16995 
  def write(self, oprot):
16996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16998 
      return
16999 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
17000 
    oprot.writeFieldStop()
17001 
    oprot.writeStructEnd()
17002 
 
17003 
  def validate(self):
17004 
    return
17005 
 
17006 
 
17007 
  def __repr__(self):
17008 
    L = ['%s=%r' % (key, value)
17009 
      for key, value in self.__dict__.iteritems()]
17010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17011 
 
17012 
  def __eq__(self, other):
17013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17014 
 
17015 
  def __ne__(self, other):
17016 
    return not (self == other)
17017 
 
17018 
class getBrandInfo_args:
17019 
 
17020 
  thrift_spec = (
17021 
  )
17022 
 
17023 
  def read(self, iprot):
17024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17026 
      return
17027 
    iprot.readStructBegin()
17028 
    while True:
17029 
      (fname, ftype, fid) = iprot.readFieldBegin()
17030 
      if ftype == TType.STOP:
17031 
        break
17032 
      else:
17033 
        iprot.skip(ftype)
17034 
      iprot.readFieldEnd()
17035 
    iprot.readStructEnd()
17036 
 
17037 
  def write(self, oprot):
17038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17040 
      return
17041 
    oprot.writeStructBegin('getBrandInfo_args')
17042 
    oprot.writeFieldStop()
17043 
    oprot.writeStructEnd()
17044 
 
17045 
  def validate(self):
17046 
    return
17047 
 
17048 
 
17049 
  def __repr__(self):
17050 
    L = ['%s=%r' % (key, value)
17051 
      for key, value in self.__dict__.iteritems()]
17052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17053 
 
17054 
  def __eq__(self, other):
17055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17056 
 
17057 
  def __ne__(self, other):
17058 
    return not (self == other)
17059 
 
17060 
class getBrandInfo_result:
17061 
  """
17062 
  Attributes:
17063 
   - success
17064 
  """
17065 
 
17066 
  thrift_spec = (
17067 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
17068 
  )
17069 
 
17070 
  def __init__(self, success=None,):
17071 
    self.success = success
17072 
 
17073 
  def read(self, iprot):
17074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17076 
      return
17077 
    iprot.readStructBegin()
17078 
    while True:
17079 
      (fname, ftype, fid) = iprot.readFieldBegin()
17080 
      if ftype == TType.STOP:
17081 
        break
17082 
      if fid == 0:
17083 
        if ftype == TType.MAP:
17084 
          self.success = {}
7438 amit.gupta 17085 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
17086 
          for _i318 in xrange(_size314):
17087 
            _key319 = iprot.readString();
17088 
            _val320 = BrandInfo()
17089 
            _val320.read(iprot)
17090 
            self.success[_key319] = _val320
7272 amit.gupta 17091 
          iprot.readMapEnd()
17092 
        else:
17093 
          iprot.skip(ftype)
17094 
      else:
17095 
        iprot.skip(ftype)
17096 
      iprot.readFieldEnd()
17097 
    iprot.readStructEnd()
17098 
 
17099 
  def write(self, oprot):
17100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17102 
      return
17103 
    oprot.writeStructBegin('getBrandInfo_result')
17104 
    if self.success is not None:
17105 
      oprot.writeFieldBegin('success', TType.MAP, 0)
17106 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 17107 
      for kiter321,viter322 in self.success.items():
17108 
        oprot.writeString(kiter321)
17109 
        viter322.write(oprot)
7272 amit.gupta 17110 
      oprot.writeMapEnd()
17111 
      oprot.writeFieldEnd()
17112 
    oprot.writeFieldStop()
17113 
    oprot.writeStructEnd()
17114 
 
17115 
  def validate(self):
17116 
    return
17117 
 
17118 
 
17119 
  def __repr__(self):
17120 
    L = ['%s=%r' % (key, value)
17121 
      for key, value in self.__dict__.iteritems()]
17122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17123 
 
17124 
  def __eq__(self, other):
17125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17126 
 
17127 
  def __ne__(self, other):
17128 
    return not (self == other)
17129 
 
7256 rajveer 17130 
class getStorePricing_args:
17131 
  """
17132 
  Attributes:
17133 
   - itemId
17134 
  """
17135 
 
17136 
  thrift_spec = (
17137 
    None, # 0
17138 
    (1, TType.I64, 'itemId', None, None, ), # 1
17139 
  )
17140 
 
17141 
  def __init__(self, itemId=None,):
17142 
    self.itemId = itemId
17143 
 
17144 
  def read(self, iprot):
17145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17147 
      return
17148 
    iprot.readStructBegin()
17149 
    while True:
17150 
      (fname, ftype, fid) = iprot.readFieldBegin()
17151 
      if ftype == TType.STOP:
17152 
        break
17153 
      if fid == 1:
17154 
        if ftype == TType.I64:
17155 
          self.itemId = iprot.readI64();
17156 
        else:
17157 
          iprot.skip(ftype)
17158 
      else:
17159 
        iprot.skip(ftype)
17160 
      iprot.readFieldEnd()
17161 
    iprot.readStructEnd()
17162 
 
17163 
  def write(self, oprot):
17164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17166 
      return
17167 
    oprot.writeStructBegin('getStorePricing_args')
17168 
    if self.itemId is not None:
17169 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17170 
      oprot.writeI64(self.itemId)
17171 
      oprot.writeFieldEnd()
17172 
    oprot.writeFieldStop()
17173 
    oprot.writeStructEnd()
17174 
 
17175 
  def validate(self):
17176 
    return
17177 
 
17178 
 
17179 
  def __repr__(self):
17180 
    L = ['%s=%r' % (key, value)
17181 
      for key, value in self.__dict__.iteritems()]
17182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17183 
 
17184 
  def __eq__(self, other):
17185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17186 
 
17187 
  def __ne__(self, other):
17188 
    return not (self == other)
17189 
 
17190 
class getStorePricing_result:
17191 
  """
17192 
  Attributes:
17193 
   - success
17194 
  """
17195 
 
17196 
  thrift_spec = (
17197 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
17198 
  )
17199 
 
17200 
  def __init__(self, success=None,):
17201 
    self.success = success
17202 
 
17203 
  def read(self, iprot):
17204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17206 
      return
17207 
    iprot.readStructBegin()
17208 
    while True:
17209 
      (fname, ftype, fid) = iprot.readFieldBegin()
17210 
      if ftype == TType.STOP:
17211 
        break
17212 
      if fid == 0:
17213 
        if ftype == TType.STRUCT:
17214 
          self.success = StorePricing()
17215 
          self.success.read(iprot)
17216 
        else:
17217 
          iprot.skip(ftype)
17218 
      else:
17219 
        iprot.skip(ftype)
17220 
      iprot.readFieldEnd()
17221 
    iprot.readStructEnd()
17222 
 
17223 
  def write(self, oprot):
17224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17226 
      return
17227 
    oprot.writeStructBegin('getStorePricing_result')
17228 
    if self.success is not None:
17229 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17230 
      self.success.write(oprot)
17231 
      oprot.writeFieldEnd()
17232 
    oprot.writeFieldStop()
17233 
    oprot.writeStructEnd()
17234 
 
17235 
  def validate(self):
17236 
    return
17237 
 
17238 
 
17239 
  def __repr__(self):
17240 
    L = ['%s=%r' % (key, value)
17241 
      for key, value in self.__dict__.iteritems()]
17242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17243 
 
17244 
  def __eq__(self, other):
17245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17246 
 
17247 
  def __ne__(self, other):
17248 
    return not (self == other)
7265 rajveer 17249 
 
7306 rajveer 17250 
class getStorePricings_args:
17251 
  """
17252 
  Attributes:
17253 
   - itemIds
17254 
  """
17255 
 
17256 
  thrift_spec = (
17257 
    None, # 0
17258 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17259 
  )
17260 
 
17261 
  def __init__(self, itemIds=None,):
17262 
    self.itemIds = itemIds
17263 
 
17264 
  def read(self, iprot):
17265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17267 
      return
17268 
    iprot.readStructBegin()
17269 
    while True:
17270 
      (fname, ftype, fid) = iprot.readFieldBegin()
17271 
      if ftype == TType.STOP:
17272 
        break
17273 
      if fid == 1:
17274 
        if ftype == TType.LIST:
17275 
          self.itemIds = []
7438 amit.gupta 17276 
          (_etype326, _size323) = iprot.readListBegin()
17277 
          for _i327 in xrange(_size323):
17278 
            _elem328 = iprot.readI64();
17279 
            self.itemIds.append(_elem328)
7306 rajveer 17280 
          iprot.readListEnd()
17281 
        else:
17282 
          iprot.skip(ftype)
17283 
      else:
17284 
        iprot.skip(ftype)
17285 
      iprot.readFieldEnd()
17286 
    iprot.readStructEnd()
17287 
 
17288 
  def write(self, oprot):
17289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17291 
      return
17292 
    oprot.writeStructBegin('getStorePricings_args')
17293 
    if self.itemIds is not None:
17294 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17295 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 17296 
      for iter329 in self.itemIds:
17297 
        oprot.writeI64(iter329)
7306 rajveer 17298 
      oprot.writeListEnd()
17299 
      oprot.writeFieldEnd()
17300 
    oprot.writeFieldStop()
17301 
    oprot.writeStructEnd()
17302 
 
17303 
  def validate(self):
17304 
    return
17305 
 
17306 
 
17307 
  def __repr__(self):
17308 
    L = ['%s=%r' % (key, value)
17309 
      for key, value in self.__dict__.iteritems()]
17310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17311 
 
17312 
  def __eq__(self, other):
17313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17314 
 
17315 
  def __ne__(self, other):
17316 
    return not (self == other)
17317 
 
17318 
class getStorePricings_result:
17319 
  """
17320 
  Attributes:
17321 
   - success
17322 
  """
17323 
 
17324 
  thrift_spec = (
17325 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
17326 
  )
17327 
 
17328 
  def __init__(self, success=None,):
17329 
    self.success = success
17330 
 
17331 
  def read(self, iprot):
17332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17334 
      return
17335 
    iprot.readStructBegin()
17336 
    while True:
17337 
      (fname, ftype, fid) = iprot.readFieldBegin()
17338 
      if ftype == TType.STOP:
17339 
        break
17340 
      if fid == 0:
17341 
        if ftype == TType.LIST:
17342 
          self.success = []
7438 amit.gupta 17343 
          (_etype333, _size330) = iprot.readListBegin()
17344 
          for _i334 in xrange(_size330):
17345 
            _elem335 = StorePricing()
17346 
            _elem335.read(iprot)
17347 
            self.success.append(_elem335)
7306 rajveer 17348 
          iprot.readListEnd()
17349 
        else:
17350 
          iprot.skip(ftype)
17351 
      else:
17352 
        iprot.skip(ftype)
17353 
      iprot.readFieldEnd()
17354 
    iprot.readStructEnd()
17355 
 
17356 
  def write(self, oprot):
17357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17359 
      return
17360 
    oprot.writeStructBegin('getStorePricings_result')
17361 
    if self.success is not None:
17362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17363 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17364 
      for iter336 in self.success:
17365 
        iter336.write(oprot)
7306 rajveer 17366 
      oprot.writeListEnd()
17367 
      oprot.writeFieldEnd()
17368 
    oprot.writeFieldStop()
17369 
    oprot.writeStructEnd()
17370 
 
17371 
  def validate(self):
17372 
    return
17373 
 
17374 
 
17375 
  def __repr__(self):
17376 
    L = ['%s=%r' % (key, value)
17377 
      for key, value in self.__dict__.iteritems()]
17378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17379 
 
17380 
  def __eq__(self, other):
17381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17382 
 
17383 
  def __ne__(self, other):
17384 
    return not (self == other)
17385 
 
7265 rajveer 17386 
class updateStorePricing_args:
17387 
  """
17388 
  Attributes:
17389 
   - sp
7382 rajveer 17390 
   - allColors
7265 rajveer 17391 
  """
17392 
 
17393 
  thrift_spec = (
17394 
    None, # 0
17395 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 17396 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 17397 
  )
17398 
 
7382 rajveer 17399 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 17400 
    self.sp = sp
7382 rajveer 17401 
    self.allColors = allColors
7265 rajveer 17402 
 
17403 
  def read(self, iprot):
17404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17406 
      return
17407 
    iprot.readStructBegin()
17408 
    while True:
17409 
      (fname, ftype, fid) = iprot.readFieldBegin()
17410 
      if ftype == TType.STOP:
17411 
        break
17412 
      if fid == 1:
17413 
        if ftype == TType.STRUCT:
17414 
          self.sp = StorePricing()
17415 
          self.sp.read(iprot)
17416 
        else:
17417 
          iprot.skip(ftype)
7382 rajveer 17418 
      elif fid == 2:
17419 
        if ftype == TType.BOOL:
17420 
          self.allColors = iprot.readBool();
17421 
        else:
17422 
          iprot.skip(ftype)
7265 rajveer 17423 
      else:
17424 
        iprot.skip(ftype)
17425 
      iprot.readFieldEnd()
17426 
    iprot.readStructEnd()
17427 
 
17428 
  def write(self, oprot):
17429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17431 
      return
17432 
    oprot.writeStructBegin('updateStorePricing_args')
17433 
    if self.sp is not None:
17434 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
17435 
      self.sp.write(oprot)
17436 
      oprot.writeFieldEnd()
7382 rajveer 17437 
    if self.allColors is not None:
17438 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
17439 
      oprot.writeBool(self.allColors)
17440 
      oprot.writeFieldEnd()
7265 rajveer 17441 
    oprot.writeFieldStop()
17442 
    oprot.writeStructEnd()
17443 
 
17444 
  def validate(self):
17445 
    return
17446 
 
17447 
 
17448 
  def __repr__(self):
17449 
    L = ['%s=%r' % (key, value)
17450 
      for key, value in self.__dict__.iteritems()]
17451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17452 
 
17453 
  def __eq__(self, other):
17454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17455 
 
17456 
  def __ne__(self, other):
17457 
    return not (self == other)
17458 
 
17459 
class updateStorePricing_result:
17460 
 
17461 
  thrift_spec = (
17462 
  )
17463 
 
17464 
  def read(self, iprot):
17465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17467 
      return
17468 
    iprot.readStructBegin()
17469 
    while True:
17470 
      (fname, ftype, fid) = iprot.readFieldBegin()
17471 
      if ftype == TType.STOP:
17472 
        break
17473 
      else:
17474 
        iprot.skip(ftype)
17475 
      iprot.readFieldEnd()
17476 
    iprot.readStructEnd()
17477 
 
17478 
  def write(self, oprot):
17479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17481 
      return
17482 
    oprot.writeStructBegin('updateStorePricing_result')
17483 
    oprot.writeFieldStop()
17484 
    oprot.writeStructEnd()
17485 
 
17486 
  def validate(self):
17487 
    return
17488 
 
17489 
 
17490 
  def __repr__(self):
17491 
    L = ['%s=%r' % (key, value)
17492 
      for key, value in self.__dict__.iteritems()]
17493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17494 
 
17495 
  def __eq__(self, other):
17496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17497 
 
17498 
  def __ne__(self, other):
17499 
    return not (self == other)
7281 kshitij.so 17500 
 
17501 
class getAllAmazonListedItems_args:
17502 
 
17503 
  thrift_spec = (
17504 
  )
17505 
 
17506 
  def read(self, iprot):
17507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17509 
      return
17510 
    iprot.readStructBegin()
17511 
    while True:
17512 
      (fname, ftype, fid) = iprot.readFieldBegin()
17513 
      if ftype == TType.STOP:
17514 
        break
17515 
      else:
17516 
        iprot.skip(ftype)
17517 
      iprot.readFieldEnd()
17518 
    iprot.readStructEnd()
17519 
 
17520 
  def write(self, oprot):
17521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17523 
      return
17524 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17525 
    oprot.writeFieldStop()
17526 
    oprot.writeStructEnd()
17527 
 
17528 
  def validate(self):
17529 
    return
17530 
 
17531 
 
17532 
  def __repr__(self):
17533 
    L = ['%s=%r' % (key, value)
17534 
      for key, value in self.__dict__.iteritems()]
17535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17536 
 
17537 
  def __eq__(self, other):
17538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17539 
 
17540 
  def __ne__(self, other):
17541 
    return not (self == other)
17542 
 
17543 
class getAllAmazonListedItems_result:
17544 
  """
17545 
  Attributes:
17546 
   - success
17547 
  """
17548 
 
17549 
  thrift_spec = (
17550 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17551 
  )
17552 
 
17553 
  def __init__(self, success=None,):
17554 
    self.success = success
17555 
 
17556 
  def read(self, iprot):
17557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17559 
      return
17560 
    iprot.readStructBegin()
17561 
    while True:
17562 
      (fname, ftype, fid) = iprot.readFieldBegin()
17563 
      if ftype == TType.STOP:
17564 
        break
17565 
      if fid == 0:
17566 
        if ftype == TType.LIST:
17567 
          self.success = []
7438 amit.gupta 17568 
          (_etype340, _size337) = iprot.readListBegin()
17569 
          for _i341 in xrange(_size337):
17570 
            _elem342 = Amazonlisted()
17571 
            _elem342.read(iprot)
17572 
            self.success.append(_elem342)
7281 kshitij.so 17573 
          iprot.readListEnd()
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('getAllAmazonListedItems_result')
17586 
    if self.success is not None:
17587 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17588 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17589 
      for iter343 in self.success:
17590 
        iter343.write(oprot)
7281 kshitij.so 17591 
      oprot.writeListEnd()
17592 
      oprot.writeFieldEnd()
17593 
    oprot.writeFieldStop()
17594 
    oprot.writeStructEnd()
17595 
 
17596 
  def validate(self):
17597 
    return
17598 
 
17599 
 
17600 
  def __repr__(self):
17601 
    L = ['%s=%r' % (key, value)
17602 
      for key, value in self.__dict__.iteritems()]
17603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17604 
 
17605 
  def __eq__(self, other):
17606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17607 
 
17608 
  def __ne__(self, other):
17609 
    return not (self == other)
17610 
 
17611 
class getAmazonItemDetails_args:
17612 
  """
17613 
  Attributes:
17614 
   - itemId
17615 
  """
17616 
 
17617 
  thrift_spec = (
17618 
    None, # 0
17619 
    (1, TType.I64, 'itemId', None, None, ), # 1
17620 
  )
17621 
 
17622 
  def __init__(self, itemId=None,):
17623 
    self.itemId = itemId
17624 
 
17625 
  def read(self, iprot):
17626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17628 
      return
17629 
    iprot.readStructBegin()
17630 
    while True:
17631 
      (fname, ftype, fid) = iprot.readFieldBegin()
17632 
      if ftype == TType.STOP:
17633 
        break
17634 
      if fid == 1:
17635 
        if ftype == TType.I64:
17636 
          self.itemId = iprot.readI64();
17637 
        else:
17638 
          iprot.skip(ftype)
17639 
      else:
17640 
        iprot.skip(ftype)
17641 
      iprot.readFieldEnd()
17642 
    iprot.readStructEnd()
17643 
 
17644 
  def write(self, oprot):
17645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17647 
      return
17648 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17649 
    if self.itemId is not None:
17650 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17651 
      oprot.writeI64(self.itemId)
17652 
      oprot.writeFieldEnd()
17653 
    oprot.writeFieldStop()
17654 
    oprot.writeStructEnd()
17655 
 
17656 
  def validate(self):
17657 
    return
17658 
 
17659 
 
17660 
  def __repr__(self):
17661 
    L = ['%s=%r' % (key, value)
17662 
      for key, value in self.__dict__.iteritems()]
17663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17664 
 
17665 
  def __eq__(self, other):
17666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17667 
 
17668 
  def __ne__(self, other):
17669 
    return not (self == other)
17670 
 
17671 
class getAmazonItemDetails_result:
17672 
  """
17673 
  Attributes:
17674 
   - success
17675 
  """
17676 
 
17677 
  thrift_spec = (
17678 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17679 
  )
17680 
 
17681 
  def __init__(self, success=None,):
17682 
    self.success = success
17683 
 
17684 
  def read(self, iprot):
17685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17687 
      return
17688 
    iprot.readStructBegin()
17689 
    while True:
17690 
      (fname, ftype, fid) = iprot.readFieldBegin()
17691 
      if ftype == TType.STOP:
17692 
        break
17693 
      if fid == 0:
17694 
        if ftype == TType.STRUCT:
17695 
          self.success = Amazonlisted()
17696 
          self.success.read(iprot)
17697 
        else:
17698 
          iprot.skip(ftype)
17699 
      else:
17700 
        iprot.skip(ftype)
17701 
      iprot.readFieldEnd()
17702 
    iprot.readStructEnd()
17703 
 
17704 
  def write(self, oprot):
17705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17707 
      return
17708 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17709 
    if self.success is not None:
17710 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17711 
      self.success.write(oprot)
17712 
      oprot.writeFieldEnd()
17713 
    oprot.writeFieldStop()
17714 
    oprot.writeStructEnd()
17715 
 
17716 
  def validate(self):
17717 
    return
17718 
 
17719 
 
17720 
  def __repr__(self):
17721 
    L = ['%s=%r' % (key, value)
17722 
      for key, value in self.__dict__.iteritems()]
17723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17724 
 
17725 
  def __eq__(self, other):
17726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17727 
 
17728 
  def __ne__(self, other):
17729 
    return not (self == other)
17730 
 
17731 
class updateAmazonItemDetails_args:
17732 
  """
17733 
  Attributes:
8168 kshitij.so 17734 
   - amazonlisted
7281 kshitij.so 17735 
  """
17736 
 
17737 
  thrift_spec = (
17738 
    None, # 0
8168 kshitij.so 17739 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 17740 
  )
17741 
 
8168 kshitij.so 17742 
  def __init__(self, amazonlisted=None,):
17743 
    self.amazonlisted = amazonlisted
7281 kshitij.so 17744 
 
17745 
  def read(self, iprot):
17746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17748 
      return
17749 
    iprot.readStructBegin()
17750 
    while True:
17751 
      (fname, ftype, fid) = iprot.readFieldBegin()
17752 
      if ftype == TType.STOP:
17753 
        break
17754 
      if fid == 1:
8168 kshitij.so 17755 
        if ftype == TType.STRUCT:
17756 
          self.amazonlisted = Amazonlisted()
17757 
          self.amazonlisted.read(iprot)
7281 kshitij.so 17758 
        else:
17759 
          iprot.skip(ftype)
17760 
      else:
17761 
        iprot.skip(ftype)
17762 
      iprot.readFieldEnd()
17763 
    iprot.readStructEnd()
17764 
 
17765 
  def write(self, oprot):
17766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17768 
      return
17769 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 17770 
    if self.amazonlisted is not None:
17771 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17772 
      self.amazonlisted.write(oprot)
7281 kshitij.so 17773 
      oprot.writeFieldEnd()
17774 
    oprot.writeFieldStop()
17775 
    oprot.writeStructEnd()
17776 
 
17777 
  def validate(self):
17778 
    return
17779 
 
17780 
 
17781 
  def __repr__(self):
17782 
    L = ['%s=%r' % (key, value)
17783 
      for key, value in self.__dict__.iteritems()]
17784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17785 
 
17786 
  def __eq__(self, other):
17787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17788 
 
17789 
  def __ne__(self, other):
17790 
    return not (self == other)
17791 
 
17792 
class updateAmazonItemDetails_result:
17793 
 
17794 
  thrift_spec = (
17795 
  )
17796 
 
17797 
  def read(self, iprot):
17798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17800 
      return
17801 
    iprot.readStructBegin()
17802 
    while True:
17803 
      (fname, ftype, fid) = iprot.readFieldBegin()
17804 
      if ftype == TType.STOP:
17805 
        break
17806 
      else:
17807 
        iprot.skip(ftype)
17808 
      iprot.readFieldEnd()
17809 
    iprot.readStructEnd()
17810 
 
17811 
  def write(self, oprot):
17812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17814 
      return
17815 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17816 
    oprot.writeFieldStop()
17817 
    oprot.writeStructEnd()
17818 
 
17819 
  def validate(self):
17820 
    return
17821 
 
17822 
 
17823 
  def __repr__(self):
17824 
    L = ['%s=%r' % (key, value)
17825 
      for key, value in self.__dict__.iteritems()]
17826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17827 
 
17828 
  def __eq__(self, other):
17829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17830 
 
17831 
  def __ne__(self, other):
17832 
    return not (self == other)
17833 
 
17834 
class addAmazonItem_args:
17835 
  """
17836 
  Attributes:
17837 
   - amazonlisted
17838 
  """
17839 
 
17840 
  thrift_spec = (
17841 
    None, # 0
17842 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17843 
  )
17844 
 
17845 
  def __init__(self, amazonlisted=None,):
17846 
    self.amazonlisted = amazonlisted
17847 
 
17848 
  def read(self, iprot):
17849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17851 
      return
17852 
    iprot.readStructBegin()
17853 
    while True:
17854 
      (fname, ftype, fid) = iprot.readFieldBegin()
17855 
      if ftype == TType.STOP:
17856 
        break
17857 
      if fid == 1:
17858 
        if ftype == TType.STRUCT:
17859 
          self.amazonlisted = Amazonlisted()
17860 
          self.amazonlisted.read(iprot)
17861 
        else:
17862 
          iprot.skip(ftype)
17863 
      else:
17864 
        iprot.skip(ftype)
17865 
      iprot.readFieldEnd()
17866 
    iprot.readStructEnd()
17867 
 
17868 
  def write(self, oprot):
17869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17871 
      return
17872 
    oprot.writeStructBegin('addAmazonItem_args')
17873 
    if self.amazonlisted is not None:
17874 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17875 
      self.amazonlisted.write(oprot)
17876 
      oprot.writeFieldEnd()
17877 
    oprot.writeFieldStop()
17878 
    oprot.writeStructEnd()
17879 
 
17880 
  def validate(self):
17881 
    return
17882 
 
17883 
 
17884 
  def __repr__(self):
17885 
    L = ['%s=%r' % (key, value)
17886 
      for key, value in self.__dict__.iteritems()]
17887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17888 
 
17889 
  def __eq__(self, other):
17890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17891 
 
17892 
  def __ne__(self, other):
17893 
    return not (self == other)
17894 
 
17895 
class addAmazonItem_result:
17896 
 
17897 
  thrift_spec = (
17898 
  )
17899 
 
17900 
  def read(self, iprot):
17901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17903 
      return
17904 
    iprot.readStructBegin()
17905 
    while True:
17906 
      (fname, ftype, fid) = iprot.readFieldBegin()
17907 
      if ftype == TType.STOP:
17908 
        break
17909 
      else:
17910 
        iprot.skip(ftype)
17911 
      iprot.readFieldEnd()
17912 
    iprot.readStructEnd()
17913 
 
17914 
  def write(self, oprot):
17915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17917 
      return
17918 
    oprot.writeStructBegin('addAmazonItem_result')
17919 
    oprot.writeFieldStop()
17920 
    oprot.writeStructEnd()
17921 
 
17922 
  def validate(self):
17923 
    return
17924 
 
17925 
 
17926 
  def __repr__(self):
17927 
    L = ['%s=%r' % (key, value)
17928 
      for key, value in self.__dict__.iteritems()]
17929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17930 
 
17931 
  def __eq__(self, other):
17932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17933 
 
17934 
  def __ne__(self, other):
17935 
    return not (self == other)
7291 vikram.rag 17936 
 
17937 
class getAsinItems_args:
17938 
 
17939 
  thrift_spec = (
17940 
  )
17941 
 
17942 
  def read(self, iprot):
17943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17945 
      return
17946 
    iprot.readStructBegin()
17947 
    while True:
17948 
      (fname, ftype, fid) = iprot.readFieldBegin()
17949 
      if ftype == TType.STOP:
17950 
        break
17951 
      else:
17952 
        iprot.skip(ftype)
17953 
      iprot.readFieldEnd()
17954 
    iprot.readStructEnd()
17955 
 
17956 
  def write(self, oprot):
17957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17959 
      return
17960 
    oprot.writeStructBegin('getAsinItems_args')
17961 
    oprot.writeFieldStop()
17962 
    oprot.writeStructEnd()
17963 
 
17964 
  def validate(self):
17965 
    return
17966 
 
17967 
 
17968 
  def __repr__(self):
17969 
    L = ['%s=%r' % (key, value)
17970 
      for key, value in self.__dict__.iteritems()]
17971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17972 
 
17973 
  def __eq__(self, other):
17974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17975 
 
17976 
  def __ne__(self, other):
17977 
    return not (self == other)
17978 
 
17979 
class getAsinItems_result:
17980 
  """
17981 
  Attributes:
17982 
   - success
17983 
  """
17984 
 
17985 
  thrift_spec = (
17986 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17987 
  )
17988 
 
17989 
  def __init__(self, success=None,):
17990 
    self.success = success
17991 
 
17992 
  def read(self, iprot):
17993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17995 
      return
17996 
    iprot.readStructBegin()
17997 
    while True:
17998 
      (fname, ftype, fid) = iprot.readFieldBegin()
17999 
      if ftype == TType.STOP:
18000 
        break
18001 
      if fid == 0:
18002 
        if ftype == TType.LIST:
18003 
          self.success = []
7438 amit.gupta 18004 
          (_etype347, _size344) = iprot.readListBegin()
18005 
          for _i348 in xrange(_size344):
18006 
            _elem349 = Item()
18007 
            _elem349.read(iprot)
18008 
            self.success.append(_elem349)
7291 vikram.rag 18009 
          iprot.readListEnd()
18010 
        else:
18011 
          iprot.skip(ftype)
18012 
      else:
18013 
        iprot.skip(ftype)
18014 
      iprot.readFieldEnd()
18015 
    iprot.readStructEnd()
18016 
 
18017 
  def write(self, oprot):
18018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18020 
      return
18021 
    oprot.writeStructBegin('getAsinItems_result')
18022 
    if self.success is not None:
18023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18025 
      for iter350 in self.success:
18026 
        iter350.write(oprot)
7291 vikram.rag 18027 
      oprot.writeListEnd()
18028 
      oprot.writeFieldEnd()
18029 
    oprot.writeFieldStop()
18030 
    oprot.writeStructEnd()
18031 
 
18032 
  def validate(self):
18033 
    return
18034 
 
18035 
 
18036 
  def __repr__(self):
18037 
    L = ['%s=%r' % (key, value)
18038 
      for key, value in self.__dict__.iteritems()]
18039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18040 
 
18041 
  def __eq__(self, other):
18042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18043 
 
18044 
  def __ne__(self, other):
18045 
    return not (self == other)
18046 
 
18047 
class getAllFbaListedItems_args:
18048 
 
18049 
  thrift_spec = (
18050 
  )
18051 
 
18052 
  def read(self, iprot):
18053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18055 
      return
18056 
    iprot.readStructBegin()
18057 
    while True:
18058 
      (fname, ftype, fid) = iprot.readFieldBegin()
18059 
      if ftype == TType.STOP:
18060 
        break
18061 
      else:
18062 
        iprot.skip(ftype)
18063 
      iprot.readFieldEnd()
18064 
    iprot.readStructEnd()
18065 
 
18066 
  def write(self, oprot):
18067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18069 
      return
18070 
    oprot.writeStructBegin('getAllFbaListedItems_args')
18071 
    oprot.writeFieldStop()
18072 
    oprot.writeStructEnd()
18073 
 
18074 
  def validate(self):
18075 
    return
18076 
 
18077 
 
18078 
  def __repr__(self):
18079 
    L = ['%s=%r' % (key, value)
18080 
      for key, value in self.__dict__.iteritems()]
18081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18082 
 
18083 
  def __eq__(self, other):
18084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18085 
 
18086 
  def __ne__(self, other):
18087 
    return not (self == other)
18088 
 
18089 
class getAllFbaListedItems_result:
18090 
  """
18091 
  Attributes:
18092 
   - success
18093 
  """
18094 
 
18095 
  thrift_spec = (
18096 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18097 
  )
18098 
 
18099 
  def __init__(self, success=None,):
18100 
    self.success = success
18101 
 
18102 
  def read(self, iprot):
18103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18105 
      return
18106 
    iprot.readStructBegin()
18107 
    while True:
18108 
      (fname, ftype, fid) = iprot.readFieldBegin()
18109 
      if ftype == TType.STOP:
18110 
        break
18111 
      if fid == 0:
18112 
        if ftype == TType.LIST:
18113 
          self.success = []
7438 amit.gupta 18114 
          (_etype354, _size351) = iprot.readListBegin()
18115 
          for _i355 in xrange(_size351):
18116 
            _elem356 = Amazonlisted()
18117 
            _elem356.read(iprot)
18118 
            self.success.append(_elem356)
7291 vikram.rag 18119 
          iprot.readListEnd()
18120 
        else:
18121 
          iprot.skip(ftype)
18122 
      else:
18123 
        iprot.skip(ftype)
18124 
      iprot.readFieldEnd()
18125 
    iprot.readStructEnd()
18126 
 
18127 
  def write(self, oprot):
18128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18130 
      return
18131 
    oprot.writeStructBegin('getAllFbaListedItems_result')
18132 
    if self.success is not None:
18133 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18134 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18135 
      for iter357 in self.success:
18136 
        iter357.write(oprot)
7291 vikram.rag 18137 
      oprot.writeListEnd()
18138 
      oprot.writeFieldEnd()
18139 
    oprot.writeFieldStop()
18140 
    oprot.writeStructEnd()
18141 
 
18142 
  def validate(self):
18143 
    return
18144 
 
18145 
 
18146 
  def __repr__(self):
18147 
    L = ['%s=%r' % (key, value)
18148 
      for key, value in self.__dict__.iteritems()]
18149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18150 
 
18151 
  def __eq__(self, other):
18152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18153 
 
18154 
  def __ne__(self, other):
18155 
    return not (self == other)
18156 
 
18157 
class getAllNonFbaListedItems_args:
18158 
 
18159 
  thrift_spec = (
18160 
  )
18161 
 
18162 
  def read(self, iprot):
18163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18165 
      return
18166 
    iprot.readStructBegin()
18167 
    while True:
18168 
      (fname, ftype, fid) = iprot.readFieldBegin()
18169 
      if ftype == TType.STOP:
18170 
        break
18171 
      else:
18172 
        iprot.skip(ftype)
18173 
      iprot.readFieldEnd()
18174 
    iprot.readStructEnd()
18175 
 
18176 
  def write(self, oprot):
18177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18179 
      return
18180 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
18181 
    oprot.writeFieldStop()
18182 
    oprot.writeStructEnd()
18183 
 
18184 
  def validate(self):
18185 
    return
18186 
 
18187 
 
18188 
  def __repr__(self):
18189 
    L = ['%s=%r' % (key, value)
18190 
      for key, value in self.__dict__.iteritems()]
18191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18192 
 
18193 
  def __eq__(self, other):
18194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18195 
 
18196 
  def __ne__(self, other):
18197 
    return not (self == other)
18198 
 
18199 
class getAllNonFbaListedItems_result:
18200 
  """
18201 
  Attributes:
18202 
   - success
18203 
  """
18204 
 
18205 
  thrift_spec = (
18206 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18207 
  )
18208 
 
18209 
  def __init__(self, success=None,):
18210 
    self.success = success
18211 
 
18212 
  def read(self, iprot):
18213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18215 
      return
18216 
    iprot.readStructBegin()
18217 
    while True:
18218 
      (fname, ftype, fid) = iprot.readFieldBegin()
18219 
      if ftype == TType.STOP:
18220 
        break
18221 
      if fid == 0:
18222 
        if ftype == TType.LIST:
18223 
          self.success = []
7438 amit.gupta 18224 
          (_etype361, _size358) = iprot.readListBegin()
18225 
          for _i362 in xrange(_size358):
18226 
            _elem363 = Amazonlisted()
18227 
            _elem363.read(iprot)
18228 
            self.success.append(_elem363)
7291 vikram.rag 18229 
          iprot.readListEnd()
18230 
        else:
18231 
          iprot.skip(ftype)
18232 
      else:
18233 
        iprot.skip(ftype)
18234 
      iprot.readFieldEnd()
18235 
    iprot.readStructEnd()
18236 
 
18237 
  def write(self, oprot):
18238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18240 
      return
18241 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
18242 
    if self.success is not None:
18243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18244 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18245 
      for iter364 in self.success:
18246 
        iter364.write(oprot)
7291 vikram.rag 18247 
      oprot.writeListEnd()
18248 
      oprot.writeFieldEnd()
18249 
    oprot.writeFieldStop()
18250 
    oprot.writeStructEnd()
18251 
 
18252 
  def validate(self):
18253 
    return
18254 
 
18255 
 
18256 
  def __repr__(self):
18257 
    L = ['%s=%r' % (key, value)
18258 
      for key, value in self.__dict__.iteritems()]
18259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18260 
 
18261 
  def __eq__(self, other):
18262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18263 
 
18264 
  def __ne__(self, other):
18265 
    return not (self == other)
7460 kshitij.so 18266 
 
18267 
class updateItemInventory_args:
18268 
  """
18269 
  Attributes:
18270 
   - itemId
18271 
   - holdInventory
18272 
   - defaultInventory
18273 
  """
18274 
 
18275 
  thrift_spec = (
18276 
    None, # 0
18277 
    (1, TType.I64, 'itemId', None, None, ), # 1
18278 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
18279 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
18280 
  )
18281 
 
18282 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
18283 
    self.itemId = itemId
18284 
    self.holdInventory = holdInventory
18285 
    self.defaultInventory = defaultInventory
18286 
 
18287 
  def read(self, iprot):
18288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18290 
      return
18291 
    iprot.readStructBegin()
18292 
    while True:
18293 
      (fname, ftype, fid) = iprot.readFieldBegin()
18294 
      if ftype == TType.STOP:
18295 
        break
18296 
      if fid == 1:
18297 
        if ftype == TType.I64:
18298 
          self.itemId = iprot.readI64();
18299 
        else:
18300 
          iprot.skip(ftype)
18301 
      elif fid == 2:
18302 
        if ftype == TType.I64:
18303 
          self.holdInventory = iprot.readI64();
18304 
        else:
18305 
          iprot.skip(ftype)
18306 
      elif fid == 3:
18307 
        if ftype == TType.I64:
18308 
          self.defaultInventory = iprot.readI64();
18309 
        else:
18310 
          iprot.skip(ftype)
18311 
      else:
18312 
        iprot.skip(ftype)
18313 
      iprot.readFieldEnd()
18314 
    iprot.readStructEnd()
18315 
 
18316 
  def write(self, oprot):
18317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18319 
      return
18320 
    oprot.writeStructBegin('updateItemInventory_args')
18321 
    if self.itemId is not None:
18322 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18323 
      oprot.writeI64(self.itemId)
18324 
      oprot.writeFieldEnd()
18325 
    if self.holdInventory is not None:
18326 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
18327 
      oprot.writeI64(self.holdInventory)
18328 
      oprot.writeFieldEnd()
18329 
    if self.defaultInventory is not None:
18330 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
18331 
      oprot.writeI64(self.defaultInventory)
18332 
      oprot.writeFieldEnd()
18333 
    oprot.writeFieldStop()
18334 
    oprot.writeStructEnd()
18335 
 
18336 
  def validate(self):
18337 
    return
18338 
 
18339 
 
18340 
  def __repr__(self):
18341 
    L = ['%s=%r' % (key, value)
18342 
      for key, value in self.__dict__.iteritems()]
18343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18344 
 
18345 
  def __eq__(self, other):
18346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18347 
 
18348 
  def __ne__(self, other):
18349 
    return not (self == other)
18350 
 
18351 
class updateItemInventory_result:
18352 
  """
18353 
  Attributes:
18354 
   - success
18355 
  """
18356 
 
18357 
  thrift_spec = (
18358 
    (0, TType.BOOL, 'success', None, None, ), # 0
18359 
  )
18360 
 
18361 
  def __init__(self, success=None,):
18362 
    self.success = success
18363 
 
18364 
  def read(self, iprot):
18365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18367 
      return
18368 
    iprot.readStructBegin()
18369 
    while True:
18370 
      (fname, ftype, fid) = iprot.readFieldBegin()
18371 
      if ftype == TType.STOP:
18372 
        break
18373 
      if fid == 0:
18374 
        if ftype == TType.BOOL:
18375 
          self.success = iprot.readBool();
18376 
        else:
18377 
          iprot.skip(ftype)
18378 
      else:
18379 
        iprot.skip(ftype)
18380 
      iprot.readFieldEnd()
18381 
    iprot.readStructEnd()
18382 
 
18383 
  def write(self, oprot):
18384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18386 
      return
18387 
    oprot.writeStructBegin('updateItemInventory_result')
18388 
    if self.success is not None:
18389 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18390 
      oprot.writeBool(self.success)
18391 
      oprot.writeFieldEnd()
18392 
    oprot.writeFieldStop()
18393 
    oprot.writeStructEnd()
18394 
 
18395 
  def validate(self):
18396 
    return
18397 
 
18398 
 
18399 
  def __repr__(self):
18400 
    L = ['%s=%r' % (key, value)
18401 
      for key, value in self.__dict__.iteritems()]
18402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18403 
 
18404 
  def __eq__(self, other):
18405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18406 
 
18407 
  def __ne__(self, other):
18408 
    return not (self == other)
7770 kshitij.so 18409 
 
18410 
class updateTimestampForAmazonFeeds_args:
18411 
  """
18412 
  Attributes:
18413 
   - type
18414 
   - sku
18415 
   - timestamp
18416 
  """
18417 
 
18418 
  thrift_spec = (
18419 
    None, # 0
18420 
    (1, TType.STRING, 'type', None, None, ), # 1
18421 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
18422 
    (3, TType.I64, 'timestamp', None, None, ), # 3
18423 
  )
18424 
 
18425 
  def __init__(self, type=None, sku=None, timestamp=None,):
18426 
    self.type = type
18427 
    self.sku = sku
18428 
    self.timestamp = timestamp
18429 
 
18430 
  def read(self, iprot):
18431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18433 
      return
18434 
    iprot.readStructBegin()
18435 
    while True:
18436 
      (fname, ftype, fid) = iprot.readFieldBegin()
18437 
      if ftype == TType.STOP:
18438 
        break
18439 
      if fid == 1:
18440 
        if ftype == TType.STRING:
18441 
          self.type = iprot.readString();
18442 
        else:
18443 
          iprot.skip(ftype)
18444 
      elif fid == 2:
18445 
        if ftype == TType.LIST:
18446 
          self.sku = []
18447 
          (_etype368, _size365) = iprot.readListBegin()
18448 
          for _i369 in xrange(_size365):
18449 
            _elem370 = iprot.readI64();
18450 
            self.sku.append(_elem370)
18451 
          iprot.readListEnd()
18452 
        else:
18453 
          iprot.skip(ftype)
18454 
      elif fid == 3:
18455 
        if ftype == TType.I64:
18456 
          self.timestamp = iprot.readI64();
18457 
        else:
18458 
          iprot.skip(ftype)
18459 
      else:
18460 
        iprot.skip(ftype)
18461 
      iprot.readFieldEnd()
18462 
    iprot.readStructEnd()
18463 
 
18464 
  def write(self, oprot):
18465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18467 
      return
18468 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
18469 
    if self.type is not None:
18470 
      oprot.writeFieldBegin('type', TType.STRING, 1)
18471 
      oprot.writeString(self.type)
18472 
      oprot.writeFieldEnd()
18473 
    if self.sku is not None:
18474 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
18475 
      oprot.writeListBegin(TType.I64, len(self.sku))
18476 
      for iter371 in self.sku:
18477 
        oprot.writeI64(iter371)
18478 
      oprot.writeListEnd()
18479 
      oprot.writeFieldEnd()
18480 
    if self.timestamp is not None:
18481 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
18482 
      oprot.writeI64(self.timestamp)
18483 
      oprot.writeFieldEnd()
18484 
    oprot.writeFieldStop()
18485 
    oprot.writeStructEnd()
18486 
 
18487 
  def validate(self):
18488 
    return
18489 
 
18490 
 
18491 
  def __repr__(self):
18492 
    L = ['%s=%r' % (key, value)
18493 
      for key, value in self.__dict__.iteritems()]
18494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18495 
 
18496 
  def __eq__(self, other):
18497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18498 
 
18499 
  def __ne__(self, other):
18500 
    return not (self == other)
18501 
 
18502 
class updateTimestampForAmazonFeeds_result:
18503 
  """
18504 
  Attributes:
18505 
   - success
18506 
  """
18507 
 
18508 
  thrift_spec = (
18509 
    (0, TType.BOOL, 'success', None, None, ), # 0
18510 
  )
18511 
 
18512 
  def __init__(self, success=None,):
18513 
    self.success = success
18514 
 
18515 
  def read(self, iprot):
18516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18518 
      return
18519 
    iprot.readStructBegin()
18520 
    while True:
18521 
      (fname, ftype, fid) = iprot.readFieldBegin()
18522 
      if ftype == TType.STOP:
18523 
        break
18524 
      if fid == 0:
18525 
        if ftype == TType.BOOL:
18526 
          self.success = iprot.readBool();
18527 
        else:
18528 
          iprot.skip(ftype)
18529 
      else:
18530 
        iprot.skip(ftype)
18531 
      iprot.readFieldEnd()
18532 
    iprot.readStructEnd()
18533 
 
18534 
  def write(self, oprot):
18535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18537 
      return
18538 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
18539 
    if self.success is not None:
18540 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18541 
      oprot.writeBool(self.success)
18542 
      oprot.writeFieldEnd()
18543 
    oprot.writeFieldStop()
18544 
    oprot.writeStructEnd()
18545 
 
18546 
  def validate(self):
18547 
    return
18548 
 
18549 
 
18550 
  def __repr__(self):
18551 
    L = ['%s=%r' % (key, value)
18552 
      for key, value in self.__dict__.iteritems()]
18553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18554 
 
18555 
  def __eq__(self, other):
18556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18557 
 
18558 
  def __ne__(self, other):
18559 
    return not (self == other)
7897 amar.kumar 18560 
 
18561 
class getAllParentCategories_args:
18562 
 
18563 
  thrift_spec = (
18564 
  )
18565 
 
18566 
  def read(self, iprot):
18567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18569 
      return
18570 
    iprot.readStructBegin()
18571 
    while True:
18572 
      (fname, ftype, fid) = iprot.readFieldBegin()
18573 
      if ftype == TType.STOP:
18574 
        break
18575 
      else:
18576 
        iprot.skip(ftype)
18577 
      iprot.readFieldEnd()
18578 
    iprot.readStructEnd()
18579 
 
18580 
  def write(self, oprot):
18581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18583 
      return
18584 
    oprot.writeStructBegin('getAllParentCategories_args')
18585 
    oprot.writeFieldStop()
18586 
    oprot.writeStructEnd()
18587 
 
18588 
  def validate(self):
18589 
    return
18590 
 
18591 
 
18592 
  def __repr__(self):
18593 
    L = ['%s=%r' % (key, value)
18594 
      for key, value in self.__dict__.iteritems()]
18595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18596 
 
18597 
  def __eq__(self, other):
18598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18599 
 
18600 
  def __ne__(self, other):
18601 
    return not (self == other)
18602 
 
18603 
class getAllParentCategories_result:
18604 
  """
18605 
  Attributes:
18606 
   - success
18607 
  """
18608 
 
18609 
  thrift_spec = (
18610 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
18611 
  )
18612 
 
18613 
  def __init__(self, success=None,):
18614 
    self.success = success
18615 
 
18616 
  def read(self, iprot):
18617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18619 
      return
18620 
    iprot.readStructBegin()
18621 
    while True:
18622 
      (fname, ftype, fid) = iprot.readFieldBegin()
18623 
      if ftype == TType.STOP:
18624 
        break
18625 
      if fid == 0:
18626 
        if ftype == TType.LIST:
18627 
          self.success = []
18628 
          (_etype375, _size372) = iprot.readListBegin()
18629 
          for _i376 in xrange(_size372):
18630 
            _elem377 = Category()
18631 
            _elem377.read(iprot)
18632 
            self.success.append(_elem377)
18633 
          iprot.readListEnd()
18634 
        else:
18635 
          iprot.skip(ftype)
18636 
      else:
18637 
        iprot.skip(ftype)
18638 
      iprot.readFieldEnd()
18639 
    iprot.readStructEnd()
18640 
 
18641 
  def write(self, oprot):
18642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18644 
      return
18645 
    oprot.writeStructBegin('getAllParentCategories_result')
18646 
    if self.success is not None:
18647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18649 
      for iter378 in self.success:
18650 
        iter378.write(oprot)
18651 
      oprot.writeListEnd()
18652 
      oprot.writeFieldEnd()
18653 
    oprot.writeFieldStop()
18654 
    oprot.writeStructEnd()
18655 
 
18656 
  def validate(self):
18657 
    return
18658 
 
18659 
 
18660 
  def __repr__(self):
18661 
    L = ['%s=%r' % (key, value)
18662 
      for key, value in self.__dict__.iteritems()]
18663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18664 
 
18665 
  def __eq__(self, other):
18666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18667 
 
18668 
  def __ne__(self, other):
18669 
    return not (self == other)
7977 kshitij.so 18670 
 
18671 
class addPageViewEvent_args:
18672 
  """
18673 
  Attributes:
18674 
   - pageViewEvents
18675 
  """
18676 
 
18677 
  thrift_spec = (
18678 
    None, # 0
18679 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
18680 
  )
18681 
 
18682 
  def __init__(self, pageViewEvents=None,):
18683 
    self.pageViewEvents = pageViewEvents
18684 
 
18685 
  def read(self, iprot):
18686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18688 
      return
18689 
    iprot.readStructBegin()
18690 
    while True:
18691 
      (fname, ftype, fid) = iprot.readFieldBegin()
18692 
      if ftype == TType.STOP:
18693 
        break
18694 
      if fid == 1:
18695 
        if ftype == TType.STRUCT:
18696 
          self.pageViewEvents = PageViewEvents()
18697 
          self.pageViewEvents.read(iprot)
18698 
        else:
18699 
          iprot.skip(ftype)
18700 
      else:
18701 
        iprot.skip(ftype)
18702 
      iprot.readFieldEnd()
18703 
    iprot.readStructEnd()
18704 
 
18705 
  def write(self, oprot):
18706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18708 
      return
18709 
    oprot.writeStructBegin('addPageViewEvent_args')
18710 
    if self.pageViewEvents is not None:
18711 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
18712 
      self.pageViewEvents.write(oprot)
18713 
      oprot.writeFieldEnd()
18714 
    oprot.writeFieldStop()
18715 
    oprot.writeStructEnd()
18716 
 
18717 
  def validate(self):
18718 
    return
18719 
 
18720 
 
18721 
  def __repr__(self):
18722 
    L = ['%s=%r' % (key, value)
18723 
      for key, value in self.__dict__.iteritems()]
18724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18725 
 
18726 
  def __eq__(self, other):
18727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18728 
 
18729 
  def __ne__(self, other):
18730 
    return not (self == other)
18731 
 
18732 
class addPageViewEvent_result:
18733 
 
18734 
  thrift_spec = (
18735 
  )
18736 
 
18737 
  def read(self, iprot):
18738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18740 
      return
18741 
    iprot.readStructBegin()
18742 
    while True:
18743 
      (fname, ftype, fid) = iprot.readFieldBegin()
18744 
      if ftype == TType.STOP:
18745 
        break
18746 
      else:
18747 
        iprot.skip(ftype)
18748 
      iprot.readFieldEnd()
18749 
    iprot.readStructEnd()
18750 
 
18751 
  def write(self, oprot):
18752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18754 
      return
18755 
    oprot.writeStructBegin('addPageViewEvent_result')
18756 
    oprot.writeFieldStop()
18757 
    oprot.writeStructEnd()
18758 
 
18759 
  def validate(self):
18760 
    return
18761 
 
18762 
 
18763 
  def __repr__(self):
18764 
    L = ['%s=%r' % (key, value)
18765 
      for key, value in self.__dict__.iteritems()]
18766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18767 
 
18768 
  def __eq__(self, other):
18769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18770 
 
18771 
  def __ne__(self, other):
18772 
    return not (self == other)
18773 
 
18774 
class addCartEvent_args:
18775 
  """
18776 
  Attributes:
18777 
   - cartEvents
18778 
  """
18779 
 
18780 
  thrift_spec = (
18781 
    None, # 0
18782 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
18783 
  )
18784 
 
18785 
  def __init__(self, cartEvents=None,):
18786 
    self.cartEvents = cartEvents
18787 
 
18788 
  def read(self, iprot):
18789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18791 
      return
18792 
    iprot.readStructBegin()
18793 
    while True:
18794 
      (fname, ftype, fid) = iprot.readFieldBegin()
18795 
      if ftype == TType.STOP:
18796 
        break
18797 
      if fid == 1:
18798 
        if ftype == TType.STRUCT:
18799 
          self.cartEvents = CartEvents()
18800 
          self.cartEvents.read(iprot)
18801 
        else:
18802 
          iprot.skip(ftype)
18803 
      else:
18804 
        iprot.skip(ftype)
18805 
      iprot.readFieldEnd()
18806 
    iprot.readStructEnd()
18807 
 
18808 
  def write(self, oprot):
18809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18811 
      return
18812 
    oprot.writeStructBegin('addCartEvent_args')
18813 
    if self.cartEvents is not None:
18814 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
18815 
      self.cartEvents.write(oprot)
18816 
      oprot.writeFieldEnd()
18817 
    oprot.writeFieldStop()
18818 
    oprot.writeStructEnd()
18819 
 
18820 
  def validate(self):
18821 
    return
18822 
 
18823 
 
18824 
  def __repr__(self):
18825 
    L = ['%s=%r' % (key, value)
18826 
      for key, value in self.__dict__.iteritems()]
18827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18828 
 
18829 
  def __eq__(self, other):
18830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18831 
 
18832 
  def __ne__(self, other):
18833 
    return not (self == other)
18834 
 
18835 
class addCartEvent_result:
18836 
 
18837 
  thrift_spec = (
18838 
  )
18839 
 
18840 
  def read(self, iprot):
18841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18843 
      return
18844 
    iprot.readStructBegin()
18845 
    while True:
18846 
      (fname, ftype, fid) = iprot.readFieldBegin()
18847 
      if ftype == TType.STOP:
18848 
        break
18849 
      else:
18850 
        iprot.skip(ftype)
18851 
      iprot.readFieldEnd()
18852 
    iprot.readStructEnd()
18853 
 
18854 
  def write(self, oprot):
18855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18857 
      return
18858 
    oprot.writeStructBegin('addCartEvent_result')
18859 
    oprot.writeFieldStop()
18860 
    oprot.writeStructEnd()
18861 
 
18862 
  def validate(self):
18863 
    return
18864 
 
18865 
 
18866 
  def __repr__(self):
18867 
    L = ['%s=%r' % (key, value)
18868 
      for key, value in self.__dict__.iteritems()]
18869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18870 
 
18871 
  def __eq__(self, other):
18872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18873 
 
18874 
  def __ne__(self, other):
18875 
    return not (self == other)
8139 kshitij.so 18876 
 
8182 amar.kumar 18877 
class addEbayItem_args:
18878 
  """
18879 
  Attributes:
18880 
   - ebayItem
18881 
  """
18882 
 
18883 
  thrift_spec = (
18884 
    None, # 0
18885 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
18886 
  )
18887 
 
18888 
  def __init__(self, ebayItem=None,):
18889 
    self.ebayItem = ebayItem
18890 
 
18891 
  def read(self, iprot):
18892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18894 
      return
18895 
    iprot.readStructBegin()
18896 
    while True:
18897 
      (fname, ftype, fid) = iprot.readFieldBegin()
18898 
      if ftype == TType.STOP:
18899 
        break
18900 
      if fid == 1:
18901 
        if ftype == TType.STRUCT:
18902 
          self.ebayItem = EbayItem()
18903 
          self.ebayItem.read(iprot)
18904 
        else:
18905 
          iprot.skip(ftype)
18906 
      else:
18907 
        iprot.skip(ftype)
18908 
      iprot.readFieldEnd()
18909 
    iprot.readStructEnd()
18910 
 
18911 
  def write(self, oprot):
18912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18914 
      return
18915 
    oprot.writeStructBegin('addEbayItem_args')
18916 
    if self.ebayItem is not None:
18917 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
18918 
      self.ebayItem.write(oprot)
18919 
      oprot.writeFieldEnd()
18920 
    oprot.writeFieldStop()
18921 
    oprot.writeStructEnd()
18922 
 
18923 
  def validate(self):
18924 
    return
18925 
 
18926 
 
18927 
  def __repr__(self):
18928 
    L = ['%s=%r' % (key, value)
18929 
      for key, value in self.__dict__.iteritems()]
18930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18931 
 
18932 
  def __eq__(self, other):
18933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18934 
 
18935 
  def __ne__(self, other):
18936 
    return not (self == other)
18937 
 
18938 
class addEbayItem_result:
18939 
 
18940 
  thrift_spec = (
18941 
  )
18942 
 
18943 
  def read(self, iprot):
18944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18946 
      return
18947 
    iprot.readStructBegin()
18948 
    while True:
18949 
      (fname, ftype, fid) = iprot.readFieldBegin()
18950 
      if ftype == TType.STOP:
18951 
        break
18952 
      else:
18953 
        iprot.skip(ftype)
18954 
      iprot.readFieldEnd()
18955 
    iprot.readStructEnd()
18956 
 
18957 
  def write(self, oprot):
18958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18960 
      return
18961 
    oprot.writeStructBegin('addEbayItem_result')
18962 
    oprot.writeFieldStop()
18963 
    oprot.writeStructEnd()
18964 
 
18965 
  def validate(self):
18966 
    return
18967 
 
18968 
 
18969 
  def __repr__(self):
18970 
    L = ['%s=%r' % (key, value)
18971 
      for key, value in self.__dict__.iteritems()]
18972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18973 
 
18974 
  def __eq__(self, other):
18975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18976 
 
18977 
  def __ne__(self, other):
18978 
    return not (self == other)
18979 
 
18980 
class getEbayItem_args:
18981 
  """
18982 
  Attributes:
18983 
   - listingId
18984 
  """
18985 
 
18986 
  thrift_spec = (
18987 
    None, # 0
18988 
    (1, TType.STRING, 'listingId', None, None, ), # 1
18989 
  )
18990 
 
18991 
  def __init__(self, listingId=None,):
18992 
    self.listingId = listingId
18993 
 
18994 
  def read(self, iprot):
18995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18997 
      return
18998 
    iprot.readStructBegin()
18999 
    while True:
19000 
      (fname, ftype, fid) = iprot.readFieldBegin()
19001 
      if ftype == TType.STOP:
19002 
        break
19003 
      if fid == 1:
19004 
        if ftype == TType.STRING:
19005 
          self.listingId = iprot.readString();
19006 
        else:
19007 
          iprot.skip(ftype)
19008 
      else:
19009 
        iprot.skip(ftype)
19010 
      iprot.readFieldEnd()
19011 
    iprot.readStructEnd()
19012 
 
19013 
  def write(self, oprot):
19014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19016 
      return
19017 
    oprot.writeStructBegin('getEbayItem_args')
19018 
    if self.listingId is not None:
19019 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
19020 
      oprot.writeString(self.listingId)
19021 
      oprot.writeFieldEnd()
19022 
    oprot.writeFieldStop()
19023 
    oprot.writeStructEnd()
19024 
 
19025 
  def validate(self):
19026 
    return
19027 
 
19028 
 
19029 
  def __repr__(self):
19030 
    L = ['%s=%r' % (key, value)
19031 
      for key, value in self.__dict__.iteritems()]
19032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19033 
 
19034 
  def __eq__(self, other):
19035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19036 
 
19037 
  def __ne__(self, other):
19038 
    return not (self == other)
19039 
 
19040 
class getEbayItem_result:
19041 
  """
19042 
  Attributes:
19043 
   - success
19044 
  """
19045 
 
19046 
  thrift_spec = (
19047 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
19048 
  )
19049 
 
19050 
  def __init__(self, success=None,):
19051 
    self.success = success
19052 
 
19053 
  def read(self, iprot):
19054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19056 
      return
19057 
    iprot.readStructBegin()
19058 
    while True:
19059 
      (fname, ftype, fid) = iprot.readFieldBegin()
19060 
      if ftype == TType.STOP:
19061 
        break
19062 
      if fid == 0:
19063 
        if ftype == TType.STRUCT:
19064 
          self.success = EbayItem()
19065 
          self.success.read(iprot)
19066 
        else:
19067 
          iprot.skip(ftype)
19068 
      else:
19069 
        iprot.skip(ftype)
19070 
      iprot.readFieldEnd()
19071 
    iprot.readStructEnd()
19072 
 
19073 
  def write(self, oprot):
19074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19076 
      return
19077 
    oprot.writeStructBegin('getEbayItem_result')
19078 
    if self.success is not None:
19079 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19080 
      self.success.write(oprot)
19081 
      oprot.writeFieldEnd()
19082 
    oprot.writeFieldStop()
19083 
    oprot.writeStructEnd()
19084 
 
19085 
  def validate(self):
19086 
    return
19087 
 
19088 
 
19089 
  def __repr__(self):
19090 
    L = ['%s=%r' % (key, value)
19091 
      for key, value in self.__dict__.iteritems()]
19092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19093 
 
19094 
  def __eq__(self, other):
19095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19096 
 
19097 
  def __ne__(self, other):
19098 
    return not (self == other)
19099 
 
19100 
class updateEbayItem_args:
19101 
  """
19102 
  Attributes:
19103 
   - ebayItem
19104 
  """
19105 
 
19106 
  thrift_spec = (
19107 
    None, # 0
19108 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
19109 
  )
19110 
 
19111 
  def __init__(self, ebayItem=None,):
19112 
    self.ebayItem = ebayItem
19113 
 
19114 
  def read(self, iprot):
19115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19117 
      return
19118 
    iprot.readStructBegin()
19119 
    while True:
19120 
      (fname, ftype, fid) = iprot.readFieldBegin()
19121 
      if ftype == TType.STOP:
19122 
        break
19123 
      if fid == 1:
19124 
        if ftype == TType.STRUCT:
19125 
          self.ebayItem = EbayItem()
19126 
          self.ebayItem.read(iprot)
19127 
        else:
19128 
          iprot.skip(ftype)
19129 
      else:
19130 
        iprot.skip(ftype)
19131 
      iprot.readFieldEnd()
19132 
    iprot.readStructEnd()
19133 
 
19134 
  def write(self, oprot):
19135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19137 
      return
19138 
    oprot.writeStructBegin('updateEbayItem_args')
19139 
    if self.ebayItem is not None:
19140 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
19141 
      self.ebayItem.write(oprot)
19142 
      oprot.writeFieldEnd()
19143 
    oprot.writeFieldStop()
19144 
    oprot.writeStructEnd()
19145 
 
19146 
  def validate(self):
19147 
    return
19148 
 
19149 
 
19150 
  def __repr__(self):
19151 
    L = ['%s=%r' % (key, value)
19152 
      for key, value in self.__dict__.iteritems()]
19153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19154 
 
19155 
  def __eq__(self, other):
19156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19157 
 
19158 
  def __ne__(self, other):
19159 
    return not (self == other)
19160 
 
19161 
class updateEbayItem_result:
19162 
 
19163 
  thrift_spec = (
19164 
  )
19165 
 
19166 
  def read(self, iprot):
19167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19169 
      return
19170 
    iprot.readStructBegin()
19171 
    while True:
19172 
      (fname, ftype, fid) = iprot.readFieldBegin()
19173 
      if ftype == TType.STOP:
19174 
        break
19175 
      else:
19176 
        iprot.skip(ftype)
19177 
      iprot.readFieldEnd()
19178 
    iprot.readStructEnd()
19179 
 
19180 
  def write(self, oprot):
19181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19183 
      return
19184 
    oprot.writeStructBegin('updateEbayItem_result')
19185 
    oprot.writeFieldStop()
19186 
    oprot.writeStructEnd()
19187 
 
19188 
  def validate(self):
19189 
    return
19190 
 
19191 
 
19192 
  def __repr__(self):
19193 
    L = ['%s=%r' % (key, value)
19194 
      for key, value in self.__dict__.iteritems()]
19195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19196 
 
19197 
  def __eq__(self, other):
19198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19199 
 
19200 
  def __ne__(self, other):
19201 
    return not (self == other)
19202 
 
8139 kshitij.so 19203 
class getAmazonListedItems_args:
19204 
  """
19205 
  Attributes:
19206 
   - offset
19207 
   - limit
19208 
  """
19209 
 
19210 
  thrift_spec = (
19211 
    None, # 0
19212 
    (1, TType.I64, 'offset', None, None, ), # 1
19213 
    (2, TType.I64, 'limit', None, None, ), # 2
19214 
  )
19215 
 
19216 
  def __init__(self, offset=None, limit=None,):
19217 
    self.offset = offset
19218 
    self.limit = limit
19219 
 
19220 
  def read(self, iprot):
19221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19223 
      return
19224 
    iprot.readStructBegin()
19225 
    while True:
19226 
      (fname, ftype, fid) = iprot.readFieldBegin()
19227 
      if ftype == TType.STOP:
19228 
        break
19229 
      if fid == 1:
19230 
        if ftype == TType.I64:
19231 
          self.offset = iprot.readI64();
19232 
        else:
19233 
          iprot.skip(ftype)
19234 
      elif fid == 2:
19235 
        if ftype == TType.I64:
19236 
          self.limit = iprot.readI64();
19237 
        else:
19238 
          iprot.skip(ftype)
19239 
      else:
19240 
        iprot.skip(ftype)
19241 
      iprot.readFieldEnd()
19242 
    iprot.readStructEnd()
19243 
 
19244 
  def write(self, oprot):
19245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19247 
      return
19248 
    oprot.writeStructBegin('getAmazonListedItems_args')
19249 
    if self.offset is not None:
19250 
      oprot.writeFieldBegin('offset', TType.I64, 1)
19251 
      oprot.writeI64(self.offset)
19252 
      oprot.writeFieldEnd()
19253 
    if self.limit is not None:
19254 
      oprot.writeFieldBegin('limit', TType.I64, 2)
19255 
      oprot.writeI64(self.limit)
19256 
      oprot.writeFieldEnd()
19257 
    oprot.writeFieldStop()
19258 
    oprot.writeStructEnd()
19259 
 
19260 
  def validate(self):
19261 
    return
19262 
 
19263 
 
19264 
  def __repr__(self):
19265 
    L = ['%s=%r' % (key, value)
19266 
      for key, value in self.__dict__.iteritems()]
19267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19268 
 
19269 
  def __eq__(self, other):
19270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19271 
 
19272 
  def __ne__(self, other):
19273 
    return not (self == other)
19274 
 
19275 
class getAmazonListedItems_result:
19276 
  """
19277 
  Attributes:
19278 
   - success
19279 
  """
19280 
 
19281 
  thrift_spec = (
19282 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19283 
  )
19284 
 
19285 
  def __init__(self, success=None,):
19286 
    self.success = success
19287 
 
19288 
  def read(self, iprot):
19289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19291 
      return
19292 
    iprot.readStructBegin()
19293 
    while True:
19294 
      (fname, ftype, fid) = iprot.readFieldBegin()
19295 
      if ftype == TType.STOP:
19296 
        break
19297 
      if fid == 0:
19298 
        if ftype == TType.LIST:
19299 
          self.success = []
19300 
          (_etype382, _size379) = iprot.readListBegin()
19301 
          for _i383 in xrange(_size379):
19302 
            _elem384 = Amazonlisted()
19303 
            _elem384.read(iprot)
19304 
            self.success.append(_elem384)
19305 
          iprot.readListEnd()
19306 
        else:
19307 
          iprot.skip(ftype)
19308 
      else:
19309 
        iprot.skip(ftype)
19310 
      iprot.readFieldEnd()
19311 
    iprot.readStructEnd()
19312 
 
19313 
  def write(self, oprot):
19314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19316 
      return
19317 
    oprot.writeStructBegin('getAmazonListedItems_result')
19318 
    if self.success is not None:
19319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19321 
      for iter385 in self.success:
19322 
        iter385.write(oprot)
19323 
      oprot.writeListEnd()
19324 
      oprot.writeFieldEnd()
19325 
    oprot.writeFieldStop()
19326 
    oprot.writeStructEnd()
19327 
 
19328 
  def validate(self):
19329 
    return
19330 
 
19331 
 
19332 
  def __repr__(self):
19333 
    L = ['%s=%r' % (key, value)
19334 
      for key, value in self.__dict__.iteritems()]
19335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19336 
 
19337 
  def __eq__(self, other):
19338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19339 
 
19340 
  def __ne__(self, other):
19341 
    return not (self == other)
8168 kshitij.so 19342 
 
19343 
class updateAmazonAttributesInBulk_args:
19344 
  """
19345 
  Attributes:
19346 
   - amazonlisted
19347 
  """
19348 
 
19349 
  thrift_spec = (
19350 
    None, # 0
19351 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
19352 
  )
19353 
 
19354 
  def __init__(self, amazonlisted=None,):
19355 
    self.amazonlisted = amazonlisted
19356 
 
19357 
  def read(self, iprot):
19358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19360 
      return
19361 
    iprot.readStructBegin()
19362 
    while True:
19363 
      (fname, ftype, fid) = iprot.readFieldBegin()
19364 
      if ftype == TType.STOP:
19365 
        break
19366 
      if fid == 1:
19367 
        if ftype == TType.MAP:
19368 
          self.amazonlisted = {}
19369 
          (_ktype387, _vtype388, _size386 ) = iprot.readMapBegin()
19370 
          for _i390 in xrange(_size386):
19371 
            _key391 = iprot.readI64();
19372 
            _val392 = Amazonlisted()
19373 
            _val392.read(iprot)
19374 
            self.amazonlisted[_key391] = _val392
19375 
          iprot.readMapEnd()
19376 
        else:
19377 
          iprot.skip(ftype)
19378 
      else:
19379 
        iprot.skip(ftype)
19380 
      iprot.readFieldEnd()
19381 
    iprot.readStructEnd()
19382 
 
19383 
  def write(self, oprot):
19384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19386 
      return
19387 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
19388 
    if self.amazonlisted is not None:
19389 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
19390 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
19391 
      for kiter393,viter394 in self.amazonlisted.items():
19392 
        oprot.writeI64(kiter393)
19393 
        viter394.write(oprot)
19394 
      oprot.writeMapEnd()
19395 
      oprot.writeFieldEnd()
19396 
    oprot.writeFieldStop()
19397 
    oprot.writeStructEnd()
19398 
 
19399 
  def validate(self):
19400 
    return
19401 
 
19402 
 
19403 
  def __repr__(self):
19404 
    L = ['%s=%r' % (key, value)
19405 
      for key, value in self.__dict__.iteritems()]
19406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19407 
 
19408 
  def __eq__(self, other):
19409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19410 
 
19411 
  def __ne__(self, other):
19412 
    return not (self == other)
19413 
 
19414 
class updateAmazonAttributesInBulk_result:
19415 
  """
19416 
  Attributes:
19417 
   - success
19418 
  """
19419 
 
19420 
  thrift_spec = (
19421 
    (0, TType.BOOL, 'success', None, None, ), # 0
19422 
  )
19423 
 
19424 
  def __init__(self, success=None,):
19425 
    self.success = success
19426 
 
19427 
  def read(self, iprot):
19428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19430 
      return
19431 
    iprot.readStructBegin()
19432 
    while True:
19433 
      (fname, ftype, fid) = iprot.readFieldBegin()
19434 
      if ftype == TType.STOP:
19435 
        break
19436 
      if fid == 0:
19437 
        if ftype == TType.BOOL:
19438 
          self.success = iprot.readBool();
19439 
        else:
19440 
          iprot.skip(ftype)
19441 
      else:
19442 
        iprot.skip(ftype)
19443 
      iprot.readFieldEnd()
19444 
    iprot.readStructEnd()
19445 
 
19446 
  def write(self, oprot):
19447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19449 
      return
19450 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
19451 
    if self.success is not None:
19452 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19453 
      oprot.writeBool(self.success)
19454 
      oprot.writeFieldEnd()
19455 
    oprot.writeFieldStop()
19456 
    oprot.writeStructEnd()
19457 
 
19458 
  def validate(self):
19459 
    return
19460 
 
19461 
 
19462 
  def __repr__(self):
19463 
    L = ['%s=%r' % (key, value)
19464 
      for key, value in self.__dict__.iteritems()]
19465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19466 
 
19467 
  def __eq__(self, other):
19468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19469 
 
19470 
  def __ne__(self, other):
19471 
    return not (self == other)
8379 vikram.rag 19472 
 
19473 
class getAllItemstoListOnFba_args:
19474 
 
19475 
  thrift_spec = (
19476 
  )
19477 
 
19478 
  def read(self, iprot):
19479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19481 
      return
19482 
    iprot.readStructBegin()
19483 
    while True:
19484 
      (fname, ftype, fid) = iprot.readFieldBegin()
19485 
      if ftype == TType.STOP:
19486 
        break
19487 
      else:
19488 
        iprot.skip(ftype)
19489 
      iprot.readFieldEnd()
19490 
    iprot.readStructEnd()
19491 
 
19492 
  def write(self, oprot):
19493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19495 
      return
19496 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
19497 
    oprot.writeFieldStop()
19498 
    oprot.writeStructEnd()
19499 
 
19500 
  def validate(self):
19501 
    return
19502 
 
19503 
 
19504 
  def __repr__(self):
19505 
    L = ['%s=%r' % (key, value)
19506 
      for key, value in self.__dict__.iteritems()]
19507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19508 
 
19509 
  def __eq__(self, other):
19510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19511 
 
19512 
  def __ne__(self, other):
19513 
    return not (self == other)
19514 
 
19515 
class getAllItemstoListOnFba_result:
19516 
  """
19517 
  Attributes:
19518 
   - success
19519 
  """
19520 
 
19521 
  thrift_spec = (
19522 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19523 
  )
19524 
 
19525 
  def __init__(self, success=None,):
19526 
    self.success = success
19527 
 
19528 
  def read(self, iprot):
19529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19531 
      return
19532 
    iprot.readStructBegin()
19533 
    while True:
19534 
      (fname, ftype, fid) = iprot.readFieldBegin()
19535 
      if ftype == TType.STOP:
19536 
        break
19537 
      if fid == 0:
19538 
        if ftype == TType.LIST:
19539 
          self.success = []
19540 
          (_etype398, _size395) = iprot.readListBegin()
19541 
          for _i399 in xrange(_size395):
19542 
            _elem400 = Amazonlisted()
19543 
            _elem400.read(iprot)
19544 
            self.success.append(_elem400)
19545 
          iprot.readListEnd()
19546 
        else:
19547 
          iprot.skip(ftype)
19548 
      else:
19549 
        iprot.skip(ftype)
19550 
      iprot.readFieldEnd()
19551 
    iprot.readStructEnd()
19552 
 
19553 
  def write(self, oprot):
19554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19556 
      return
19557 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
19558 
    if self.success is not None:
19559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19561 
      for iter401 in self.success:
19562 
        iter401.write(oprot)
19563 
      oprot.writeListEnd()
19564 
      oprot.writeFieldEnd()
19565 
    oprot.writeFieldStop()
19566 
    oprot.writeStructEnd()
19567 
 
19568 
  def validate(self):
19569 
    return
19570 
 
19571 
 
19572 
  def __repr__(self):
19573 
    L = ['%s=%r' % (key, value)
19574 
      for key, value in self.__dict__.iteritems()]
19575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19576 
 
19577 
  def __eq__(self, other):
19578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19579 
 
19580 
  def __ne__(self, other):
19581 
    return not (self == other)
19582 
 
19583 
class getAllItemstoListOnNonFba_args:
19584 
 
19585 
  thrift_spec = (
19586 
  )
19587 
 
19588 
  def read(self, iprot):
19589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19591 
      return
19592 
    iprot.readStructBegin()
19593 
    while True:
19594 
      (fname, ftype, fid) = iprot.readFieldBegin()
19595 
      if ftype == TType.STOP:
19596 
        break
19597 
      else:
19598 
        iprot.skip(ftype)
19599 
      iprot.readFieldEnd()
19600 
    iprot.readStructEnd()
19601 
 
19602 
  def write(self, oprot):
19603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19605 
      return
19606 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
19607 
    oprot.writeFieldStop()
19608 
    oprot.writeStructEnd()
19609 
 
19610 
  def validate(self):
19611 
    return
19612 
 
19613 
 
19614 
  def __repr__(self):
19615 
    L = ['%s=%r' % (key, value)
19616 
      for key, value in self.__dict__.iteritems()]
19617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19618 
 
19619 
  def __eq__(self, other):
19620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19621 
 
19622 
  def __ne__(self, other):
19623 
    return not (self == other)
19624 
 
19625 
class getAllItemstoListOnNonFba_result:
19626 
  """
19627 
  Attributes:
19628 
   - success
19629 
  """
19630 
 
19631 
  thrift_spec = (
19632 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19633 
  )
19634 
 
19635 
  def __init__(self, success=None,):
19636 
    self.success = success
19637 
 
19638 
  def read(self, iprot):
19639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19641 
      return
19642 
    iprot.readStructBegin()
19643 
    while True:
19644 
      (fname, ftype, fid) = iprot.readFieldBegin()
19645 
      if ftype == TType.STOP:
19646 
        break
19647 
      if fid == 0:
19648 
        if ftype == TType.LIST:
19649 
          self.success = []
19650 
          (_etype405, _size402) = iprot.readListBegin()
19651 
          for _i406 in xrange(_size402):
19652 
            _elem407 = Amazonlisted()
19653 
            _elem407.read(iprot)
19654 
            self.success.append(_elem407)
19655 
          iprot.readListEnd()
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('getAllItemstoListOnNonFba_result')
19668 
    if self.success is not None:
19669 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19670 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19671 
      for iter408 in self.success:
19672 
        iter408.write(oprot)
19673 
      oprot.writeListEnd()
19674 
      oprot.writeFieldEnd()
19675 
    oprot.writeFieldStop()
19676 
    oprot.writeStructEnd()
19677 
 
19678 
  def validate(self):
19679 
    return
19680 
 
19681 
 
19682 
  def __repr__(self):
19683 
    L = ['%s=%r' % (key, value)
19684 
      for key, value in self.__dict__.iteritems()]
19685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19686 
 
19687 
  def __eq__(self, other):
19688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19689 
 
19690 
  def __ne__(self, other):
19691 
    return not (self == other)