Subversion Repositories SmartDukaan

Rev

Rev 7977 | Rev 8168 | 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 
 
7367 kshitij.so 720 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 721 
    """
722 
    Parameters:
723 
     - itemId
724 
     - fbaPrice
725 
     - sellingPrice
726 
     - isFba
727 
     - isNonFba
728 
     - isInventoryOverride
7367 kshitij.so 729 
     - handlingTime
730 
     - isCustomTime
7281 kshitij.so 731 
    """
732 
    pass
733 
 
734 
  def addAmazonItem(self, amazonlisted):
735 
    """
736 
    Parameters:
737 
     - amazonlisted
738 
    """
739 
    pass
740 
 
7291 vikram.rag 741 
  def getAsinItems(self, ):
742 
    pass
7281 kshitij.so 743 
 
7291 vikram.rag 744 
  def getAllFbaListedItems(self, ):
745 
    pass
746 
 
747 
  def getAllNonFbaListedItems(self, ):
748 
    pass
749 
 
7460 kshitij.so 750 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
751 
    """
752 
    Parameters:
753 
     - itemId
754 
     - holdInventory
755 
     - defaultInventory
756 
    """
757 
    pass
7291 vikram.rag 758 
 
7770 kshitij.so 759 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
760 
    """
761 
    Parameters:
762 
     - type
763 
     - sku
764 
     - timestamp
765 
    """
766 
    pass
7460 kshitij.so 767 
 
7897 amar.kumar 768 
  def getAllParentCategories(self, ):
769 
    pass
7770 kshitij.so 770 
 
7977 kshitij.so 771 
  def addPageViewEvent(self, pageViewEvents):
772 
    """
773 
    Parameters:
774 
     - pageViewEvents
775 
    """
776 
    pass
7897 amar.kumar 777 
 
7977 kshitij.so 778 
  def addCartEvent(self, cartEvents):
779 
    """
780 
    Parameters:
781 
     - cartEvents
782 
    """
783 
    pass
784 
 
8139 kshitij.so 785 
  def getAmazonListedItems(self, offset, limit):
786 
    """
787 
    Parameters:
788 
     - offset
789 
     - limit
790 
    """
791 
    pass
7977 kshitij.so 792 
 
8139 kshitij.so 793 
 
5944 mandeep.dh 794 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
795 
  def __init__(self, iprot, oprot=None):
796 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
797 
 
798 
  def addItem(self, item):
799 
    """
800 
    Availability and inventory attributes
801 
 
802 
    Parameters:
803 
     - item
804 
    """
805 
    self.send_addItem(item)
806 
    return self.recv_addItem()
807 
 
808 
  def send_addItem(self, item):
809 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
810 
    args = addItem_args()
811 
    args.item = item
812 
    args.write(self._oprot)
813 
    self._oprot.writeMessageEnd()
814 
    self._oprot.trans.flush()
815 
 
816 
  def recv_addItem(self, ):
817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
818 
    if mtype == TMessageType.EXCEPTION:
819 
      x = TApplicationException()
820 
      x.read(self._iprot)
821 
      self._iprot.readMessageEnd()
822 
      raise x
823 
    result = addItem_result()
824 
    result.read(self._iprot)
825 
    self._iprot.readMessageEnd()
826 
    if result.success is not None:
827 
      return result.success
828 
    if result.cex is not None:
829 
      raise result.cex
830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
831 
 
832 
  def updateItem(self, item):
833 
    """
834 
    Parameters:
835 
     - item
836 
    """
837 
    self.send_updateItem(item)
838 
    return self.recv_updateItem()
839 
 
840 
  def send_updateItem(self, item):
841 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
842 
    args = updateItem_args()
843 
    args.item = item
844 
    args.write(self._oprot)
845 
    self._oprot.writeMessageEnd()
846 
    self._oprot.trans.flush()
847 
 
848 
  def recv_updateItem(self, ):
849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
850 
    if mtype == TMessageType.EXCEPTION:
851 
      x = TApplicationException()
852 
      x.read(self._iprot)
853 
      self._iprot.readMessageEnd()
854 
      raise x
855 
    result = updateItem_result()
856 
    result.read(self._iprot)
857 
    self._iprot.readMessageEnd()
858 
    if result.success is not None:
859 
      return result.success
860 
    if result.cex is not None:
861 
      raise result.cex
862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
863 
 
864 
  def isActive(self, itemId):
865 
    """
866 
    Checks if the item given to the corresponding itemId is active. If it's active,
867 
    whether it's risky and if it's risky, its inventory position.
868 
 
869 
    Parameters:
870 
     - itemId
871 
    """
872 
    self.send_isActive(itemId)
873 
    return self.recv_isActive()
874 
 
875 
  def send_isActive(self, itemId):
876 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
877 
    args = isActive_args()
878 
    args.itemId = itemId
879 
    args.write(self._oprot)
880 
    self._oprot.writeMessageEnd()
881 
    self._oprot.trans.flush()
882 
 
883 
  def recv_isActive(self, ):
884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
885 
    if mtype == TMessageType.EXCEPTION:
886 
      x = TApplicationException()
887 
      x.read(self._iprot)
888 
      self._iprot.readMessageEnd()
889 
      raise x
890 
    result = isActive_result()
891 
    result.read(self._iprot)
892 
    self._iprot.readMessageEnd()
893 
    if result.success is not None:
894 
      return result.success
895 
    if result.isex is not None:
896 
      raise result.isex
897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
898 
 
7438 amit.gupta 899 
  def getItemsStatus(self, itemIds):
900 
    """
901 
    Parameters:
902 
     - itemIds
903 
    """
904 
    self.send_getItemsStatus(itemIds)
905 
    return self.recv_getItemsStatus()
906 
 
907 
  def send_getItemsStatus(self, itemIds):
908 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
909 
    args = getItemsStatus_args()
910 
    args.itemIds = itemIds
911 
    args.write(self._oprot)
912 
    self._oprot.writeMessageEnd()
913 
    self._oprot.trans.flush()
914 
 
915 
  def recv_getItemsStatus(self, ):
916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
917 
    if mtype == TMessageType.EXCEPTION:
918 
      x = TApplicationException()
919 
      x.read(self._iprot)
920 
      self._iprot.readMessageEnd()
921 
      raise x
922 
    result = getItemsStatus_result()
923 
    result.read(self._iprot)
924 
    self._iprot.readMessageEnd()
925 
    if result.success is not None:
926 
      return result.success
927 
    if result.isex is not None:
928 
      raise result.isex
929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
930 
 
5944 mandeep.dh 931 
  def getItemStatusDescription(self, itemId):
932 
    """
933 
    Parameters:
934 
     - itemId
935 
    """
936 
    self.send_getItemStatusDescription(itemId)
937 
    return self.recv_getItemStatusDescription()
938 
 
939 
  def send_getItemStatusDescription(self, itemId):
940 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
941 
    args = getItemStatusDescription_args()
942 
    args.itemId = itemId
943 
    args.write(self._oprot)
944 
    self._oprot.writeMessageEnd()
945 
    self._oprot.trans.flush()
946 
 
947 
  def recv_getItemStatusDescription(self, ):
948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
949 
    if mtype == TMessageType.EXCEPTION:
950 
      x = TApplicationException()
951 
      x.read(self._iprot)
952 
      self._iprot.readMessageEnd()
953 
      raise x
954 
    result = getItemStatusDescription_result()
955 
    result.read(self._iprot)
956 
    self._iprot.readMessageEnd()
957 
    if result.success is not None:
958 
      return result.success
959 
    if result.isex is not None:
960 
      raise result.isex
961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
962 
 
963 
  def startItemOn(self, item_id, timestamp):
964 
    """
965 
    Parameters:
966 
     - item_id
967 
     - timestamp
968 
    """
969 
    self.send_startItemOn(item_id, timestamp)
970 
    self.recv_startItemOn()
971 
 
972 
  def send_startItemOn(self, item_id, timestamp):
973 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
974 
    args = startItemOn_args()
975 
    args.item_id = item_id
976 
    args.timestamp = timestamp
977 
    args.write(self._oprot)
978 
    self._oprot.writeMessageEnd()
979 
    self._oprot.trans.flush()
980 
 
981 
  def recv_startItemOn(self, ):
982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
983 
    if mtype == TMessageType.EXCEPTION:
984 
      x = TApplicationException()
985 
      x.read(self._iprot)
986 
      self._iprot.readMessageEnd()
987 
      raise x
988 
    result = startItemOn_result()
989 
    result.read(self._iprot)
990 
    self._iprot.readMessageEnd()
991 
    if result.cex is not None:
992 
      raise result.cex
993 
    return
994 
 
995 
  def retireItemOn(self, item_id, timestamp):
996 
    """
997 
    Parameters:
998 
     - item_id
999 
     - timestamp
1000 
    """
1001 
    self.send_retireItemOn(item_id, timestamp)
1002 
    self.recv_retireItemOn()
1003 
 
1004 
  def send_retireItemOn(self, item_id, timestamp):
1005 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1006 
    args = retireItemOn_args()
1007 
    args.item_id = item_id
1008 
    args.timestamp = timestamp
1009 
    args.write(self._oprot)
1010 
    self._oprot.writeMessageEnd()
1011 
    self._oprot.trans.flush()
1012 
 
1013 
  def recv_retireItemOn(self, ):
1014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1015 
    if mtype == TMessageType.EXCEPTION:
1016 
      x = TApplicationException()
1017 
      x.read(self._iprot)
1018 
      self._iprot.readMessageEnd()
1019 
      raise x
1020 
    result = retireItemOn_result()
1021 
    result.read(self._iprot)
1022 
    self._iprot.readMessageEnd()
1023 
    if result.cex is not None:
1024 
      raise result.cex
1025 
    return
1026 
 
1027 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1028 
    """
1029 
    Parameters:
1030 
     - item_id
1031 
     - timestamp
1032 
     - newstatus
1033 
    """
1034 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1035 
    self.recv_changeItemStatus()
1036 
 
1037 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1038 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1039 
    args = changeItemStatus_args()
1040 
    args.item_id = item_id
1041 
    args.timestamp = timestamp
1042 
    args.newstatus = newstatus
1043 
    args.write(self._oprot)
1044 
    self._oprot.writeMessageEnd()
1045 
    self._oprot.trans.flush()
1046 
 
1047 
  def recv_changeItemStatus(self, ):
1048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1049 
    if mtype == TMessageType.EXCEPTION:
1050 
      x = TApplicationException()
1051 
      x.read(self._iprot)
1052 
      self._iprot.readMessageEnd()
1053 
      raise x
1054 
    result = changeItemStatus_result()
1055 
    result.read(self._iprot)
1056 
    self._iprot.readMessageEnd()
1057 
    if result.cex is not None:
1058 
      raise result.cex
1059 
    return
1060 
 
1061 
  def getItem(self, item_id):
1062 
    """
1063 
    Parameters:
1064 
     - item_id
1065 
    """
1066 
    self.send_getItem(item_id)
1067 
    return self.recv_getItem()
1068 
 
1069 
  def send_getItem(self, item_id):
1070 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1071 
    args = getItem_args()
1072 
    args.item_id = item_id
1073 
    args.write(self._oprot)
1074 
    self._oprot.writeMessageEnd()
1075 
    self._oprot.trans.flush()
1076 
 
1077 
  def recv_getItem(self, ):
1078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1079 
    if mtype == TMessageType.EXCEPTION:
1080 
      x = TApplicationException()
1081 
      x.read(self._iprot)
1082 
      self._iprot.readMessageEnd()
1083 
      raise x
1084 
    result = getItem_result()
1085 
    result.read(self._iprot)
1086 
    self._iprot.readMessageEnd()
1087 
    if result.success is not None:
1088 
      return result.success
1089 
    if result.cex is not None:
1090 
      raise result.cex
1091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1092 
 
1093 
  def getItemsByCatalogId(self, catalog_item_id):
1094 
    """
1095 
    Parameters:
1096 
     - catalog_item_id
1097 
    """
1098 
    self.send_getItemsByCatalogId(catalog_item_id)
1099 
    return self.recv_getItemsByCatalogId()
1100 
 
1101 
  def send_getItemsByCatalogId(self, catalog_item_id):
1102 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1103 
    args = getItemsByCatalogId_args()
1104 
    args.catalog_item_id = catalog_item_id
1105 
    args.write(self._oprot)
1106 
    self._oprot.writeMessageEnd()
1107 
    self._oprot.trans.flush()
1108 
 
1109 
  def recv_getItemsByCatalogId(self, ):
1110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1111 
    if mtype == TMessageType.EXCEPTION:
1112 
      x = TApplicationException()
1113 
      x.read(self._iprot)
1114 
      self._iprot.readMessageEnd()
1115 
      raise x
1116 
    result = getItemsByCatalogId_result()
1117 
    result.read(self._iprot)
1118 
    self._iprot.readMessageEnd()
1119 
    if result.success is not None:
1120 
      return result.success
1121 
    if result.cex is not None:
1122 
      raise result.cex
1123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1124 
 
1125 
  def getValidItemsByCatalogId(self, catalog_item_id):
1126 
    """
1127 
    Parameters:
1128 
     - catalog_item_id
1129 
    """
1130 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1131 
    return self.recv_getValidItemsByCatalogId()
1132 
 
1133 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1134 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1135 
    args = getValidItemsByCatalogId_args()
1136 
    args.catalog_item_id = catalog_item_id
1137 
    args.write(self._oprot)
1138 
    self._oprot.writeMessageEnd()
1139 
    self._oprot.trans.flush()
1140 
 
1141 
  def recv_getValidItemsByCatalogId(self, ):
1142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1143 
    if mtype == TMessageType.EXCEPTION:
1144 
      x = TApplicationException()
1145 
      x.read(self._iprot)
1146 
      self._iprot.readMessageEnd()
1147 
      raise x
1148 
    result = getValidItemsByCatalogId_result()
1149 
    result.read(self._iprot)
1150 
    self._iprot.readMessageEnd()
1151 
    if result.success is not None:
1152 
      return result.success
1153 
    if result.cex is not None:
1154 
      raise result.cex
1155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1156 
 
1157 
  def getAllItems(self, isActive):
1158 
    """
1159 
    Parameters:
1160 
     - isActive
1161 
    """
1162 
    self.send_getAllItems(isActive)
1163 
    return self.recv_getAllItems()
1164 
 
1165 
  def send_getAllItems(self, isActive):
1166 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1167 
    args = getAllItems_args()
1168 
    args.isActive = isActive
1169 
    args.write(self._oprot)
1170 
    self._oprot.writeMessageEnd()
1171 
    self._oprot.trans.flush()
1172 
 
1173 
  def recv_getAllItems(self, ):
1174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1175 
    if mtype == TMessageType.EXCEPTION:
1176 
      x = TApplicationException()
1177 
      x.read(self._iprot)
1178 
      self._iprot.readMessageEnd()
1179 
      raise x
1180 
    result = getAllItems_result()
1181 
    result.read(self._iprot)
1182 
    self._iprot.readMessageEnd()
1183 
    if result.success is not None:
1184 
      return result.success
1185 
    if result.cex is not None:
1186 
      raise result.cex
1187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1188 
 
1189 
  def getAllItemsByStatus(self, itemStatus):
1190 
    """
1191 
    Parameters:
1192 
     - itemStatus
1193 
    """
1194 
    self.send_getAllItemsByStatus(itemStatus)
1195 
    return self.recv_getAllItemsByStatus()
1196 
 
1197 
  def send_getAllItemsByStatus(self, itemStatus):
1198 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1199 
    args = getAllItemsByStatus_args()
1200 
    args.itemStatus = itemStatus
1201 
    args.write(self._oprot)
1202 
    self._oprot.writeMessageEnd()
1203 
    self._oprot.trans.flush()
1204 
 
1205 
  def recv_getAllItemsByStatus(self, ):
1206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1207 
    if mtype == TMessageType.EXCEPTION:
1208 
      x = TApplicationException()
1209 
      x.read(self._iprot)
1210 
      self._iprot.readMessageEnd()
1211 
      raise x
1212 
    result = getAllItemsByStatus_result()
1213 
    result.read(self._iprot)
1214 
    self._iprot.readMessageEnd()
1215 
    if result.success is not None:
1216 
      return result.success
1217 
    if result.cex is not None:
1218 
      raise result.cex
1219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1220 
 
1221 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1222 
    """
1223 
    Parameters:
1224 
     - entityId
1225 
     - category
1226 
     - brand
1227 
     - modelName
1228 
     - modelNumber
1229 
    """
1230 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1231 
    return self.recv_markItemAsContentComplete()
1232 
 
1233 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1234 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1235 
    args = markItemAsContentComplete_args()
1236 
    args.entityId = entityId
1237 
    args.category = category
1238 
    args.brand = brand
1239 
    args.modelName = modelName
1240 
    args.modelNumber = modelNumber
1241 
    args.write(self._oprot)
1242 
    self._oprot.writeMessageEnd()
1243 
    self._oprot.trans.flush()
1244 
 
1245 
  def recv_markItemAsContentComplete(self, ):
1246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1247 
    if mtype == TMessageType.EXCEPTION:
1248 
      x = TApplicationException()
1249 
      x.read(self._iprot)
1250 
      self._iprot.readMessageEnd()
1251 
      raise x
1252 
    result = markItemAsContentComplete_result()
1253 
    result.read(self._iprot)
1254 
    self._iprot.readMessageEnd()
1255 
    if result.success is not None:
1256 
      return result.success
1257 
    if result.cex is not None:
1258 
      raise result.cex
1259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1260 
 
1261 
  def getAllItemsInRange(self, offset, limit):
1262 
    """
1263 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1264 
 
1265 
    Parameters:
1266 
     - offset
1267 
     - limit
1268 
    """
1269 
    self.send_getAllItemsInRange(offset, limit)
1270 
    return self.recv_getAllItemsInRange()
1271 
 
1272 
  def send_getAllItemsInRange(self, offset, limit):
1273 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1274 
    args = getAllItemsInRange_args()
1275 
    args.offset = offset
1276 
    args.limit = limit
1277 
    args.write(self._oprot)
1278 
    self._oprot.writeMessageEnd()
1279 
    self._oprot.trans.flush()
1280 
 
1281 
  def recv_getAllItemsInRange(self, ):
1282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1283 
    if mtype == TMessageType.EXCEPTION:
1284 
      x = TApplicationException()
1285 
      x.read(self._iprot)
1286 
      self._iprot.readMessageEnd()
1287 
      raise x
1288 
    result = getAllItemsInRange_result()
1289 
    result.read(self._iprot)
1290 
    self._iprot.readMessageEnd()
1291 
    if result.success is not None:
1292 
      return result.success
1293 
    if result.cex is not None:
1294 
      raise result.cex
1295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1296 
 
1297 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1298 
    """
1299 
    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.
1300 
 
1301 
    Parameters:
1302 
     - itemStatus
1303 
     - offset
1304 
     - limit
1305 
    """
1306 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1307 
    return self.recv_getAllItemsByStatusInRange()
1308 
 
1309 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1310 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1311 
    args = getAllItemsByStatusInRange_args()
1312 
    args.itemStatus = itemStatus
1313 
    args.offset = offset
1314 
    args.limit = limit
1315 
    args.write(self._oprot)
1316 
    self._oprot.writeMessageEnd()
1317 
    self._oprot.trans.flush()
1318 
 
1319 
  def recv_getAllItemsByStatusInRange(self, ):
1320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1321 
    if mtype == TMessageType.EXCEPTION:
1322 
      x = TApplicationException()
1323 
      x.read(self._iprot)
1324 
      self._iprot.readMessageEnd()
1325 
      raise x
1326 
    result = getAllItemsByStatusInRange_result()
1327 
    result.read(self._iprot)
1328 
    self._iprot.readMessageEnd()
1329 
    if result.success is not None:
1330 
      return result.success
1331 
    if result.cex is not None:
1332 
      raise result.cex
1333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1334 
 
1335 
  def getItemCountByStatus(self, useStatus, itemStatus):
1336 
    """
1337 
    Gets a count of all items by status
1338 
 
1339 
    Parameters:
1340 
     - useStatus
1341 
     - itemStatus
1342 
    """
1343 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1344 
    return self.recv_getItemCountByStatus()
1345 
 
1346 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1347 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1348 
    args = getItemCountByStatus_args()
1349 
    args.useStatus = useStatus
1350 
    args.itemStatus = itemStatus
1351 
    args.write(self._oprot)
1352 
    self._oprot.writeMessageEnd()
1353 
    self._oprot.trans.flush()
1354 
 
1355 
  def recv_getItemCountByStatus(self, ):
1356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1357 
    if mtype == TMessageType.EXCEPTION:
1358 
      x = TApplicationException()
1359 
      x.read(self._iprot)
1360 
      self._iprot.readMessageEnd()
1361 
      raise x
1362 
    result = getItemCountByStatus_result()
1363 
    result.read(self._iprot)
1364 
    self._iprot.readMessageEnd()
1365 
    if result.success is not None:
1366 
      return result.success
1367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1368 
 
1369 
  def getBestSellers(self, ):
1370 
    self.send_getBestSellers()
1371 
    return self.recv_getBestSellers()
1372 
 
1373 
  def send_getBestSellers(self, ):
1374 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1375 
    args = getBestSellers_args()
1376 
    args.write(self._oprot)
1377 
    self._oprot.writeMessageEnd()
1378 
    self._oprot.trans.flush()
1379 
 
1380 
  def recv_getBestSellers(self, ):
1381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1382 
    if mtype == TMessageType.EXCEPTION:
1383 
      x = TApplicationException()
1384 
      x.read(self._iprot)
1385 
      self._iprot.readMessageEnd()
1386 
      raise x
1387 
    result = getBestSellers_result()
1388 
    result.read(self._iprot)
1389 
    self._iprot.readMessageEnd()
1390 
    if result.success is not None:
1391 
      return result.success
1392 
    if result.isex is not None:
1393 
      raise result.isex
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1395 
 
1396 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1397 
    """
1398 
    Parameters:
1399 
     - beginIndex
1400 
     - totalItems
1401 
     - brand
1402 
     - category
1403 
    """
1404 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1405 
    return self.recv_getBestSellersCatalogIds()
1406 
 
1407 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1408 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1409 
    args = getBestSellersCatalogIds_args()
1410 
    args.beginIndex = beginIndex
1411 
    args.totalItems = totalItems
1412 
    args.brand = brand
1413 
    args.category = category
1414 
    args.write(self._oprot)
1415 
    self._oprot.writeMessageEnd()
1416 
    self._oprot.trans.flush()
1417 
 
1418 
  def recv_getBestSellersCatalogIds(self, ):
1419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1420 
    if mtype == TMessageType.EXCEPTION:
1421 
      x = TApplicationException()
1422 
      x.read(self._iprot)
1423 
      self._iprot.readMessageEnd()
1424 
      raise x
1425 
    result = getBestSellersCatalogIds_result()
1426 
    result.read(self._iprot)
1427 
    self._iprot.readMessageEnd()
1428 
    if result.success is not None:
1429 
      return result.success
1430 
    if result.cex is not None:
1431 
      raise result.cex
1432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1433 
 
1434 
  def getBestSellersCount(self, ):
1435 
    self.send_getBestSellersCount()
1436 
    return self.recv_getBestSellersCount()
1437 
 
1438 
  def send_getBestSellersCount(self, ):
1439 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1440 
    args = getBestSellersCount_args()
1441 
    args.write(self._oprot)
1442 
    self._oprot.writeMessageEnd()
1443 
    self._oprot.trans.flush()
1444 
 
1445 
  def recv_getBestSellersCount(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 = getBestSellersCount_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, "getBestSellersCount failed: unknown result");
1460 
 
1461 
  def getBestDeals(self, ):
1462 
    self.send_getBestDeals()
1463 
    return self.recv_getBestDeals()
1464 
 
1465 
  def send_getBestDeals(self, ):
1466 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1467 
    args = getBestDeals_args()
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_getBestDeals(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 = getBestDeals_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
1482 
    if result.success is not None:
1483 
      return result.success
1484 
    if result.isex is not None:
1485 
      raise result.isex
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1487 
 
1488 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1489 
    """
1490 
    Parameters:
1491 
     - beginIndex
1492 
     - totalItems
1493 
     - brand
1494 
     - category
1495 
    """
1496 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1497 
    return self.recv_getBestDealsCatalogIds()
1498 
 
1499 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1500 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1501 
    args = getBestDealsCatalogIds_args()
1502 
    args.beginIndex = beginIndex
1503 
    args.totalItems = totalItems
1504 
    args.brand = brand
1505 
    args.category = category
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_getBestDealsCatalogIds(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = getBestDealsCatalogIds_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
1520 
    if result.success is not None:
1521 
      return result.success
1522 
    if result.cex is not None:
1523 
      raise result.cex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1525 
 
1526 
  def getBestDealsCount(self, ):
1527 
    self.send_getBestDealsCount()
1528 
    return self.recv_getBestDealsCount()
1529 
 
1530 
  def send_getBestDealsCount(self, ):
1531 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1532 
    args = getBestDealsCount_args()
1533 
    args.write(self._oprot)
1534 
    self._oprot.writeMessageEnd()
1535 
    self._oprot.trans.flush()
1536 
 
1537 
  def recv_getBestDealsCount(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 = getBestDealsCount_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, "getBestDealsCount failed: unknown result");
1552 
 
1553 
  def getComingSoon(self, ):
1554 
    self.send_getComingSoon()
1555 
    return self.recv_getComingSoon()
1556 
 
1557 
  def send_getComingSoon(self, ):
1558 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1559 
    args = getComingSoon_args()
1560 
    args.write(self._oprot)
1561 
    self._oprot.writeMessageEnd()
1562 
    self._oprot.trans.flush()
1563 
 
1564 
  def recv_getComingSoon(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 = getComingSoon_result()
1572 
    result.read(self._iprot)
1573 
    self._iprot.readMessageEnd()
1574 
    if result.success is not None:
1575 
      return result.success
1576 
    if result.isex is not None:
1577 
      raise result.isex
1578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1579 
 
1580 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1581 
    """
1582 
    Parameters:
1583 
     - beginIndex
1584 
     - totalItems
1585 
     - brand
1586 
     - category
1587 
    """
1588 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1589 
    return self.recv_getComingSoonCatalogIds()
1590 
 
1591 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1592 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1593 
    args = getComingSoonCatalogIds_args()
1594 
    args.beginIndex = beginIndex
1595 
    args.totalItems = totalItems
1596 
    args.brand = brand
1597 
    args.category = category
1598 
    args.write(self._oprot)
1599 
    self._oprot.writeMessageEnd()
1600 
    self._oprot.trans.flush()
1601 
 
1602 
  def recv_getComingSoonCatalogIds(self, ):
1603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1604 
    if mtype == TMessageType.EXCEPTION:
1605 
      x = TApplicationException()
1606 
      x.read(self._iprot)
1607 
      self._iprot.readMessageEnd()
1608 
      raise x
1609 
    result = getComingSoonCatalogIds_result()
1610 
    result.read(self._iprot)
1611 
    self._iprot.readMessageEnd()
1612 
    if result.success is not None:
1613 
      return result.success
1614 
    if result.cex is not None:
1615 
      raise result.cex
1616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1617 
 
1618 
  def getComingSoonCount(self, ):
1619 
    self.send_getComingSoonCount()
1620 
    return self.recv_getComingSoonCount()
1621 
 
1622 
  def send_getComingSoonCount(self, ):
1623 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1624 
    args = getComingSoonCount_args()
1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
1629 
  def recv_getComingSoonCount(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 = getComingSoonCount_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, "getComingSoonCount failed: unknown result");
1644 
 
1645 
  def getLatestArrivals(self, ):
1646 
    """
1647 
    Returns a list of items sorted in the descending order by start date.
1648 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1649 
    """
1650 
    self.send_getLatestArrivals()
1651 
    return self.recv_getLatestArrivals()
1652 
 
1653 
  def send_getLatestArrivals(self, ):
1654 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1655 
    args = getLatestArrivals_args()
1656 
    args.write(self._oprot)
1657 
    self._oprot.writeMessageEnd()
1658 
    self._oprot.trans.flush()
1659 
 
1660 
  def recv_getLatestArrivals(self, ):
1661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1662 
    if mtype == TMessageType.EXCEPTION:
1663 
      x = TApplicationException()
1664 
      x.read(self._iprot)
1665 
      self._iprot.readMessageEnd()
1666 
      raise x
1667 
    result = getLatestArrivals_result()
1668 
    result.read(self._iprot)
1669 
    self._iprot.readMessageEnd()
1670 
    if result.success is not None:
1671 
      return result.success
1672 
    if result.isex is not None:
1673 
      raise result.isex
1674 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1675 
 
1676 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1677 
    """
1678 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1679 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1680 
 
1681 
    Parameters:
1682 
     - beginIndex
1683 
     - totalItems
1684 
     - brand
1685 
     - categories
1686 
    """
1687 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1688 
    return self.recv_getLatestArrivalsCatalogIds()
1689 
 
1690 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1691 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1692 
    args = getLatestArrivalsCatalogIds_args()
1693 
    args.beginIndex = beginIndex
1694 
    args.totalItems = totalItems
1695 
    args.brand = brand
1696 
    args.categories = categories
1697 
    args.write(self._oprot)
1698 
    self._oprot.writeMessageEnd()
1699 
    self._oprot.trans.flush()
1700 
 
1701 
  def recv_getLatestArrivalsCatalogIds(self, ):
1702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1703 
    if mtype == TMessageType.EXCEPTION:
1704 
      x = TApplicationException()
1705 
      x.read(self._iprot)
1706 
      self._iprot.readMessageEnd()
1707 
      raise x
1708 
    result = getLatestArrivalsCatalogIds_result()
1709 
    result.read(self._iprot)
1710 
    self._iprot.readMessageEnd()
1711 
    if result.success is not None:
1712 
      return result.success
1713 
    if result.cex is not None:
1714 
      raise result.cex
1715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1716 
 
1717 
  def getLatestArrivalsCount(self, ):
1718 
    """
1719 
    Get the total number of latest arrivals we are willing to show.
1720 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1721 
    """
1722 
    self.send_getLatestArrivalsCount()
1723 
    return self.recv_getLatestArrivalsCount()
1724 
 
1725 
  def send_getLatestArrivalsCount(self, ):
1726 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1727 
    args = getLatestArrivalsCount_args()
1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_getLatestArrivalsCount(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = getLatestArrivalsCount_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
1742 
    if result.success is not None:
1743 
      return result.success
1744 
    if result.cex is not None:
1745 
      raise result.cex
1746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1747 
 
1748 
  def generateNewEntityID(self, ):
1749 
    self.send_generateNewEntityID()
1750 
    return self.recv_generateNewEntityID()
1751 
 
1752 
  def send_generateNewEntityID(self, ):
1753 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1754 
    args = generateNewEntityID_args()
1755 
    args.write(self._oprot)
1756 
    self._oprot.writeMessageEnd()
1757 
    self._oprot.trans.flush()
1758 
 
1759 
  def recv_generateNewEntityID(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 = generateNewEntityID_result()
1767 
    result.read(self._iprot)
1768 
    self._iprot.readMessageEnd()
1769 
    if result.success is not None:
1770 
      return result.success
1771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1772 
 
1773 
  def addCategory(self, category):
1774 
    """
1775 
    All category related functions
1776 
 
1777 
    Parameters:
1778 
     - category
1779 
    """
1780 
    self.send_addCategory(category)
1781 
    return self.recv_addCategory()
1782 
 
1783 
  def send_addCategory(self, category):
1784 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1785 
    args = addCategory_args()
1786 
    args.category = category
1787 
    args.write(self._oprot)
1788 
    self._oprot.writeMessageEnd()
1789 
    self._oprot.trans.flush()
1790 
 
1791 
  def recv_addCategory(self, ):
1792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1793 
    if mtype == TMessageType.EXCEPTION:
1794 
      x = TApplicationException()
1795 
      x.read(self._iprot)
1796 
      self._iprot.readMessageEnd()
1797 
      raise x
1798 
    result = addCategory_result()
1799 
    result.read(self._iprot)
1800 
    self._iprot.readMessageEnd()
1801 
    if result.success is not None:
1802 
      return result.success
1803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1804 
 
1805 
  def getCategory(self, id):
1806 
    """
1807 
    Parameters:
1808 
     - id
1809 
    """
1810 
    self.send_getCategory(id)
1811 
    return self.recv_getCategory()
1812 
 
1813 
  def send_getCategory(self, id):
1814 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1815 
    args = getCategory_args()
1816 
    args.id = id
1817 
    args.write(self._oprot)
1818 
    self._oprot.writeMessageEnd()
1819 
    self._oprot.trans.flush()
1820 
 
1821 
  def recv_getCategory(self, ):
1822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1823 
    if mtype == TMessageType.EXCEPTION:
1824 
      x = TApplicationException()
1825 
      x.read(self._iprot)
1826 
      self._iprot.readMessageEnd()
1827 
      raise x
1828 
    result = getCategory_result()
1829 
    result.read(self._iprot)
1830 
    self._iprot.readMessageEnd()
1831 
    if result.success is not None:
1832 
      return result.success
1833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1834 
 
1835 
  def getAllCategories(self, ):
1836 
    self.send_getAllCategories()
1837 
    return self.recv_getAllCategories()
1838 
 
1839 
  def send_getAllCategories(self, ):
1840 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1841 
    args = getAllCategories_args()
1842 
    args.write(self._oprot)
1843 
    self._oprot.writeMessageEnd()
1844 
    self._oprot.trans.flush()
1845 
 
1846 
  def recv_getAllCategories(self, ):
1847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1848 
    if mtype == TMessageType.EXCEPTION:
1849 
      x = TApplicationException()
1850 
      x.read(self._iprot)
1851 
      self._iprot.readMessageEnd()
1852 
      raise x
1853 
    result = getAllCategories_result()
1854 
    result.read(self._iprot)
1855 
    self._iprot.readMessageEnd()
1856 
    if result.success is not None:
1857 
      return result.success
1858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1859 
 
1860 
  def getAllSimilarItems(self, itemId):
1861 
    """
1862 
    Returns the list of similar items.
1863 
 
1864 
    Parameters:
1865 
     - itemId
1866 
    """
1867 
    self.send_getAllSimilarItems(itemId)
1868 
    return self.recv_getAllSimilarItems()
1869 
 
1870 
  def send_getAllSimilarItems(self, itemId):
1871 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1872 
    args = getAllSimilarItems_args()
1873 
    args.itemId = itemId
1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_getAllSimilarItems(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = getAllSimilarItems_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
1888 
    if result.success is not None:
1889 
      return result.success
1890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1891 
 
1892 
  def addSimilarItem(self, itemId, catalogItemId):
1893 
    """
1894 
    Adds similar item.
1895 
 
1896 
    Parameters:
1897 
     - itemId
1898 
     - catalogItemId
1899 
    """
1900 
    self.send_addSimilarItem(itemId, catalogItemId)
1901 
    return self.recv_addSimilarItem()
1902 
 
1903 
  def send_addSimilarItem(self, itemId, catalogItemId):
1904 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1905 
    args = addSimilarItem_args()
1906 
    args.itemId = itemId
1907 
    args.catalogItemId = catalogItemId
1908 
    args.write(self._oprot)
1909 
    self._oprot.writeMessageEnd()
1910 
    self._oprot.trans.flush()
1911 
 
1912 
  def recv_addSimilarItem(self, ):
1913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1914 
    if mtype == TMessageType.EXCEPTION:
1915 
      x = TApplicationException()
1916 
      x.read(self._iprot)
1917 
      self._iprot.readMessageEnd()
1918 
      raise x
1919 
    result = addSimilarItem_result()
1920 
    result.read(self._iprot)
1921 
    self._iprot.readMessageEnd()
1922 
    if result.success is not None:
1923 
      return result.success
1924 
    if result.cex is not None:
1925 
      raise result.cex
1926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1927 
 
6512 kshitij.so 1928 
  def addTag(self, displayName, itemId):
1929 
    """
1930 
    Tag Related
1931 
 
1932 
    Parameters:
1933 
     - displayName
1934 
     - itemId
1935 
    """
1936 
    self.send_addTag(displayName, itemId)
1937 
    return self.recv_addTag()
1938 
 
1939 
  def send_addTag(self, displayName, itemId):
1940 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1941 
    args = addTag_args()
1942 
    args.displayName = displayName
1943 
    args.itemId = itemId
1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
1948 
  def recv_addTag(self, ):
1949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1950 
    if mtype == TMessageType.EXCEPTION:
1951 
      x = TApplicationException()
1952 
      x.read(self._iprot)
1953 
      self._iprot.readMessageEnd()
1954 
      raise x
1955 
    result = addTag_result()
1956 
    result.read(self._iprot)
1957 
    self._iprot.readMessageEnd()
1958 
    if result.success is not None:
1959 
      return result.success
1960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1961 
 
1962 
  def deleteEntityTag(self, displayName, itemId):
1963 
    """
1964 
    Parameters:
1965 
     - displayName
1966 
     - itemId
1967 
    """
1968 
    self.send_deleteEntityTag(displayName, itemId)
1969 
    return self.recv_deleteEntityTag()
1970 
 
1971 
  def send_deleteEntityTag(self, displayName, itemId):
1972 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1973 
    args = deleteEntityTag_args()
1974 
    args.displayName = displayName
1975 
    args.itemId = itemId
1976 
    args.write(self._oprot)
1977 
    self._oprot.writeMessageEnd()
1978 
    self._oprot.trans.flush()
1979 
 
1980 
  def recv_deleteEntityTag(self, ):
1981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1982 
    if mtype == TMessageType.EXCEPTION:
1983 
      x = TApplicationException()
1984 
      x.read(self._iprot)
1985 
      self._iprot.readMessageEnd()
1986 
      raise x
1987 
    result = deleteEntityTag_result()
1988 
    result.read(self._iprot)
1989 
    self._iprot.readMessageEnd()
1990 
    if result.success is not None:
1991 
      return result.success
1992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1993 
 
1994 
  def deleteTag(self, displayName):
1995 
    """
1996 
    Parameters:
1997 
     - displayName
1998 
    """
1999 
    self.send_deleteTag(displayName)
2000 
    return self.recv_deleteTag()
2001 
 
2002 
  def send_deleteTag(self, displayName):
2003 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2004 
    args = deleteTag_args()
2005 
    args.displayName = displayName
2006 
    args.write(self._oprot)
2007 
    self._oprot.writeMessageEnd()
2008 
    self._oprot.trans.flush()
2009 
 
2010 
  def recv_deleteTag(self, ):
2011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2012 
    if mtype == TMessageType.EXCEPTION:
2013 
      x = TApplicationException()
2014 
      x.read(self._iprot)
2015 
      self._iprot.readMessageEnd()
2016 
      raise x
2017 
    result = deleteTag_result()
2018 
    result.read(self._iprot)
2019 
    self._iprot.readMessageEnd()
2020 
    if result.success is not None:
2021 
      return result.success
2022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2023 
 
2024 
  def getAllTags(self, ):
2025 
    self.send_getAllTags()
2026 
    return self.recv_getAllTags()
2027 
 
2028 
  def send_getAllTags(self, ):
2029 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2030 
    args = getAllTags_args()
2031 
    args.write(self._oprot)
2032 
    self._oprot.writeMessageEnd()
2033 
    self._oprot.trans.flush()
2034 
 
2035 
  def recv_getAllTags(self, ):
2036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2037 
    if mtype == TMessageType.EXCEPTION:
2038 
      x = TApplicationException()
2039 
      x.read(self._iprot)
2040 
      self._iprot.readMessageEnd()
2041 
      raise x
2042 
    result = getAllTags_result()
2043 
    result.read(self._iprot)
2044 
    self._iprot.readMessageEnd()
2045 
    if result.success is not None:
2046 
      return result.success
2047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2048 
 
2049 
  def getAllEntitiesByTagName(self, displayName):
2050 
    """
2051 
    Parameters:
2052 
     - displayName
2053 
    """
2054 
    self.send_getAllEntitiesByTagName(displayName)
2055 
    return self.recv_getAllEntitiesByTagName()
2056 
 
2057 
  def send_getAllEntitiesByTagName(self, displayName):
2058 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2059 
    args = getAllEntitiesByTagName_args()
2060 
    args.displayName = displayName
2061 
    args.write(self._oprot)
2062 
    self._oprot.writeMessageEnd()
2063 
    self._oprot.trans.flush()
2064 
 
2065 
  def recv_getAllEntitiesByTagName(self, ):
2066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2067 
    if mtype == TMessageType.EXCEPTION:
2068 
      x = TApplicationException()
2069 
      x.read(self._iprot)
2070 
      self._iprot.readMessageEnd()
2071 
      raise x
2072 
    result = getAllEntitiesByTagName_result()
2073 
    result.read(self._iprot)
2074 
    self._iprot.readMessageEnd()
2075 
    if result.success is not None:
2076 
      return result.success
2077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2078 
 
6845 amit.gupta 2079 
  def getAllEntityTags(self, ):
2080 
    self.send_getAllEntityTags()
2081 
    return self.recv_getAllEntityTags()
2082 
 
2083 
  def send_getAllEntityTags(self, ):
2084 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2085 
    args = getAllEntityTags_args()
2086 
    args.write(self._oprot)
2087 
    self._oprot.writeMessageEnd()
2088 
    self._oprot.trans.flush()
2089 
 
2090 
  def recv_getAllEntityTags(self, ):
2091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2092 
    if mtype == TMessageType.EXCEPTION:
2093 
      x = TApplicationException()
2094 
      x.read(self._iprot)
2095 
      self._iprot.readMessageEnd()
2096 
      raise x
2097 
    result = getAllEntityTags_result()
2098 
    result.read(self._iprot)
2099 
    self._iprot.readMessageEnd()
2100 
    if result.success is not None:
2101 
      return result.success
2102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2103 
 
6850 kshitij.so 2104 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2105 
    """
2106 
    Parameters:
2107 
     - bannerName
2108 
     - imageName
2109 
     - link
2110 
     - priority
2111 
     - isActive
2112 
     - hasMap
2113 
    """
2114 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2115 
    return self.recv_addBanner()
2116 
 
2117 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2118 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2119 
    args = addBanner_args()
2120 
    args.bannerName = bannerName
2121 
    args.imageName = imageName
2122 
    args.link = link
2123 
    args.priority = priority
2124 
    args.isActive = isActive
2125 
    args.hasMap = hasMap
2126 
    args.write(self._oprot)
2127 
    self._oprot.writeMessageEnd()
2128 
    self._oprot.trans.flush()
2129 
 
2130 
  def recv_addBanner(self, ):
2131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2132 
    if mtype == TMessageType.EXCEPTION:
2133 
      x = TApplicationException()
2134 
      x.read(self._iprot)
2135 
      self._iprot.readMessageEnd()
2136 
      raise x
2137 
    result = addBanner_result()
2138 
    result.read(self._iprot)
2139 
    self._iprot.readMessageEnd()
2140 
    if result.success is not None:
2141 
      return result.success
2142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2143 
 
2144 
  def getAllBanners(self, ):
2145 
    self.send_getAllBanners()
2146 
    return self.recv_getAllBanners()
2147 
 
2148 
  def send_getAllBanners(self, ):
2149 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2150 
    args = getAllBanners_args()
2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
2155 
  def recv_getAllBanners(self, ):
2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
2162 
    result = getAllBanners_result()
2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
2165 
    if result.success is not None:
2166 
      return result.success
2167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2168 
 
2169 
  def deleteBanner(self, bannerName):
2170 
    """
2171 
    Parameters:
2172 
     - bannerName
2173 
    """
2174 
    self.send_deleteBanner(bannerName)
2175 
    return self.recv_deleteBanner()
2176 
 
2177 
  def send_deleteBanner(self, bannerName):
2178 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2179 
    args = deleteBanner_args()
2180 
    args.bannerName = bannerName
2181 
    args.write(self._oprot)
2182 
    self._oprot.writeMessageEnd()
2183 
    self._oprot.trans.flush()
2184 
 
2185 
  def recv_deleteBanner(self, ):
2186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2187 
    if mtype == TMessageType.EXCEPTION:
2188 
      x = TApplicationException()
2189 
      x.read(self._iprot)
2190 
      self._iprot.readMessageEnd()
2191 
      raise x
2192 
    result = deleteBanner_result()
2193 
    result.read(self._iprot)
2194 
    self._iprot.readMessageEnd()
2195 
    if result.success is not None:
2196 
      return result.success
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2198 
 
2199 
  def getBannerDetails(self, bannerName):
2200 
    """
2201 
    Parameters:
2202 
     - bannerName
2203 
    """
2204 
    self.send_getBannerDetails(bannerName)
2205 
    return self.recv_getBannerDetails()
2206 
 
2207 
  def send_getBannerDetails(self, bannerName):
2208 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2209 
    args = getBannerDetails_args()
2210 
    args.bannerName = bannerName
2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
2215 
  def recv_getBannerDetails(self, ):
2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
2222 
    result = getBannerDetails_result()
2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
2225 
    if result.success is not None:
2226 
      return result.success
2227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2228 
 
2229 
  def getActiveBanners(self, ):
2230 
    self.send_getActiveBanners()
2231 
    return self.recv_getActiveBanners()
2232 
 
2233 
  def send_getActiveBanners(self, ):
2234 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2235 
    args = getActiveBanners_args()
2236 
    args.write(self._oprot)
2237 
    self._oprot.writeMessageEnd()
2238 
    self._oprot.trans.flush()
2239 
 
2240 
  def recv_getActiveBanners(self, ):
2241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2242 
    if mtype == TMessageType.EXCEPTION:
2243 
      x = TApplicationException()
2244 
      x.read(self._iprot)
2245 
      self._iprot.readMessageEnd()
2246 
      raise x
2247 
    result = getActiveBanners_result()
2248 
    result.read(self._iprot)
2249 
    self._iprot.readMessageEnd()
2250 
    if result.success is not None:
2251 
      return result.success
2252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2253 
 
6849 kshitij.so 2254 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2255 
    """
2256 
    Parameters:
2257 
     - bannerName
2258 
     - mapLink
2259 
     - coordinates
2260 
    """
2261 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2262 
    return self.recv_addBannerMap()
2263 
 
2264 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2265 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2266 
    args = addBannerMap_args()
2267 
    args.bannerName = bannerName
2268 
    args.mapLink = mapLink
2269 
    args.coordinates = coordinates
2270 
    args.write(self._oprot)
2271 
    self._oprot.writeMessageEnd()
2272 
    self._oprot.trans.flush()
2273 
 
2274 
  def recv_addBannerMap(self, ):
2275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2276 
    if mtype == TMessageType.EXCEPTION:
2277 
      x = TApplicationException()
2278 
      x.read(self._iprot)
2279 
      self._iprot.readMessageEnd()
2280 
      raise x
2281 
    result = addBannerMap_result()
2282 
    result.read(self._iprot)
2283 
    self._iprot.readMessageEnd()
2284 
    if result.success is not None:
2285 
      return result.success
2286 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2287 
 
2288 
  def deleteBannerMap(self, bannerName):
2289 
    """
2290 
    Parameters:
2291 
     - bannerName
2292 
    """
2293 
    self.send_deleteBannerMap(bannerName)
2294 
    return self.recv_deleteBannerMap()
2295 
 
2296 
  def send_deleteBannerMap(self, bannerName):
2297 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2298 
    args = deleteBannerMap_args()
2299 
    args.bannerName = bannerName
2300 
    args.write(self._oprot)
2301 
    self._oprot.writeMessageEnd()
2302 
    self._oprot.trans.flush()
2303 
 
2304 
  def recv_deleteBannerMap(self, ):
2305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2306 
    if mtype == TMessageType.EXCEPTION:
2307 
      x = TApplicationException()
2308 
      x.read(self._iprot)
2309 
      self._iprot.readMessageEnd()
2310 
      raise x
2311 
    result = deleteBannerMap_result()
2312 
    result.read(self._iprot)
2313 
    self._iprot.readMessageEnd()
2314 
    if result.success is not None:
2315 
      return result.success
2316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2317 
 
2318 
  def getBannerMapDetails(self, bannerName):
2319 
    """
2320 
    Parameters:
2321 
     - bannerName
2322 
    """
2323 
    self.send_getBannerMapDetails(bannerName)
2324 
    return self.recv_getBannerMapDetails()
2325 
 
2326 
  def send_getBannerMapDetails(self, bannerName):
2327 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2328 
    args = getBannerMapDetails_args()
2329 
    args.bannerName = bannerName
2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
2334 
  def recv_getBannerMapDetails(self, ):
2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
2341 
    result = getBannerMapDetails_result()
2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
2344 
    if result.success is not None:
2345 
      return result.success
2346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2347 
 
5944 mandeep.dh 2348 
  def deleteSimilarItem(self, itemId, catalogItemId):
2349 
    """
2350 
    Delete similar item.
2351 
 
2352 
    Parameters:
2353 
     - itemId
2354 
     - catalogItemId
2355 
    """
2356 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2357 
    return self.recv_deleteSimilarItem()
2358 
 
2359 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2360 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2361 
    args = deleteSimilarItem_args()
2362 
    args.itemId = itemId
2363 
    args.catalogItemId = catalogItemId
2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
2368 
  def recv_deleteSimilarItem(self, ):
2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
2375 
    result = deleteSimilarItem_result()
2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
2378 
    if result.success is not None:
2379 
      return result.success
2380 
    if result.cex is not None:
2381 
      raise result.cex
2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2383 
 
2384 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2385 
    """
2386 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2387 
    If yes, returns the itemId else returns 0
2388 
 
2389 
    Parameters:
2390 
     - brand
2391 
     - modelNumber
2392 
     - modelName
2393 
     - color
2394 
    """
2395 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2396 
    return self.recv_checkSimilarItem()
2397 
 
2398 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2399 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2400 
    args = checkSimilarItem_args()
2401 
    args.brand = brand
2402 
    args.modelNumber = modelNumber
2403 
    args.modelName = modelName
2404 
    args.color = color
2405 
    args.write(self._oprot)
2406 
    self._oprot.writeMessageEnd()
2407 
    self._oprot.trans.flush()
2408 
 
2409 
  def recv_checkSimilarItem(self, ):
2410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2411 
    if mtype == TMessageType.EXCEPTION:
2412 
      x = TApplicationException()
2413 
      x.read(self._iprot)
2414 
      self._iprot.readMessageEnd()
2415 
      raise x
2416 
    result = checkSimilarItem_result()
2417 
    result.read(self._iprot)
2418 
    self._iprot.readMessageEnd()
2419 
    if result.success is not None:
2420 
      return result.success
2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2422 
 
2423 
  def validateRiskyStatus(self, itemId):
2424 
    """
2425 
    Check wether item is risky and change status if inventory is not available for risky items
2426 
 
2427 
    Parameters:
2428 
     - itemId
2429 
    """
2430 
    self.send_validateRiskyStatus(itemId)
2431 
    self.recv_validateRiskyStatus()
2432 
 
2433 
  def send_validateRiskyStatus(self, itemId):
2434 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2435 
    args = validateRiskyStatus_args()
2436 
    args.itemId = itemId
2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
2441 
  def recv_validateRiskyStatus(self, ):
2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
2448 
    result = validateRiskyStatus_result()
2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
2451 
    return
2452 
 
2453 
  def changeItemRiskyFlag(self, itemId, risky):
2454 
    """
2455 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2456 
 
2457 
    Parameters:
2458 
     - itemId
2459 
     - risky
2460 
    """
2461 
    self.send_changeItemRiskyFlag(itemId, risky)
2462 
    self.recv_changeItemRiskyFlag()
2463 
 
2464 
  def send_changeItemRiskyFlag(self, itemId, risky):
2465 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2466 
    args = changeItemRiskyFlag_args()
2467 
    args.itemId = itemId
2468 
    args.risky = risky
2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
2473 
  def recv_changeItemRiskyFlag(self, ):
2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
2480 
    result = changeItemRiskyFlag_result()
2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
2483 
    return
2484 
 
2485 
  def getItemsByRiskyFlag(self, ):
2486 
    """
2487 
    Returns list of items marked as risky.
2488 
    """
2489 
    self.send_getItemsByRiskyFlag()
2490 
    return self.recv_getItemsByRiskyFlag()
2491 
 
2492 
  def send_getItemsByRiskyFlag(self, ):
2493 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2494 
    args = getItemsByRiskyFlag_args()
2495 
    args.write(self._oprot)
2496 
    self._oprot.writeMessageEnd()
2497 
    self._oprot.trans.flush()
2498 
 
2499 
  def recv_getItemsByRiskyFlag(self, ):
2500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2501 
    if mtype == TMessageType.EXCEPTION:
2502 
      x = TApplicationException()
2503 
      x.read(self._iprot)
2504 
      self._iprot.readMessageEnd()
2505 
      raise x
2506 
    result = getItemsByRiskyFlag_result()
2507 
    result.read(self._iprot)
2508 
    self._iprot.readMessageEnd()
2509 
    if result.success is not None:
2510 
      return result.success
2511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2512 
 
2513 
  def getItemsForMasterSheet(self, category, brand):
2514 
    """
2515 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2516 
 
2517 
    Parameters:
2518 
     - category
2519 
     - brand
2520 
    """
2521 
    self.send_getItemsForMasterSheet(category, brand)
2522 
    return self.recv_getItemsForMasterSheet()
2523 
 
2524 
  def send_getItemsForMasterSheet(self, category, brand):
2525 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2526 
    args = getItemsForMasterSheet_args()
2527 
    args.category = category
2528 
    args.brand = brand
2529 
    args.write(self._oprot)
2530 
    self._oprot.writeMessageEnd()
2531 
    self._oprot.trans.flush()
2532 
 
2533 
  def recv_getItemsForMasterSheet(self, ):
2534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2535 
    if mtype == TMessageType.EXCEPTION:
2536 
      x = TApplicationException()
2537 
      x.read(self._iprot)
2538 
      self._iprot.readMessageEnd()
2539 
      raise x
2540 
    result = getItemsForMasterSheet_result()
2541 
    result.read(self._iprot)
2542 
    self._iprot.readMessageEnd()
2543 
    if result.success is not None:
2544 
      return result.success
2545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2546 
 
2547 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2548 
    """
2549 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2550 
 
2551 
    Parameters:
2552 
     - beginIndex
2553 
     - totalItems
2554 
     - itemId
2555 
    """
2556 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2557 
    return self.recv_getSimilarItemsCatalogIds()
2558 
 
2559 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2560 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2561 
    args = getSimilarItemsCatalogIds_args()
2562 
    args.beginIndex = beginIndex
2563 
    args.totalItems = totalItems
2564 
    args.itemId = itemId
2565 
    args.write(self._oprot)
2566 
    self._oprot.writeMessageEnd()
2567 
    self._oprot.trans.flush()
2568 
 
2569 
  def recv_getSimilarItemsCatalogIds(self, ):
2570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2571 
    if mtype == TMessageType.EXCEPTION:
2572 
      x = TApplicationException()
2573 
      x.read(self._iprot)
2574 
      self._iprot.readMessageEnd()
2575 
      raise x
2576 
    result = getSimilarItemsCatalogIds_result()
2577 
    result.read(self._iprot)
2578 
    self._iprot.readMessageEnd()
2579 
    if result.success is not None:
2580 
      return result.success
2581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2582 
 
2583 
  def addProductNotification(self, itemId, email):
2584 
    """
2585 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2586 
 
2587 
    Parameters:
2588 
     - itemId
2589 
     - email
2590 
    """
2591 
    self.send_addProductNotification(itemId, email)
2592 
    return self.recv_addProductNotification()
2593 
 
2594 
  def send_addProductNotification(self, itemId, email):
2595 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2596 
    args = addProductNotification_args()
2597 
    args.itemId = itemId
2598 
    args.email = email
2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_addProductNotification(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = addProductNotification_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
2613 
    if result.success is not None:
2614 
      return result.success
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2616 
 
2617 
  def sendProductNotifications(self, ):
2618 
    """
2619 
    Send the product notifications to the users for items which has stock.
2620 
    """
2621 
    self.send_sendProductNotifications()
2622 
    return self.recv_sendProductNotifications()
2623 
 
2624 
  def send_sendProductNotifications(self, ):
2625 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2626 
    args = sendProductNotifications_args()
2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2631 
  def recv_sendProductNotifications(self, ):
2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2638 
    result = sendProductNotifications_result()
2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
2641 
    if result.success is not None:
2642 
      return result.success
2643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2644 
 
2645 
  def getAllBrandsByCategory(self, categoryId):
2646 
    """
2647 
    Returns list of brand names for a given category Id
2648 
 
2649 
    Parameters:
2650 
     - categoryId
2651 
    """
2652 
    self.send_getAllBrandsByCategory(categoryId)
2653 
    return self.recv_getAllBrandsByCategory()
2654 
 
2655 
  def send_getAllBrandsByCategory(self, categoryId):
2656 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2657 
    args = getAllBrandsByCategory_args()
2658 
    args.categoryId = categoryId
2659 
    args.write(self._oprot)
2660 
    self._oprot.writeMessageEnd()
2661 
    self._oprot.trans.flush()
2662 
 
2663 
  def recv_getAllBrandsByCategory(self, ):
2664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2665 
    if mtype == TMessageType.EXCEPTION:
2666 
      x = TApplicationException()
2667 
      x.read(self._iprot)
2668 
      self._iprot.readMessageEnd()
2669 
      raise x
2670 
    result = getAllBrandsByCategory_result()
2671 
    result.read(self._iprot)
2672 
    self._iprot.readMessageEnd()
2673 
    if result.success is not None:
2674 
      return result.success
2675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2676 
 
2677 
  def getAllBrands(self, ):
2678 
    """
2679 
    Returns list of brand names
2680 
    """
2681 
    self.send_getAllBrands()
2682 
    return self.recv_getAllBrands()
2683 
 
2684 
  def send_getAllBrands(self, ):
2685 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2686 
    args = getAllBrands_args()
2687 
    args.write(self._oprot)
2688 
    self._oprot.writeMessageEnd()
2689 
    self._oprot.trans.flush()
2690 
 
2691 
  def recv_getAllBrands(self, ):
2692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2693 
    if mtype == TMessageType.EXCEPTION:
2694 
      x = TApplicationException()
2695 
      x.read(self._iprot)
2696 
      self._iprot.readMessageEnd()
2697 
      raise x
2698 
    result = getAllBrands_result()
2699 
    result.read(self._iprot)
2700 
    self._iprot.readMessageEnd()
2701 
    if result.success is not None:
2702 
      return result.success
2703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2704 
 
2705 
  def getAllSources(self, ):
2706 
    """
2707 
    Return list of all sources
2708 
    """
2709 
    self.send_getAllSources()
2710 
    return self.recv_getAllSources()
2711 
 
2712 
  def send_getAllSources(self, ):
2713 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2714 
    args = getAllSources_args()
2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
2719 
  def recv_getAllSources(self, ):
2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
2726 
    result = getAllSources_result()
2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
2729 
    if result.success is not None:
2730 
      return result.success
2731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2732 
 
2733 
  def getItemPricingBySource(self, itemId, sourceId):
2734 
    """
2735 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2736 
 
2737 
    Parameters:
2738 
     - itemId
2739 
     - sourceId
2740 
    """
2741 
    self.send_getItemPricingBySource(itemId, sourceId)
2742 
    return self.recv_getItemPricingBySource()
2743 
 
2744 
  def send_getItemPricingBySource(self, itemId, sourceId):
2745 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2746 
    args = getItemPricingBySource_args()
2747 
    args.itemId = itemId
2748 
    args.sourceId = sourceId
2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_getItemPricingBySource(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = getItemPricingBySource_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    if result.success is not None:
2764 
      return result.success
2765 
    if result.cex is not None:
2766 
      raise result.cex
2767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2768 
 
2769 
  def addSourceItemPricing(self, sourceItemPricing):
2770 
    """
2771 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2772 
    If item is not found or source is not found, it will throw exception.
2773 
 
2774 
    Parameters:
2775 
     - sourceItemPricing
2776 
    """
2777 
    self.send_addSourceItemPricing(sourceItemPricing)
2778 
    self.recv_addSourceItemPricing()
2779 
 
2780 
  def send_addSourceItemPricing(self, sourceItemPricing):
2781 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2782 
    args = addSourceItemPricing_args()
2783 
    args.sourceItemPricing = sourceItemPricing
2784 
    args.write(self._oprot)
2785 
    self._oprot.writeMessageEnd()
2786 
    self._oprot.trans.flush()
2787 
 
2788 
  def recv_addSourceItemPricing(self, ):
2789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2790 
    if mtype == TMessageType.EXCEPTION:
2791 
      x = TApplicationException()
2792 
      x.read(self._iprot)
2793 
      self._iprot.readMessageEnd()
2794 
      raise x
2795 
    result = addSourceItemPricing_result()
2796 
    result.read(self._iprot)
2797 
    self._iprot.readMessageEnd()
2798 
    if result.cex is not None:
2799 
      raise result.cex
2800 
    return
2801 
 
2802 
  def getAllSourcePricing(self, itemId):
2803 
    """
2804 
    Returns the list of source pricing information of an item.
2805 
    Raises an exception if item not found corresponding to itemId
2806 
 
2807 
    Parameters:
2808 
     - itemId
2809 
    """
2810 
    self.send_getAllSourcePricing(itemId)
2811 
    return self.recv_getAllSourcePricing()
2812 
 
2813 
  def send_getAllSourcePricing(self, itemId):
2814 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2815 
    args = getAllSourcePricing_args()
2816 
    args.itemId = itemId
2817 
    args.write(self._oprot)
2818 
    self._oprot.writeMessageEnd()
2819 
    self._oprot.trans.flush()
2820 
 
2821 
  def recv_getAllSourcePricing(self, ):
2822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2823 
    if mtype == TMessageType.EXCEPTION:
2824 
      x = TApplicationException()
2825 
      x.read(self._iprot)
2826 
      self._iprot.readMessageEnd()
2827 
      raise x
2828 
    result = getAllSourcePricing_result()
2829 
    result.read(self._iprot)
2830 
    self._iprot.readMessageEnd()
2831 
    if result.success is not None:
2832 
      return result.success
2833 
    if result.cex is not None:
2834 
      raise result.cex
2835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2836 
 
2837 
  def getItemForSource(self, item_id, sourceId):
2838 
    """
2839 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2840 
 
2841 
    Parameters:
2842 
     - item_id
2843 
     - sourceId
2844 
    """
2845 
    self.send_getItemForSource(item_id, sourceId)
2846 
    return self.recv_getItemForSource()
2847 
 
2848 
  def send_getItemForSource(self, item_id, sourceId):
2849 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2850 
    args = getItemForSource_args()
2851 
    args.item_id = item_id
2852 
    args.sourceId = sourceId
2853 
    args.write(self._oprot)
2854 
    self._oprot.writeMessageEnd()
2855 
    self._oprot.trans.flush()
2856 
 
2857 
  def recv_getItemForSource(self, ):
2858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2859 
    if mtype == TMessageType.EXCEPTION:
2860 
      x = TApplicationException()
2861 
      x.read(self._iprot)
2862 
      self._iprot.readMessageEnd()
2863 
      raise x
2864 
    result = getItemForSource_result()
2865 
    result.read(self._iprot)
2866 
    self._iprot.readMessageEnd()
2867 
    if result.success is not None:
2868 
      return result.success
2869 
    if result.cex is not None:
2870 
      raise result.cex
2871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2872 
 
2873 
  def searchItemsInRange(self, searchTerms, offset, limit):
2874 
    """
2875 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2876 
 
2877 
    Parameters:
2878 
     - searchTerms
2879 
     - offset
2880 
     - limit
2881 
    """
2882 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2883 
    return self.recv_searchItemsInRange()
2884 
 
2885 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2886 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2887 
    args = searchItemsInRange_args()
2888 
    args.searchTerms = searchTerms
2889 
    args.offset = offset
2890 
    args.limit = limit
2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
2895 
  def recv_searchItemsInRange(self, ):
2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
2902 
    result = searchItemsInRange_result()
2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
2905 
    if result.success is not None:
2906 
      return result.success
2907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2908 
 
2909 
  def getSearchResultCount(self, searchTerms):
2910 
    """
2911 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2912 
 
2913 
    Parameters:
2914 
     - searchTerms
2915 
    """
2916 
    self.send_getSearchResultCount(searchTerms)
2917 
    return self.recv_getSearchResultCount()
2918 
 
2919 
  def send_getSearchResultCount(self, searchTerms):
2920 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2921 
    args = getSearchResultCount_args()
2922 
    args.searchTerms = searchTerms
2923 
    args.write(self._oprot)
2924 
    self._oprot.writeMessageEnd()
2925 
    self._oprot.trans.flush()
2926 
 
2927 
  def recv_getSearchResultCount(self, ):
2928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2929 
    if mtype == TMessageType.EXCEPTION:
2930 
      x = TApplicationException()
2931 
      x.read(self._iprot)
2932 
      self._iprot.readMessageEnd()
2933 
      raise x
2934 
    result = getSearchResultCount_result()
2935 
    result.read(self._iprot)
2936 
    self._iprot.readMessageEnd()
2937 
    if result.success is not None:
2938 
      return result.success
2939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2940 
 
2941 
  def getProductNotifications(self, startDateTime):
2942 
    """
2943 
    Returns a list of product notifications added after a supplied datetime
2944 
 
2945 
    Parameters:
2946 
     - startDateTime
2947 
    """
2948 
    self.send_getProductNotifications(startDateTime)
2949 
    return self.recv_getProductNotifications()
2950 
 
2951 
  def send_getProductNotifications(self, startDateTime):
2952 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2953 
    args = getProductNotifications_args()
2954 
    args.startDateTime = startDateTime
2955 
    args.write(self._oprot)
2956 
    self._oprot.writeMessageEnd()
2957 
    self._oprot.trans.flush()
2958 
 
2959 
  def recv_getProductNotifications(self, ):
2960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2961 
    if mtype == TMessageType.EXCEPTION:
2962 
      x = TApplicationException()
2963 
      x.read(self._iprot)
2964 
      self._iprot.readMessageEnd()
2965 
      raise x
2966 
    result = getProductNotifications_result()
2967 
    result.read(self._iprot)
2968 
    self._iprot.readMessageEnd()
2969 
    if result.success is not None:
2970 
      return result.success
2971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2972 
 
7897 amar.kumar 2973 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2974 
    """
2975 
    Returns a list of count of requests for product notification against each item
2976 
 
2977 
    Parameters:
2978 
     - startDateTime
7897 amar.kumar 2979 
     - categoryId
5944 mandeep.dh 2980 
    """
7897 amar.kumar 2981 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 2982 
    return self.recv_getProductNotificationRequestCount()
2983 
 
7897 amar.kumar 2984 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 2985 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2986 
    args = getProductNotificationRequestCount_args()
2987 
    args.startDateTime = startDateTime
7897 amar.kumar 2988 
    args.categoryId = categoryId
5944 mandeep.dh 2989 
    args.write(self._oprot)
2990 
    self._oprot.writeMessageEnd()
2991 
    self._oprot.trans.flush()
2992 
 
2993 
  def recv_getProductNotificationRequestCount(self, ):
2994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2995 
    if mtype == TMessageType.EXCEPTION:
2996 
      x = TApplicationException()
2997 
      x.read(self._iprot)
2998 
      self._iprot.readMessageEnd()
2999 
      raise x
3000 
    result = getProductNotificationRequestCount_result()
3001 
    result.read(self._iprot)
3002 
    self._iprot.readMessageEnd()
3003 
    if result.success is not None:
3004 
      return result.success
3005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3006 
 
3007 
  def addAuthorizationLog(self, itemId, username, reason):
3008 
    """
3009 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3010 
 
3011 
    Parameters:
3012 
     - itemId
3013 
     - username
3014 
     - reason
3015 
    """
3016 
    self.send_addAuthorizationLog(itemId, username, reason)
3017 
    return self.recv_addAuthorizationLog()
3018 
 
3019 
  def send_addAuthorizationLog(self, itemId, username, reason):
3020 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3021 
    args = addAuthorizationLog_args()
3022 
    args.itemId = itemId
3023 
    args.username = username
3024 
    args.reason = reason
3025 
    args.write(self._oprot)
3026 
    self._oprot.writeMessageEnd()
3027 
    self._oprot.trans.flush()
3028 
 
3029 
  def recv_addAuthorizationLog(self, ):
3030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3031 
    if mtype == TMessageType.EXCEPTION:
3032 
      x = TApplicationException()
3033 
      x.read(self._iprot)
3034 
      self._iprot.readMessageEnd()
3035 
      raise x
3036 
    result = addAuthorizationLog_result()
3037 
    result.read(self._iprot)
3038 
    self._iprot.readMessageEnd()
3039 
    if result.success is not None:
3040 
      return result.success
3041 
    if result.cex is not None:
3042 
      raise result.cex
3043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3044 
 
3045 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3046 
    """
3047 
    Parameters:
3048 
     - catalog_item_id
3049 
     - voucherType
3050 
     - voucherAmount
3051 
    """
3052 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3053 
    return self.recv_addupdateVoucherForItem()
3054 
 
3055 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3056 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3057 
    args = addupdateVoucherForItem_args()
3058 
    args.catalog_item_id = catalog_item_id
3059 
    args.voucherType = voucherType
3060 
    args.voucherAmount = voucherAmount
3061 
    args.write(self._oprot)
3062 
    self._oprot.writeMessageEnd()
3063 
    self._oprot.trans.flush()
3064 
 
3065 
  def recv_addupdateVoucherForItem(self, ):
3066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3067 
    if mtype == TMessageType.EXCEPTION:
3068 
      x = TApplicationException()
3069 
      x.read(self._iprot)
3070 
      self._iprot.readMessageEnd()
3071 
      raise x
3072 
    result = addupdateVoucherForItem_result()
3073 
    result.read(self._iprot)
3074 
    self._iprot.readMessageEnd()
3075 
    if result.success is not None:
3076 
      return result.success
3077 
    if result.cex is not None:
3078 
      raise result.cex
3079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3080 
 
3081 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3082 
    """
3083 
    Parameters:
3084 
     - catalog_item_id
3085 
     - voucherType
3086 
    """
3087 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3088 
    return self.recv_deleteVoucherForItem()
3089 
 
3090 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3091 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3092 
    args = deleteVoucherForItem_args()
3093 
    args.catalog_item_id = catalog_item_id
3094 
    args.voucherType = voucherType
3095 
    args.write(self._oprot)
3096 
    self._oprot.writeMessageEnd()
3097 
    self._oprot.trans.flush()
3098 
 
3099 
  def recv_deleteVoucherForItem(self, ):
3100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3101 
    if mtype == TMessageType.EXCEPTION:
3102 
      x = TApplicationException()
3103 
      x.read(self._iprot)
3104 
      self._iprot.readMessageEnd()
3105 
      raise x
3106 
    result = deleteVoucherForItem_result()
3107 
    result.read(self._iprot)
3108 
    self._iprot.readMessageEnd()
3109 
    if result.success is not None:
3110 
      return result.success
3111 
    if result.cex is not None:
3112 
      raise result.cex
3113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3114 
 
3115 
  def getVoucherAmount(self, itemId, voucherType):
3116 
    """
3117 
    Parameters:
3118 
     - itemId
3119 
     - voucherType
3120 
    """
3121 
    self.send_getVoucherAmount(itemId, voucherType)
3122 
    return self.recv_getVoucherAmount()
3123 
 
3124 
  def send_getVoucherAmount(self, itemId, voucherType):
3125 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3126 
    args = getVoucherAmount_args()
3127 
    args.itemId = itemId
3128 
    args.voucherType = voucherType
3129 
    args.write(self._oprot)
3130 
    self._oprot.writeMessageEnd()
3131 
    self._oprot.trans.flush()
3132 
 
3133 
  def recv_getVoucherAmount(self, ):
3134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3135 
    if mtype == TMessageType.EXCEPTION:
3136 
      x = TApplicationException()
3137 
      x.read(self._iprot)
3138 
      self._iprot.readMessageEnd()
3139 
      raise x
3140 
    result = getVoucherAmount_result()
3141 
    result.read(self._iprot)
3142 
    self._iprot.readMessageEnd()
3143 
    if result.success is not None:
3144 
      return result.success
3145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3146 
 
3147 
  def getAllItemVouchers(self, itemId):
3148 
    """
3149 
    Parameters:
3150 
     - itemId
3151 
    """
3152 
    self.send_getAllItemVouchers(itemId)
3153 
    return self.recv_getAllItemVouchers()
3154 
 
3155 
  def send_getAllItemVouchers(self, itemId):
3156 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3157 
    args = getAllItemVouchers_args()
3158 
    args.itemId = itemId
3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3163 
  def recv_getAllItemVouchers(self, ):
3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3170 
    result = getAllItemVouchers_result()
3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3173 
    if result.success is not None:
3174 
      return result.success
3175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3176 
 
3177 
  def isValidCatalogItemId(self, catalog_item_id):
3178 
    """
3179 
    Parameters:
3180 
     - catalog_item_id
3181 
    """
3182 
    self.send_isValidCatalogItemId(catalog_item_id)
3183 
    return self.recv_isValidCatalogItemId()
3184 
 
3185 
  def send_isValidCatalogItemId(self, catalog_item_id):
3186 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3187 
    args = isValidCatalogItemId_args()
3188 
    args.catalog_item_id = catalog_item_id
3189 
    args.write(self._oprot)
3190 
    self._oprot.writeMessageEnd()
3191 
    self._oprot.trans.flush()
3192 
 
3193 
  def recv_isValidCatalogItemId(self, ):
3194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3195 
    if mtype == TMessageType.EXCEPTION:
3196 
      x = TApplicationException()
3197 
      x.read(self._iprot)
3198 
      self._iprot.readMessageEnd()
3199 
      raise x
3200 
    result = isValidCatalogItemId_result()
3201 
    result.read(self._iprot)
3202 
    self._iprot.readMessageEnd()
3203 
    if result.success is not None:
3204 
      return result.success
3205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3206 
 
7330 amit.gupta 3207 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3208 
    """
3209 
    Parameters:
3210 
     - itemId
7330 amit.gupta 3211 
     - stateId
6039 amit.gupta 3212 
     - price
3213 
    """
7330 amit.gupta 3214 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3215 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3216 
 
7330 amit.gupta 3217 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3218 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3219 
    args = getVatPercentageForItem_args()
3220 
    args.itemId = itemId
7330 amit.gupta 3221 
    args.stateId = stateId
6039 amit.gupta 3222 
    args.price = price
3223 
    args.write(self._oprot)
3224 
    self._oprot.writeMessageEnd()
3225 
    self._oprot.trans.flush()
3226 
 
3227 
  def recv_getVatPercentageForItem(self, ):
3228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3229 
    if mtype == TMessageType.EXCEPTION:
3230 
      x = TApplicationException()
3231 
      x.read(self._iprot)
3232 
      self._iprot.readMessageEnd()
3233 
      raise x
3234 
    result = getVatPercentageForItem_result()
3235 
    result.read(self._iprot)
3236 
    self._iprot.readMessageEnd()
3237 
    if result.success is not None:
3238 
      return result.success
7340 amit.gupta 3239 
    if result.cex is not None:
3240 
      raise result.cex
6039 amit.gupta 3241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3242 
 
3243 
  def getVatAmountForItem(self, itemId, price):
3244 
    """
3245 
    Parameters:
3246 
     - itemId
3247 
     - price
3248 
    """
3249 
    self.send_getVatAmountForItem(itemId, price)
3250 
    return self.recv_getVatAmountForItem()
3251 
 
3252 
  def send_getVatAmountForItem(self, itemId, price):
3253 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3254 
    args = getVatAmountForItem_args()
3255 
    args.itemId = itemId
3256 
    args.price = price
3257 
    args.write(self._oprot)
3258 
    self._oprot.writeMessageEnd()
3259 
    self._oprot.trans.flush()
3260 
 
3261 
  def recv_getVatAmountForItem(self, ):
3262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3263 
    if mtype == TMessageType.EXCEPTION:
3264 
      x = TApplicationException()
3265 
      x.read(self._iprot)
3266 
      self._iprot.readMessageEnd()
3267 
      raise x
3268 
    result = getVatAmountForItem_result()
3269 
    result.read(self._iprot)
3270 
    self._iprot.readMessageEnd()
3271 
    if result.success is not None:
3272 
      return result.success
3273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3274 
 
6531 vikram.rag 3275 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3276 
    """
3277 
    Parameters:
3278 
     - offset
3279 
     - limit
3280 
    """
3281 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3282 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3283 
 
6531 vikram.rag 3284 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3285 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3286 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3287 
    args.offset = offset
3288 
    args.limit = limit
3289 
    args.write(self._oprot)
3290 
    self._oprot.writeMessageEnd()
3291 
    self._oprot.trans.flush()
3292 
 
3293 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3295 
    if mtype == TMessageType.EXCEPTION:
3296 
      x = TApplicationException()
3297 
      x.read(self._iprot)
3298 
      self._iprot.readMessageEnd()
3299 
      raise x
3300 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3301 
    result.read(self._iprot)
3302 
    self._iprot.readMessageEnd()
3303 
    if result.success is not None:
3304 
      return result.success
3305 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3306 
 
6821 amar.kumar 3307 
  def getAllAliveItems(self, ):
3308 
    self.send_getAllAliveItems()
3309 
    return self.recv_getAllAliveItems()
3310 
 
3311 
  def send_getAllAliveItems(self, ):
3312 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3313 
    args = getAllAliveItems_args()
3314 
    args.write(self._oprot)
3315 
    self._oprot.writeMessageEnd()
3316 
    self._oprot.trans.flush()
3317 
 
3318 
  def recv_getAllAliveItems(self, ):
3319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3320 
    if mtype == TMessageType.EXCEPTION:
3321 
      x = TApplicationException()
3322 
      x.read(self._iprot)
3323 
      self._iprot.readMessageEnd()
3324 
      raise x
3325 
    result = getAllAliveItems_result()
3326 
    result.read(self._iprot)
3327 
    self._iprot.readMessageEnd()
3328 
    if result.success is not None:
3329 
      return result.success
3330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3331 
 
6921 anupam.sin 3332 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3333 
    """
3334 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3335 
 
6805 anupam.sin 3336 
    Parameters:
3337 
     - itemId
6921 anupam.sin 3338 
     - price
6805 anupam.sin 3339 
     - insurerId
3340 
     - quantity
3341 
    """
6921 anupam.sin 3342 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3343 
    return self.recv_getInsuranceAmount()
3344 
 
6921 anupam.sin 3345 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3346 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3347 
    args = getInsuranceAmount_args()
3348 
    args.itemId = itemId
6921 anupam.sin 3349 
    args.price = price
6805 anupam.sin 3350 
    args.insurerId = insurerId
3351 
    args.quantity = quantity
3352 
    args.write(self._oprot)
3353 
    self._oprot.writeMessageEnd()
3354 
    self._oprot.trans.flush()
3355 
 
3356 
  def recv_getInsuranceAmount(self, ):
3357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3358 
    if mtype == TMessageType.EXCEPTION:
3359 
      x = TApplicationException()
3360 
      x.read(self._iprot)
3361 
      self._iprot.readMessageEnd()
3362 
      raise x
3363 
    result = getInsuranceAmount_result()
3364 
    result.read(self._iprot)
3365 
    self._iprot.readMessageEnd()
3366 
    if result.success is not None:
3367 
      return result.success
3368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3369 
 
3370 
  def getInsurer(self, insurerId):
3371 
    """
3372 
    Parameters:
3373 
     - insurerId
3374 
    """
3375 
    self.send_getInsurer(insurerId)
3376 
    return self.recv_getInsurer()
3377 
 
3378 
  def send_getInsurer(self, insurerId):
3379 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3380 
    args = getInsurer_args()
3381 
    args.insurerId = insurerId
3382 
    args.write(self._oprot)
3383 
    self._oprot.writeMessageEnd()
3384 
    self._oprot.trans.flush()
3385 
 
3386 
  def recv_getInsurer(self, ):
3387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3388 
    if mtype == TMessageType.EXCEPTION:
3389 
      x = TApplicationException()
3390 
      x.read(self._iprot)
3391 
      self._iprot.readMessageEnd()
3392 
      raise x
3393 
    result = getInsurer_result()
3394 
    result.read(self._iprot)
3395 
    self._iprot.readMessageEnd()
3396 
    if result.success is not None:
3397 
      return result.success
3398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3399 
 
6838 vikram.rag 3400 
  def getAllInsurers(self, ):
3401 
    self.send_getAllInsurers()
3402 
    return self.recv_getAllInsurers()
6805 anupam.sin 3403 
 
6838 vikram.rag 3404 
  def send_getAllInsurers(self, ):
3405 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3406 
    args = getAllInsurers_args()
3407 
    args.write(self._oprot)
3408 
    self._oprot.writeMessageEnd()
3409 
    self._oprot.trans.flush()
3410 
 
3411 
  def recv_getAllInsurers(self, ):
3412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3413 
    if mtype == TMessageType.EXCEPTION:
3414 
      x = TApplicationException()
3415 
      x.read(self._iprot)
3416 
      self._iprot.readMessageEnd()
3417 
      raise x
3418 
    result = getAllInsurers_result()
3419 
    result.read(self._iprot)
3420 
    self._iprot.readMessageEnd()
3421 
    if result.success is not None:
3422 
      return result.success
3423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3424 
 
6962 rajveer 3425 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3426 
    """
3427 
    Parameters:
3428 
     - insurerId
3429 
     - amount
3430 
    """
3431 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3432 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3433 
 
6962 rajveer 3434 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3435 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3436 
    args = updateInsuranceDeclaredAmount_args()
3437 
    args.insurerId = insurerId
3438 
    args.amount = amount
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_updateInsuranceDeclaredAmount(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = updateInsuranceDeclaredAmount_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    return
3454 
 
7190 amar.kumar 3455 
  def getFreebieForItem(self, itemId):
3456 
    """
3457 
    Parameters:
3458 
     - itemId
3459 
    """
3460 
    self.send_getFreebieForItem(itemId)
3461 
    return self.recv_getFreebieForItem()
6962 rajveer 3462 
 
7190 amar.kumar 3463 
  def send_getFreebieForItem(self, itemId):
3464 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3465 
    args = getFreebieForItem_args()
3466 
    args.itemId = itemId
3467 
    args.write(self._oprot)
3468 
    self._oprot.writeMessageEnd()
3469 
    self._oprot.trans.flush()
3470 
 
3471 
  def recv_getFreebieForItem(self, ):
3472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3473 
    if mtype == TMessageType.EXCEPTION:
3474 
      x = TApplicationException()
3475 
      x.read(self._iprot)
3476 
      self._iprot.readMessageEnd()
3477 
      raise x
3478 
    result = getFreebieForItem_result()
3479 
    result.read(self._iprot)
3480 
    self._iprot.readMessageEnd()
3481 
    if result.success is not None:
3482 
      return result.success
3483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3484 
 
3485 
  def addOrUpdateFreebieForItem(self, freebieItem):
3486 
    """
3487 
    Parameters:
3488 
     - freebieItem
3489 
    """
3490 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3491 
    self.recv_addOrUpdateFreebieForItem()
3492 
 
3493 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3494 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3495 
    args = addOrUpdateFreebieForItem_args()
3496 
    args.freebieItem = freebieItem
3497 
    args.write(self._oprot)
3498 
    self._oprot.writeMessageEnd()
3499 
    self._oprot.trans.flush()
3500 
 
3501 
  def recv_addOrUpdateFreebieForItem(self, ):
3502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3503 
    if mtype == TMessageType.EXCEPTION:
3504 
      x = TApplicationException()
3505 
      x.read(self._iprot)
3506 
      self._iprot.readMessageEnd()
3507 
      raise x
3508 
    result = addOrUpdateFreebieForItem_result()
3509 
    result.read(self._iprot)
3510 
    self._iprot.readMessageEnd()
3511 
    return
3512 
 
7272 amit.gupta 3513 
  def addOrUpdateBrandInfo(self, brandInfo):
3514 
    """
3515 
    Parameters:
3516 
     - brandInfo
3517 
    """
3518 
    self.send_addOrUpdateBrandInfo(brandInfo)
3519 
    self.recv_addOrUpdateBrandInfo()
3520 
 
3521 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3522 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3523 
    args = addOrUpdateBrandInfo_args()
3524 
    args.brandInfo = brandInfo
3525 
    args.write(self._oprot)
3526 
    self._oprot.writeMessageEnd()
3527 
    self._oprot.trans.flush()
3528 
 
3529 
  def recv_addOrUpdateBrandInfo(self, ):
3530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3531 
    if mtype == TMessageType.EXCEPTION:
3532 
      x = TApplicationException()
3533 
      x.read(self._iprot)
3534 
      self._iprot.readMessageEnd()
3535 
      raise x
3536 
    result = addOrUpdateBrandInfo_result()
3537 
    result.read(self._iprot)
3538 
    self._iprot.readMessageEnd()
3539 
    return
3540 
 
3541 
  def getBrandInfo(self, ):
3542 
    self.send_getBrandInfo()
3543 
    return self.recv_getBrandInfo()
3544 
 
3545 
  def send_getBrandInfo(self, ):
3546 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3547 
    args = getBrandInfo_args()
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_getBrandInfo(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = getBrandInfo_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3562 
    if result.success is not None:
3563 
      return result.success
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3565 
 
7256 rajveer 3566 
  def getStorePricing(self, itemId):
3567 
    """
3568 
    Parameters:
3569 
     - itemId
3570 
    """
3571 
    self.send_getStorePricing(itemId)
3572 
    return self.recv_getStorePricing()
7190 amar.kumar 3573 
 
7256 rajveer 3574 
  def send_getStorePricing(self, itemId):
3575 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3576 
    args = getStorePricing_args()
3577 
    args.itemId = itemId
3578 
    args.write(self._oprot)
3579 
    self._oprot.writeMessageEnd()
3580 
    self._oprot.trans.flush()
3581 
 
3582 
  def recv_getStorePricing(self, ):
3583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3584 
    if mtype == TMessageType.EXCEPTION:
3585 
      x = TApplicationException()
3586 
      x.read(self._iprot)
3587 
      self._iprot.readMessageEnd()
3588 
      raise x
3589 
    result = getStorePricing_result()
3590 
    result.read(self._iprot)
3591 
    self._iprot.readMessageEnd()
3592 
    if result.success is not None:
3593 
      return result.success
3594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3595 
 
7306 rajveer 3596 
  def getStorePricings(self, itemIds):
3597 
    """
3598 
    Parameters:
3599 
     - itemIds
3600 
    """
3601 
    self.send_getStorePricings(itemIds)
3602 
    return self.recv_getStorePricings()
3603 
 
3604 
  def send_getStorePricings(self, itemIds):
3605 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3606 
    args = getStorePricings_args()
3607 
    args.itemIds = itemIds
3608 
    args.write(self._oprot)
3609 
    self._oprot.writeMessageEnd()
3610 
    self._oprot.trans.flush()
3611 
 
3612 
  def recv_getStorePricings(self, ):
3613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3614 
    if mtype == TMessageType.EXCEPTION:
3615 
      x = TApplicationException()
3616 
      x.read(self._iprot)
3617 
      self._iprot.readMessageEnd()
3618 
      raise x
3619 
    result = getStorePricings_result()
3620 
    result.read(self._iprot)
3621 
    self._iprot.readMessageEnd()
3622 
    if result.success is not None:
3623 
      return result.success
3624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3625 
 
7382 rajveer 3626 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3627 
    """
3628 
    Parameters:
3629 
     - sp
7382 rajveer 3630 
     - allColors
7265 rajveer 3631 
    """
7382 rajveer 3632 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3633 
    self.recv_updateStorePricing()
7256 rajveer 3634 
 
7382 rajveer 3635 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3636 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3637 
    args = updateStorePricing_args()
3638 
    args.sp = sp
7382 rajveer 3639 
    args.allColors = allColors
7265 rajveer 3640 
    args.write(self._oprot)
3641 
    self._oprot.writeMessageEnd()
3642 
    self._oprot.trans.flush()
3643 
 
3644 
  def recv_updateStorePricing(self, ):
3645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3646 
    if mtype == TMessageType.EXCEPTION:
3647 
      x = TApplicationException()
3648 
      x.read(self._iprot)
3649 
      self._iprot.readMessageEnd()
3650 
      raise x
3651 
    result = updateStorePricing_result()
3652 
    result.read(self._iprot)
3653 
    self._iprot.readMessageEnd()
3654 
    return
3655 
 
7281 kshitij.so 3656 
  def getAllAmazonListedItems(self, ):
3657 
    self.send_getAllAmazonListedItems()
3658 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3659 
 
7281 kshitij.so 3660 
  def send_getAllAmazonListedItems(self, ):
3661 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3662 
    args = getAllAmazonListedItems_args()
3663 
    args.write(self._oprot)
3664 
    self._oprot.writeMessageEnd()
3665 
    self._oprot.trans.flush()
3666 
 
3667 
  def recv_getAllAmazonListedItems(self, ):
3668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3669 
    if mtype == TMessageType.EXCEPTION:
3670 
      x = TApplicationException()
3671 
      x.read(self._iprot)
3672 
      self._iprot.readMessageEnd()
3673 
      raise x
3674 
    result = getAllAmazonListedItems_result()
3675 
    result.read(self._iprot)
3676 
    self._iprot.readMessageEnd()
3677 
    if result.success is not None:
3678 
      return result.success
3679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3680 
 
3681 
  def getAmazonItemDetails(self, itemId):
3682 
    """
3683 
    Parameters:
3684 
     - itemId
3685 
    """
3686 
    self.send_getAmazonItemDetails(itemId)
3687 
    return self.recv_getAmazonItemDetails()
3688 
 
3689 
  def send_getAmazonItemDetails(self, itemId):
3690 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3691 
    args = getAmazonItemDetails_args()
3692 
    args.itemId = itemId
3693 
    args.write(self._oprot)
3694 
    self._oprot.writeMessageEnd()
3695 
    self._oprot.trans.flush()
3696 
 
3697 
  def recv_getAmazonItemDetails(self, ):
3698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3699 
    if mtype == TMessageType.EXCEPTION:
3700 
      x = TApplicationException()
3701 
      x.read(self._iprot)
3702 
      self._iprot.readMessageEnd()
3703 
      raise x
3704 
    result = getAmazonItemDetails_result()
3705 
    result.read(self._iprot)
3706 
    self._iprot.readMessageEnd()
3707 
    if result.success is not None:
3708 
      return result.success
3709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3710 
 
7367 kshitij.so 3711 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3712 
    """
3713 
    Parameters:
3714 
     - itemId
3715 
     - fbaPrice
3716 
     - sellingPrice
3717 
     - isFba
3718 
     - isNonFba
3719 
     - isInventoryOverride
7367 kshitij.so 3720 
     - handlingTime
3721 
     - isCustomTime
7281 kshitij.so 3722 
    """
7367 kshitij.so 3723 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3724 
    self.recv_updateAmazonItemDetails()
3725 
 
7367 kshitij.so 3726 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3727 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3728 
    args = updateAmazonItemDetails_args()
3729 
    args.itemId = itemId
3730 
    args.fbaPrice = fbaPrice
3731 
    args.sellingPrice = sellingPrice
3732 
    args.isFba = isFba
3733 
    args.isNonFba = isNonFba
3734 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3735 
    args.handlingTime = handlingTime
3736 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3737 
    args.write(self._oprot)
3738 
    self._oprot.writeMessageEnd()
3739 
    self._oprot.trans.flush()
3740 
 
3741 
  def recv_updateAmazonItemDetails(self, ):
3742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3743 
    if mtype == TMessageType.EXCEPTION:
3744 
      x = TApplicationException()
3745 
      x.read(self._iprot)
3746 
      self._iprot.readMessageEnd()
3747 
      raise x
3748 
    result = updateAmazonItemDetails_result()
3749 
    result.read(self._iprot)
3750 
    self._iprot.readMessageEnd()
3751 
    return
3752 
 
3753 
  def addAmazonItem(self, amazonlisted):
3754 
    """
3755 
    Parameters:
3756 
     - amazonlisted
3757 
    """
3758 
    self.send_addAmazonItem(amazonlisted)
3759 
    self.recv_addAmazonItem()
3760 
 
3761 
  def send_addAmazonItem(self, amazonlisted):
3762 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3763 
    args = addAmazonItem_args()
3764 
    args.amazonlisted = amazonlisted
3765 
    args.write(self._oprot)
3766 
    self._oprot.writeMessageEnd()
3767 
    self._oprot.trans.flush()
3768 
 
3769 
  def recv_addAmazonItem(self, ):
3770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3771 
    if mtype == TMessageType.EXCEPTION:
3772 
      x = TApplicationException()
3773 
      x.read(self._iprot)
3774 
      self._iprot.readMessageEnd()
3775 
      raise x
3776 
    result = addAmazonItem_result()
3777 
    result.read(self._iprot)
3778 
    self._iprot.readMessageEnd()
3779 
    return
3780 
 
7291 vikram.rag 3781 
  def getAsinItems(self, ):
3782 
    self.send_getAsinItems()
3783 
    return self.recv_getAsinItems()
7281 kshitij.so 3784 
 
7291 vikram.rag 3785 
  def send_getAsinItems(self, ):
3786 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3787 
    args = getAsinItems_args()
3788 
    args.write(self._oprot)
3789 
    self._oprot.writeMessageEnd()
3790 
    self._oprot.trans.flush()
3791 
 
3792 
  def recv_getAsinItems(self, ):
3793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3794 
    if mtype == TMessageType.EXCEPTION:
3795 
      x = TApplicationException()
3796 
      x.read(self._iprot)
3797 
      self._iprot.readMessageEnd()
3798 
      raise x
3799 
    result = getAsinItems_result()
3800 
    result.read(self._iprot)
3801 
    self._iprot.readMessageEnd()
3802 
    if result.success is not None:
3803 
      return result.success
3804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3805 
 
3806 
  def getAllFbaListedItems(self, ):
3807 
    self.send_getAllFbaListedItems()
3808 
    return self.recv_getAllFbaListedItems()
3809 
 
3810 
  def send_getAllFbaListedItems(self, ):
3811 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3812 
    args = getAllFbaListedItems_args()
3813 
    args.write(self._oprot)
3814 
    self._oprot.writeMessageEnd()
3815 
    self._oprot.trans.flush()
3816 
 
3817 
  def recv_getAllFbaListedItems(self, ):
3818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3819 
    if mtype == TMessageType.EXCEPTION:
3820 
      x = TApplicationException()
3821 
      x.read(self._iprot)
3822 
      self._iprot.readMessageEnd()
3823 
      raise x
3824 
    result = getAllFbaListedItems_result()
3825 
    result.read(self._iprot)
3826 
    self._iprot.readMessageEnd()
3827 
    if result.success is not None:
3828 
      return result.success
3829 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3830 
 
3831 
  def getAllNonFbaListedItems(self, ):
3832 
    self.send_getAllNonFbaListedItems()
3833 
    return self.recv_getAllNonFbaListedItems()
3834 
 
3835 
  def send_getAllNonFbaListedItems(self, ):
3836 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3837 
    args = getAllNonFbaListedItems_args()
3838 
    args.write(self._oprot)
3839 
    self._oprot.writeMessageEnd()
3840 
    self._oprot.trans.flush()
3841 
 
3842 
  def recv_getAllNonFbaListedItems(self, ):
3843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3844 
    if mtype == TMessageType.EXCEPTION:
3845 
      x = TApplicationException()
3846 
      x.read(self._iprot)
3847 
      self._iprot.readMessageEnd()
3848 
      raise x
3849 
    result = getAllNonFbaListedItems_result()
3850 
    result.read(self._iprot)
3851 
    self._iprot.readMessageEnd()
3852 
    if result.success is not None:
3853 
      return result.success
3854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3855 
 
7460 kshitij.so 3856 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3857 
    """
3858 
    Parameters:
3859 
     - itemId
3860 
     - holdInventory
3861 
     - defaultInventory
3862 
    """
3863 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3864 
    return self.recv_updateItemInventory()
7291 vikram.rag 3865 
 
7460 kshitij.so 3866 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3867 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3868 
    args = updateItemInventory_args()
3869 
    args.itemId = itemId
3870 
    args.holdInventory = holdInventory
3871 
    args.defaultInventory = defaultInventory
3872 
    args.write(self._oprot)
3873 
    self._oprot.writeMessageEnd()
3874 
    self._oprot.trans.flush()
3875 
 
3876 
  def recv_updateItemInventory(self, ):
3877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3878 
    if mtype == TMessageType.EXCEPTION:
3879 
      x = TApplicationException()
3880 
      x.read(self._iprot)
3881 
      self._iprot.readMessageEnd()
3882 
      raise x
3883 
    result = updateItemInventory_result()
3884 
    result.read(self._iprot)
3885 
    self._iprot.readMessageEnd()
3886 
    if result.success is not None:
3887 
      return result.success
3888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3889 
 
7770 kshitij.so 3890 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3891 
    """
3892 
    Parameters:
3893 
     - type
3894 
     - sku
3895 
     - timestamp
3896 
    """
3897 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
3898 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 3899 
 
7770 kshitij.so 3900 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
3901 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
3902 
    args = updateTimestampForAmazonFeeds_args()
3903 
    args.type = type
3904 
    args.sku = sku
3905 
    args.timestamp = timestamp
3906 
    args.write(self._oprot)
3907 
    self._oprot.writeMessageEnd()
3908 
    self._oprot.trans.flush()
3909 
 
3910 
  def recv_updateTimestampForAmazonFeeds(self, ):
3911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3912 
    if mtype == TMessageType.EXCEPTION:
3913 
      x = TApplicationException()
3914 
      x.read(self._iprot)
3915 
      self._iprot.readMessageEnd()
3916 
      raise x
3917 
    result = updateTimestampForAmazonFeeds_result()
3918 
    result.read(self._iprot)
3919 
    self._iprot.readMessageEnd()
3920 
    if result.success is not None:
3921 
      return result.success
3922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
3923 
 
7897 amar.kumar 3924 
  def getAllParentCategories(self, ):
3925 
    self.send_getAllParentCategories()
3926 
    return self.recv_getAllParentCategories()
7770 kshitij.so 3927 
 
7897 amar.kumar 3928 
  def send_getAllParentCategories(self, ):
3929 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
3930 
    args = getAllParentCategories_args()
3931 
    args.write(self._oprot)
3932 
    self._oprot.writeMessageEnd()
3933 
    self._oprot.trans.flush()
3934 
 
3935 
  def recv_getAllParentCategories(self, ):
3936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3937 
    if mtype == TMessageType.EXCEPTION:
3938 
      x = TApplicationException()
3939 
      x.read(self._iprot)
3940 
      self._iprot.readMessageEnd()
3941 
      raise x
3942 
    result = getAllParentCategories_result()
3943 
    result.read(self._iprot)
3944 
    self._iprot.readMessageEnd()
3945 
    if result.success is not None:
3946 
      return result.success
3947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
3948 
 
7977 kshitij.so 3949 
  def addPageViewEvent(self, pageViewEvents):
3950 
    """
3951 
    Parameters:
3952 
     - pageViewEvents
3953 
    """
3954 
    self.send_addPageViewEvent(pageViewEvents)
3955 
    self.recv_addPageViewEvent()
7897 amar.kumar 3956 
 
7977 kshitij.so 3957 
  def send_addPageViewEvent(self, pageViewEvents):
3958 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
3959 
    args = addPageViewEvent_args()
3960 
    args.pageViewEvents = pageViewEvents
3961 
    args.write(self._oprot)
3962 
    self._oprot.writeMessageEnd()
3963 
    self._oprot.trans.flush()
3964 
 
3965 
  def recv_addPageViewEvent(self, ):
3966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3967 
    if mtype == TMessageType.EXCEPTION:
3968 
      x = TApplicationException()
3969 
      x.read(self._iprot)
3970 
      self._iprot.readMessageEnd()
3971 
      raise x
3972 
    result = addPageViewEvent_result()
3973 
    result.read(self._iprot)
3974 
    self._iprot.readMessageEnd()
3975 
    return
3976 
 
3977 
  def addCartEvent(self, cartEvents):
3978 
    """
3979 
    Parameters:
3980 
     - cartEvents
3981 
    """
3982 
    self.send_addCartEvent(cartEvents)
3983 
    self.recv_addCartEvent()
3984 
 
3985 
  def send_addCartEvent(self, cartEvents):
3986 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
3987 
    args = addCartEvent_args()
3988 
    args.cartEvents = cartEvents
3989 
    args.write(self._oprot)
3990 
    self._oprot.writeMessageEnd()
3991 
    self._oprot.trans.flush()
3992 
 
3993 
  def recv_addCartEvent(self, ):
3994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3995 
    if mtype == TMessageType.EXCEPTION:
3996 
      x = TApplicationException()
3997 
      x.read(self._iprot)
3998 
      self._iprot.readMessageEnd()
3999 
      raise x
4000 
    result = addCartEvent_result()
4001 
    result.read(self._iprot)
4002 
    self._iprot.readMessageEnd()
4003 
    return
4004 
 
8139 kshitij.so 4005 
  def getAmazonListedItems(self, offset, limit):
4006 
    """
4007 
    Parameters:
4008 
     - offset
4009 
     - limit
4010 
    """
4011 
    self.send_getAmazonListedItems(offset, limit)
4012 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4013 
 
8139 kshitij.so 4014 
  def send_getAmazonListedItems(self, offset, limit):
4015 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4016 
    args = getAmazonListedItems_args()
4017 
    args.offset = offset
4018 
    args.limit = limit
4019 
    args.write(self._oprot)
4020 
    self._oprot.writeMessageEnd()
4021 
    self._oprot.trans.flush()
4022 
 
4023 
  def recv_getAmazonListedItems(self, ):
4024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4025 
    if mtype == TMessageType.EXCEPTION:
4026 
      x = TApplicationException()
4027 
      x.read(self._iprot)
4028 
      self._iprot.readMessageEnd()
4029 
      raise x
4030 
    result = getAmazonListedItems_result()
4031 
    result.read(self._iprot)
4032 
    self._iprot.readMessageEnd()
4033 
    if result.success is not None:
4034 
      return result.success
4035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4036 
 
4037 
 
5944 mandeep.dh 4038 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4039 
  def __init__(self, handler):
4040 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4041 
    self._processMap["addItem"] = Processor.process_addItem
4042 
    self._processMap["updateItem"] = Processor.process_updateItem
4043 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4044 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4045 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4046 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4047 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4048 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4049 
    self._processMap["getItem"] = Processor.process_getItem
4050 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4051 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4052 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4053 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4054 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4055 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4056 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4057 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4058 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4059 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4060 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4061 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4062 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4063 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4064 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4065 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4066 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4067 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4068 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4069 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4070 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4071 
    self._processMap["addCategory"] = Processor.process_addCategory
4072 
    self._processMap["getCategory"] = Processor.process_getCategory
4073 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4074 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4075 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4076 
    self._processMap["addTag"] = Processor.process_addTag
4077 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4078 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4079 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4080 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4081 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4082 
    self._processMap["addBanner"] = Processor.process_addBanner
4083 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4084 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4085 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4086 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4087 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
4088 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4089 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 4090 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4091 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4092 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4093 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4094 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4095 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4096 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4097 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4098 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4099 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4100 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4101 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4102 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4103 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4104 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4105 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4106 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4107 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4108 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4109 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4110 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4111 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4112 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4113 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4114 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4115 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4116 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4117 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4118 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4119 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4120 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4121 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4122 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4123 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4124 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4125 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4126 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4127 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4128 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4129 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4130 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4131 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
4132 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4133 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4134 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4135 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4136 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4137 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4138 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4139 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4140 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4141 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4142 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8139 kshitij.so 4143 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
5944 mandeep.dh 4144 
 
4145 
  def process(self, iprot, oprot):
4146 
    (name, type, seqid) = iprot.readMessageBegin()
4147 
    if name not in self._processMap:
4148 
      iprot.skip(TType.STRUCT)
4149 
      iprot.readMessageEnd()
4150 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4151 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4152 
      x.write(oprot)
4153 
      oprot.writeMessageEnd()
4154 
      oprot.trans.flush()
4155 
      return
4156 
    else:
4157 
      self._processMap[name](self, seqid, iprot, oprot)
4158 
    return True
4159 
 
4160 
  def process_addItem(self, seqid, iprot, oprot):
4161 
    args = addItem_args()
4162 
    args.read(iprot)
4163 
    iprot.readMessageEnd()
4164 
    result = addItem_result()
4165 
    try:
4166 
      result.success = self._handler.addItem(args.item)
4167 
    except CatalogServiceException, cex:
4168 
      result.cex = cex
4169 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4170 
    result.write(oprot)
4171 
    oprot.writeMessageEnd()
4172 
    oprot.trans.flush()
4173 
 
4174 
  def process_updateItem(self, seqid, iprot, oprot):
4175 
    args = updateItem_args()
4176 
    args.read(iprot)
4177 
    iprot.readMessageEnd()
4178 
    result = updateItem_result()
4179 
    try:
4180 
      result.success = self._handler.updateItem(args.item)
4181 
    except CatalogServiceException, cex:
4182 
      result.cex = cex
4183 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4184 
    result.write(oprot)
4185 
    oprot.writeMessageEnd()
4186 
    oprot.trans.flush()
4187 
 
4188 
  def process_isActive(self, seqid, iprot, oprot):
4189 
    args = isActive_args()
4190 
    args.read(iprot)
4191 
    iprot.readMessageEnd()
4192 
    result = isActive_result()
4193 
    try:
4194 
      result.success = self._handler.isActive(args.itemId)
4195 
    except CatalogServiceException, isex:
4196 
      result.isex = isex
4197 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4198 
    result.write(oprot)
4199 
    oprot.writeMessageEnd()
4200 
    oprot.trans.flush()
4201 
 
7438 amit.gupta 4202 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4203 
    args = getItemsStatus_args()
4204 
    args.read(iprot)
4205 
    iprot.readMessageEnd()
4206 
    result = getItemsStatus_result()
4207 
    try:
4208 
      result.success = self._handler.getItemsStatus(args.itemIds)
4209 
    except CatalogServiceException, isex:
4210 
      result.isex = isex
4211 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4212 
    result.write(oprot)
4213 
    oprot.writeMessageEnd()
4214 
    oprot.trans.flush()
4215 
 
5944 mandeep.dh 4216 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4217 
    args = getItemStatusDescription_args()
4218 
    args.read(iprot)
4219 
    iprot.readMessageEnd()
4220 
    result = getItemStatusDescription_result()
4221 
    try:
4222 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4223 
    except CatalogServiceException, isex:
4224 
      result.isex = isex
4225 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4226 
    result.write(oprot)
4227 
    oprot.writeMessageEnd()
4228 
    oprot.trans.flush()
4229 
 
4230 
  def process_startItemOn(self, seqid, iprot, oprot):
4231 
    args = startItemOn_args()
4232 
    args.read(iprot)
4233 
    iprot.readMessageEnd()
4234 
    result = startItemOn_result()
4235 
    try:
4236 
      self._handler.startItemOn(args.item_id, args.timestamp)
4237 
    except CatalogServiceException, cex:
4238 
      result.cex = cex
4239 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4240 
    result.write(oprot)
4241 
    oprot.writeMessageEnd()
4242 
    oprot.trans.flush()
4243 
 
4244 
  def process_retireItemOn(self, seqid, iprot, oprot):
4245 
    args = retireItemOn_args()
4246 
    args.read(iprot)
4247 
    iprot.readMessageEnd()
4248 
    result = retireItemOn_result()
4249 
    try:
4250 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4251 
    except CatalogServiceException, cex:
4252 
      result.cex = cex
4253 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4254 
    result.write(oprot)
4255 
    oprot.writeMessageEnd()
4256 
    oprot.trans.flush()
4257 
 
4258 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4259 
    args = changeItemStatus_args()
4260 
    args.read(iprot)
4261 
    iprot.readMessageEnd()
4262 
    result = changeItemStatus_result()
4263 
    try:
4264 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4265 
    except CatalogServiceException, cex:
4266 
      result.cex = cex
4267 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4268 
    result.write(oprot)
4269 
    oprot.writeMessageEnd()
4270 
    oprot.trans.flush()
4271 
 
4272 
  def process_getItem(self, seqid, iprot, oprot):
4273 
    args = getItem_args()
4274 
    args.read(iprot)
4275 
    iprot.readMessageEnd()
4276 
    result = getItem_result()
4277 
    try:
4278 
      result.success = self._handler.getItem(args.item_id)
4279 
    except CatalogServiceException, cex:
4280 
      result.cex = cex
4281 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4282 
    result.write(oprot)
4283 
    oprot.writeMessageEnd()
4284 
    oprot.trans.flush()
4285 
 
4286 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4287 
    args = getItemsByCatalogId_args()
4288 
    args.read(iprot)
4289 
    iprot.readMessageEnd()
4290 
    result = getItemsByCatalogId_result()
4291 
    try:
4292 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4293 
    except CatalogServiceException, cex:
4294 
      result.cex = cex
4295 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4296 
    result.write(oprot)
4297 
    oprot.writeMessageEnd()
4298 
    oprot.trans.flush()
4299 
 
4300 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4301 
    args = getValidItemsByCatalogId_args()
4302 
    args.read(iprot)
4303 
    iprot.readMessageEnd()
4304 
    result = getValidItemsByCatalogId_result()
4305 
    try:
4306 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4307 
    except CatalogServiceException, cex:
4308 
      result.cex = cex
4309 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4310 
    result.write(oprot)
4311 
    oprot.writeMessageEnd()
4312 
    oprot.trans.flush()
4313 
 
4314 
  def process_getAllItems(self, seqid, iprot, oprot):
4315 
    args = getAllItems_args()
4316 
    args.read(iprot)
4317 
    iprot.readMessageEnd()
4318 
    result = getAllItems_result()
4319 
    try:
4320 
      result.success = self._handler.getAllItems(args.isActive)
4321 
    except CatalogServiceException, cex:
4322 
      result.cex = cex
4323 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4324 
    result.write(oprot)
4325 
    oprot.writeMessageEnd()
4326 
    oprot.trans.flush()
4327 
 
4328 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4329 
    args = getAllItemsByStatus_args()
4330 
    args.read(iprot)
4331 
    iprot.readMessageEnd()
4332 
    result = getAllItemsByStatus_result()
4333 
    try:
4334 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4335 
    except CatalogServiceException, cex:
4336 
      result.cex = cex
4337 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4338 
    result.write(oprot)
4339 
    oprot.writeMessageEnd()
4340 
    oprot.trans.flush()
4341 
 
4342 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4343 
    args = markItemAsContentComplete_args()
4344 
    args.read(iprot)
4345 
    iprot.readMessageEnd()
4346 
    result = markItemAsContentComplete_result()
4347 
    try:
4348 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4349 
    except CatalogServiceException, cex:
4350 
      result.cex = cex
4351 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4352 
    result.write(oprot)
4353 
    oprot.writeMessageEnd()
4354 
    oprot.trans.flush()
4355 
 
4356 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4357 
    args = getAllItemsInRange_args()
4358 
    args.read(iprot)
4359 
    iprot.readMessageEnd()
4360 
    result = getAllItemsInRange_result()
4361 
    try:
4362 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4363 
    except CatalogServiceException, cex:
4364 
      result.cex = cex
4365 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4366 
    result.write(oprot)
4367 
    oprot.writeMessageEnd()
4368 
    oprot.trans.flush()
4369 
 
4370 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4371 
    args = getAllItemsByStatusInRange_args()
4372 
    args.read(iprot)
4373 
    iprot.readMessageEnd()
4374 
    result = getAllItemsByStatusInRange_result()
4375 
    try:
4376 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4377 
    except CatalogServiceException, cex:
4378 
      result.cex = cex
4379 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4380 
    result.write(oprot)
4381 
    oprot.writeMessageEnd()
4382 
    oprot.trans.flush()
4383 
 
4384 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4385 
    args = getItemCountByStatus_args()
4386 
    args.read(iprot)
4387 
    iprot.readMessageEnd()
4388 
    result = getItemCountByStatus_result()
4389 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4390 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4391 
    result.write(oprot)
4392 
    oprot.writeMessageEnd()
4393 
    oprot.trans.flush()
4394 
 
4395 
  def process_getBestSellers(self, seqid, iprot, oprot):
4396 
    args = getBestSellers_args()
4397 
    args.read(iprot)
4398 
    iprot.readMessageEnd()
4399 
    result = getBestSellers_result()
4400 
    try:
4401 
      result.success = self._handler.getBestSellers()
4402 
    except CatalogServiceException, isex:
4403 
      result.isex = isex
4404 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4405 
    result.write(oprot)
4406 
    oprot.writeMessageEnd()
4407 
    oprot.trans.flush()
4408 
 
4409 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4410 
    args = getBestSellersCatalogIds_args()
4411 
    args.read(iprot)
4412 
    iprot.readMessageEnd()
4413 
    result = getBestSellersCatalogIds_result()
4414 
    try:
4415 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4416 
    except CatalogServiceException, cex:
4417 
      result.cex = cex
4418 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4419 
    result.write(oprot)
4420 
    oprot.writeMessageEnd()
4421 
    oprot.trans.flush()
4422 
 
4423 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4424 
    args = getBestSellersCount_args()
4425 
    args.read(iprot)
4426 
    iprot.readMessageEnd()
4427 
    result = getBestSellersCount_result()
4428 
    try:
4429 
      result.success = self._handler.getBestSellersCount()
4430 
    except CatalogServiceException, cex:
4431 
      result.cex = cex
4432 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4433 
    result.write(oprot)
4434 
    oprot.writeMessageEnd()
4435 
    oprot.trans.flush()
4436 
 
4437 
  def process_getBestDeals(self, seqid, iprot, oprot):
4438 
    args = getBestDeals_args()
4439 
    args.read(iprot)
4440 
    iprot.readMessageEnd()
4441 
    result = getBestDeals_result()
4442 
    try:
4443 
      result.success = self._handler.getBestDeals()
4444 
    except CatalogServiceException, isex:
4445 
      result.isex = isex
4446 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4447 
    result.write(oprot)
4448 
    oprot.writeMessageEnd()
4449 
    oprot.trans.flush()
4450 
 
4451 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4452 
    args = getBestDealsCatalogIds_args()
4453 
    args.read(iprot)
4454 
    iprot.readMessageEnd()
4455 
    result = getBestDealsCatalogIds_result()
4456 
    try:
4457 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4458 
    except CatalogServiceException, cex:
4459 
      result.cex = cex
4460 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4461 
    result.write(oprot)
4462 
    oprot.writeMessageEnd()
4463 
    oprot.trans.flush()
4464 
 
4465 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4466 
    args = getBestDealsCount_args()
4467 
    args.read(iprot)
4468 
    iprot.readMessageEnd()
4469 
    result = getBestDealsCount_result()
4470 
    try:
4471 
      result.success = self._handler.getBestDealsCount()
4472 
    except CatalogServiceException, cex:
4473 
      result.cex = cex
4474 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4475 
    result.write(oprot)
4476 
    oprot.writeMessageEnd()
4477 
    oprot.trans.flush()
4478 
 
4479 
  def process_getComingSoon(self, seqid, iprot, oprot):
4480 
    args = getComingSoon_args()
4481 
    args.read(iprot)
4482 
    iprot.readMessageEnd()
4483 
    result = getComingSoon_result()
4484 
    try:
4485 
      result.success = self._handler.getComingSoon()
4486 
    except CatalogServiceException, isex:
4487 
      result.isex = isex
4488 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4489 
    result.write(oprot)
4490 
    oprot.writeMessageEnd()
4491 
    oprot.trans.flush()
4492 
 
4493 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4494 
    args = getComingSoonCatalogIds_args()
4495 
    args.read(iprot)
4496 
    iprot.readMessageEnd()
4497 
    result = getComingSoonCatalogIds_result()
4498 
    try:
4499 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4500 
    except CatalogServiceException, cex:
4501 
      result.cex = cex
4502 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4503 
    result.write(oprot)
4504 
    oprot.writeMessageEnd()
4505 
    oprot.trans.flush()
4506 
 
4507 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4508 
    args = getComingSoonCount_args()
4509 
    args.read(iprot)
4510 
    iprot.readMessageEnd()
4511 
    result = getComingSoonCount_result()
4512 
    try:
4513 
      result.success = self._handler.getComingSoonCount()
4514 
    except CatalogServiceException, cex:
4515 
      result.cex = cex
4516 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4517 
    result.write(oprot)
4518 
    oprot.writeMessageEnd()
4519 
    oprot.trans.flush()
4520 
 
4521 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4522 
    args = getLatestArrivals_args()
4523 
    args.read(iprot)
4524 
    iprot.readMessageEnd()
4525 
    result = getLatestArrivals_result()
4526 
    try:
4527 
      result.success = self._handler.getLatestArrivals()
4528 
    except CatalogServiceException, isex:
4529 
      result.isex = isex
4530 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4531 
    result.write(oprot)
4532 
    oprot.writeMessageEnd()
4533 
    oprot.trans.flush()
4534 
 
4535 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4536 
    args = getLatestArrivalsCatalogIds_args()
4537 
    args.read(iprot)
4538 
    iprot.readMessageEnd()
4539 
    result = getLatestArrivalsCatalogIds_result()
4540 
    try:
4541 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4542 
    except CatalogServiceException, cex:
4543 
      result.cex = cex
4544 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4545 
    result.write(oprot)
4546 
    oprot.writeMessageEnd()
4547 
    oprot.trans.flush()
4548 
 
4549 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4550 
    args = getLatestArrivalsCount_args()
4551 
    args.read(iprot)
4552 
    iprot.readMessageEnd()
4553 
    result = getLatestArrivalsCount_result()
4554 
    try:
4555 
      result.success = self._handler.getLatestArrivalsCount()
4556 
    except CatalogServiceException, cex:
4557 
      result.cex = cex
4558 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4559 
    result.write(oprot)
4560 
    oprot.writeMessageEnd()
4561 
    oprot.trans.flush()
4562 
 
4563 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4564 
    args = generateNewEntityID_args()
4565 
    args.read(iprot)
4566 
    iprot.readMessageEnd()
4567 
    result = generateNewEntityID_result()
4568 
    result.success = self._handler.generateNewEntityID()
4569 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4570 
    result.write(oprot)
4571 
    oprot.writeMessageEnd()
4572 
    oprot.trans.flush()
4573 
 
4574 
  def process_addCategory(self, seqid, iprot, oprot):
4575 
    args = addCategory_args()
4576 
    args.read(iprot)
4577 
    iprot.readMessageEnd()
4578 
    result = addCategory_result()
4579 
    result.success = self._handler.addCategory(args.category)
4580 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4581 
    result.write(oprot)
4582 
    oprot.writeMessageEnd()
4583 
    oprot.trans.flush()
4584 
 
4585 
  def process_getCategory(self, seqid, iprot, oprot):
4586 
    args = getCategory_args()
4587 
    args.read(iprot)
4588 
    iprot.readMessageEnd()
4589 
    result = getCategory_result()
4590 
    result.success = self._handler.getCategory(args.id)
4591 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4592 
    result.write(oprot)
4593 
    oprot.writeMessageEnd()
4594 
    oprot.trans.flush()
4595 
 
4596 
  def process_getAllCategories(self, seqid, iprot, oprot):
4597 
    args = getAllCategories_args()
4598 
    args.read(iprot)
4599 
    iprot.readMessageEnd()
4600 
    result = getAllCategories_result()
4601 
    result.success = self._handler.getAllCategories()
4602 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4603 
    result.write(oprot)
4604 
    oprot.writeMessageEnd()
4605 
    oprot.trans.flush()
4606 
 
4607 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4608 
    args = getAllSimilarItems_args()
4609 
    args.read(iprot)
4610 
    iprot.readMessageEnd()
4611 
    result = getAllSimilarItems_result()
4612 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4613 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4614 
    result.write(oprot)
4615 
    oprot.writeMessageEnd()
4616 
    oprot.trans.flush()
4617 
 
4618 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4619 
    args = addSimilarItem_args()
4620 
    args.read(iprot)
4621 
    iprot.readMessageEnd()
4622 
    result = addSimilarItem_result()
4623 
    try:
4624 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4625 
    except CatalogServiceException, cex:
4626 
      result.cex = cex
4627 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4628 
    result.write(oprot)
4629 
    oprot.writeMessageEnd()
4630 
    oprot.trans.flush()
4631 
 
6512 kshitij.so 4632 
  def process_addTag(self, seqid, iprot, oprot):
4633 
    args = addTag_args()
4634 
    args.read(iprot)
4635 
    iprot.readMessageEnd()
4636 
    result = addTag_result()
4637 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4638 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4639 
    result.write(oprot)
4640 
    oprot.writeMessageEnd()
4641 
    oprot.trans.flush()
4642 
 
4643 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4644 
    args = deleteEntityTag_args()
4645 
    args.read(iprot)
4646 
    iprot.readMessageEnd()
4647 
    result = deleteEntityTag_result()
4648 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4649 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4650 
    result.write(oprot)
4651 
    oprot.writeMessageEnd()
4652 
    oprot.trans.flush()
4653 
 
4654 
  def process_deleteTag(self, seqid, iprot, oprot):
4655 
    args = deleteTag_args()
4656 
    args.read(iprot)
4657 
    iprot.readMessageEnd()
4658 
    result = deleteTag_result()
4659 
    result.success = self._handler.deleteTag(args.displayName)
4660 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4661 
    result.write(oprot)
4662 
    oprot.writeMessageEnd()
4663 
    oprot.trans.flush()
4664 
 
4665 
  def process_getAllTags(self, seqid, iprot, oprot):
4666 
    args = getAllTags_args()
4667 
    args.read(iprot)
4668 
    iprot.readMessageEnd()
4669 
    result = getAllTags_result()
4670 
    result.success = self._handler.getAllTags()
4671 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4672 
    result.write(oprot)
4673 
    oprot.writeMessageEnd()
4674 
    oprot.trans.flush()
4675 
 
4676 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4677 
    args = getAllEntitiesByTagName_args()
4678 
    args.read(iprot)
4679 
    iprot.readMessageEnd()
4680 
    result = getAllEntitiesByTagName_result()
4681 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4682 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
6845 amit.gupta 4687 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4688 
    args = getAllEntityTags_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = getAllEntityTags_result()
4692 
    result.success = self._handler.getAllEntityTags()
4693 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4694 
    result.write(oprot)
4695 
    oprot.writeMessageEnd()
4696 
    oprot.trans.flush()
4697 
 
6850 kshitij.so 4698 
  def process_addBanner(self, seqid, iprot, oprot):
4699 
    args = addBanner_args()
4700 
    args.read(iprot)
4701 
    iprot.readMessageEnd()
4702 
    result = addBanner_result()
4703 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4704 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
4709 
  def process_getAllBanners(self, seqid, iprot, oprot):
4710 
    args = getAllBanners_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = getAllBanners_result()
4714 
    result.success = self._handler.getAllBanners()
4715 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
4720 
  def process_deleteBanner(self, seqid, iprot, oprot):
4721 
    args = deleteBanner_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = deleteBanner_result()
4725 
    result.success = self._handler.deleteBanner(args.bannerName)
4726 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
4730 
 
4731 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4732 
    args = getBannerDetails_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = getBannerDetails_result()
4736 
    result.success = self._handler.getBannerDetails(args.bannerName)
4737 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4738 
    result.write(oprot)
4739 
    oprot.writeMessageEnd()
4740 
    oprot.trans.flush()
4741 
 
4742 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4743 
    args = getActiveBanners_args()
4744 
    args.read(iprot)
4745 
    iprot.readMessageEnd()
4746 
    result = getActiveBanners_result()
4747 
    result.success = self._handler.getActiveBanners()
4748 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
6849 kshitij.so 4753 
  def process_addBannerMap(self, seqid, iprot, oprot):
4754 
    args = addBannerMap_args()
4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
4757 
    result = addBannerMap_result()
4758 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4759 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4760 
    result.write(oprot)
4761 
    oprot.writeMessageEnd()
4762 
    oprot.trans.flush()
4763 
 
4764 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4765 
    args = deleteBannerMap_args()
4766 
    args.read(iprot)
4767 
    iprot.readMessageEnd()
4768 
    result = deleteBannerMap_result()
4769 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4770 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4771 
    result.write(oprot)
4772 
    oprot.writeMessageEnd()
4773 
    oprot.trans.flush()
4774 
 
4775 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4776 
    args = getBannerMapDetails_args()
4777 
    args.read(iprot)
4778 
    iprot.readMessageEnd()
4779 
    result = getBannerMapDetails_result()
4780 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4781 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4782 
    result.write(oprot)
4783 
    oprot.writeMessageEnd()
4784 
    oprot.trans.flush()
4785 
 
5944 mandeep.dh 4786 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4787 
    args = deleteSimilarItem_args()
4788 
    args.read(iprot)
4789 
    iprot.readMessageEnd()
4790 
    result = deleteSimilarItem_result()
4791 
    try:
4792 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4793 
    except CatalogServiceException, cex:
4794 
      result.cex = cex
4795 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4796 
    result.write(oprot)
4797 
    oprot.writeMessageEnd()
4798 
    oprot.trans.flush()
4799 
 
4800 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4801 
    args = checkSimilarItem_args()
4802 
    args.read(iprot)
4803 
    iprot.readMessageEnd()
4804 
    result = checkSimilarItem_result()
4805 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4806 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4807 
    result.write(oprot)
4808 
    oprot.writeMessageEnd()
4809 
    oprot.trans.flush()
4810 
 
4811 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4812 
    args = validateRiskyStatus_args()
4813 
    args.read(iprot)
4814 
    iprot.readMessageEnd()
4815 
    result = validateRiskyStatus_result()
4816 
    self._handler.validateRiskyStatus(args.itemId)
4817 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4818 
    result.write(oprot)
4819 
    oprot.writeMessageEnd()
4820 
    oprot.trans.flush()
4821 
 
4822 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4823 
    args = changeItemRiskyFlag_args()
4824 
    args.read(iprot)
4825 
    iprot.readMessageEnd()
4826 
    result = changeItemRiskyFlag_result()
4827 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4828 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4829 
    result.write(oprot)
4830 
    oprot.writeMessageEnd()
4831 
    oprot.trans.flush()
4832 
 
4833 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4834 
    args = getItemsByRiskyFlag_args()
4835 
    args.read(iprot)
4836 
    iprot.readMessageEnd()
4837 
    result = getItemsByRiskyFlag_result()
4838 
    result.success = self._handler.getItemsByRiskyFlag()
4839 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4840 
    result.write(oprot)
4841 
    oprot.writeMessageEnd()
4842 
    oprot.trans.flush()
4843 
 
4844 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4845 
    args = getItemsForMasterSheet_args()
4846 
    args.read(iprot)
4847 
    iprot.readMessageEnd()
4848 
    result = getItemsForMasterSheet_result()
4849 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4850 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4851 
    result.write(oprot)
4852 
    oprot.writeMessageEnd()
4853 
    oprot.trans.flush()
4854 
 
4855 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4856 
    args = getSimilarItemsCatalogIds_args()
4857 
    args.read(iprot)
4858 
    iprot.readMessageEnd()
4859 
    result = getSimilarItemsCatalogIds_result()
4860 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4861 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4862 
    result.write(oprot)
4863 
    oprot.writeMessageEnd()
4864 
    oprot.trans.flush()
4865 
 
4866 
  def process_addProductNotification(self, seqid, iprot, oprot):
4867 
    args = addProductNotification_args()
4868 
    args.read(iprot)
4869 
    iprot.readMessageEnd()
4870 
    result = addProductNotification_result()
4871 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4872 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4873 
    result.write(oprot)
4874 
    oprot.writeMessageEnd()
4875 
    oprot.trans.flush()
4876 
 
4877 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4878 
    args = sendProductNotifications_args()
4879 
    args.read(iprot)
4880 
    iprot.readMessageEnd()
4881 
    result = sendProductNotifications_result()
4882 
    result.success = self._handler.sendProductNotifications()
4883 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4884 
    result.write(oprot)
4885 
    oprot.writeMessageEnd()
4886 
    oprot.trans.flush()
4887 
 
4888 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4889 
    args = getAllBrandsByCategory_args()
4890 
    args.read(iprot)
4891 
    iprot.readMessageEnd()
4892 
    result = getAllBrandsByCategory_result()
4893 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4894 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4895 
    result.write(oprot)
4896 
    oprot.writeMessageEnd()
4897 
    oprot.trans.flush()
4898 
 
4899 
  def process_getAllBrands(self, seqid, iprot, oprot):
4900 
    args = getAllBrands_args()
4901 
    args.read(iprot)
4902 
    iprot.readMessageEnd()
4903 
    result = getAllBrands_result()
4904 
    result.success = self._handler.getAllBrands()
4905 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4906 
    result.write(oprot)
4907 
    oprot.writeMessageEnd()
4908 
    oprot.trans.flush()
4909 
 
4910 
  def process_getAllSources(self, seqid, iprot, oprot):
4911 
    args = getAllSources_args()
4912 
    args.read(iprot)
4913 
    iprot.readMessageEnd()
4914 
    result = getAllSources_result()
4915 
    result.success = self._handler.getAllSources()
4916 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
4920 
 
4921 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4922 
    args = getItemPricingBySource_args()
4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
4925 
    result = getItemPricingBySource_result()
4926 
    try:
4927 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4928 
    except CatalogServiceException, cex:
4929 
      result.cex = cex
4930 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4931 
    result.write(oprot)
4932 
    oprot.writeMessageEnd()
4933 
    oprot.trans.flush()
4934 
 
4935 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4936 
    args = addSourceItemPricing_args()
4937 
    args.read(iprot)
4938 
    iprot.readMessageEnd()
4939 
    result = addSourceItemPricing_result()
4940 
    try:
4941 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4942 
    except CatalogServiceException, cex:
4943 
      result.cex = cex
4944 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
4948 
 
4949 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4950 
    args = getAllSourcePricing_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = getAllSourcePricing_result()
4954 
    try:
4955 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4956 
    except CatalogServiceException, cex:
4957 
      result.cex = cex
4958 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4959 
    result.write(oprot)
4960 
    oprot.writeMessageEnd()
4961 
    oprot.trans.flush()
4962 
 
4963 
  def process_getItemForSource(self, seqid, iprot, oprot):
4964 
    args = getItemForSource_args()
4965 
    args.read(iprot)
4966 
    iprot.readMessageEnd()
4967 
    result = getItemForSource_result()
4968 
    try:
4969 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4970 
    except CatalogServiceException, cex:
4971 
      result.cex = cex
4972 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4973 
    result.write(oprot)
4974 
    oprot.writeMessageEnd()
4975 
    oprot.trans.flush()
4976 
 
4977 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4978 
    args = searchItemsInRange_args()
4979 
    args.read(iprot)
4980 
    iprot.readMessageEnd()
4981 
    result = searchItemsInRange_result()
4982 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4983 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4984 
    result.write(oprot)
4985 
    oprot.writeMessageEnd()
4986 
    oprot.trans.flush()
4987 
 
4988 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4989 
    args = getSearchResultCount_args()
4990 
    args.read(iprot)
4991 
    iprot.readMessageEnd()
4992 
    result = getSearchResultCount_result()
4993 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4994 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4995 
    result.write(oprot)
4996 
    oprot.writeMessageEnd()
4997 
    oprot.trans.flush()
4998 
 
4999 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5000 
    args = getProductNotifications_args()
5001 
    args.read(iprot)
5002 
    iprot.readMessageEnd()
5003 
    result = getProductNotifications_result()
5004 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5005 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5006 
    result.write(oprot)
5007 
    oprot.writeMessageEnd()
5008 
    oprot.trans.flush()
5009 
 
5010 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5011 
    args = getProductNotificationRequestCount_args()
5012 
    args.read(iprot)
5013 
    iprot.readMessageEnd()
5014 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5015 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5016 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
5020 
 
5021 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5022 
    args = addAuthorizationLog_args()
5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
5025 
    result = addAuthorizationLog_result()
5026 
    try:
5027 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5028 
    except CatalogServiceException, cex:
5029 
      result.cex = cex
5030 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5031 
    result.write(oprot)
5032 
    oprot.writeMessageEnd()
5033 
    oprot.trans.flush()
5034 
 
5035 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5036 
    args = addupdateVoucherForItem_args()
5037 
    args.read(iprot)
5038 
    iprot.readMessageEnd()
5039 
    result = addupdateVoucherForItem_result()
5040 
    try:
5041 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5042 
    except CatalogServiceException, cex:
5043 
      result.cex = cex
5044 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5045 
    result.write(oprot)
5046 
    oprot.writeMessageEnd()
5047 
    oprot.trans.flush()
5048 
 
5049 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5050 
    args = deleteVoucherForItem_args()
5051 
    args.read(iprot)
5052 
    iprot.readMessageEnd()
5053 
    result = deleteVoucherForItem_result()
5054 
    try:
5055 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5056 
    except CatalogServiceException, cex:
5057 
      result.cex = cex
5058 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5059 
    result.write(oprot)
5060 
    oprot.writeMessageEnd()
5061 
    oprot.trans.flush()
5062 
 
5063 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5064 
    args = getVoucherAmount_args()
5065 
    args.read(iprot)
5066 
    iprot.readMessageEnd()
5067 
    result = getVoucherAmount_result()
5068 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5069 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5070 
    result.write(oprot)
5071 
    oprot.writeMessageEnd()
5072 
    oprot.trans.flush()
5073 
 
5074 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5075 
    args = getAllItemVouchers_args()
5076 
    args.read(iprot)
5077 
    iprot.readMessageEnd()
5078 
    result = getAllItemVouchers_result()
5079 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5080 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5081 
    result.write(oprot)
5082 
    oprot.writeMessageEnd()
5083 
    oprot.trans.flush()
5084 
 
5085 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5086 
    args = isValidCatalogItemId_args()
5087 
    args.read(iprot)
5088 
    iprot.readMessageEnd()
5089 
    result = isValidCatalogItemId_result()
5090 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5091 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5092 
    result.write(oprot)
5093 
    oprot.writeMessageEnd()
5094 
    oprot.trans.flush()
5095 
 
6039 amit.gupta 5096 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5097 
    args = getVatPercentageForItem_args()
5098 
    args.read(iprot)
5099 
    iprot.readMessageEnd()
5100 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5101 
    try:
5102 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5103 
    except CatalogServiceException, cex:
5104 
      result.cex = cex
6039 amit.gupta 5105 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5106 
    result.write(oprot)
5107 
    oprot.writeMessageEnd()
5108 
    oprot.trans.flush()
5944 mandeep.dh 5109 
 
6039 amit.gupta 5110 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5111 
    args = getVatAmountForItem_args()
5112 
    args.read(iprot)
5113 
    iprot.readMessageEnd()
5114 
    result = getVatAmountForItem_result()
5115 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5116 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5117 
    result.write(oprot)
5118 
    oprot.writeMessageEnd()
5119 
    oprot.trans.flush()
5120 
 
6531 vikram.rag 5121 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5122 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5123 
    args.read(iprot)
5124 
    iprot.readMessageEnd()
5125 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5126 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5127 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5128 
    result.write(oprot)
5129 
    oprot.writeMessageEnd()
5130 
    oprot.trans.flush()
6039 amit.gupta 5131 
 
6821 amar.kumar 5132 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5133 
    args = getAllAliveItems_args()
5134 
    args.read(iprot)
5135 
    iprot.readMessageEnd()
5136 
    result = getAllAliveItems_result()
5137 
    result.success = self._handler.getAllAliveItems()
5138 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5139 
    result.write(oprot)
5140 
    oprot.writeMessageEnd()
5141 
    oprot.trans.flush()
5142 
 
6805 anupam.sin 5143 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5144 
    args = getInsuranceAmount_args()
5145 
    args.read(iprot)
5146 
    iprot.readMessageEnd()
5147 
    result = getInsuranceAmount_result()
6921 anupam.sin 5148 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5149 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5150 
    result.write(oprot)
5151 
    oprot.writeMessageEnd()
5152 
    oprot.trans.flush()
6531 vikram.rag 5153 
 
6805 anupam.sin 5154 
  def process_getInsurer(self, seqid, iprot, oprot):
5155 
    args = getInsurer_args()
5156 
    args.read(iprot)
5157 
    iprot.readMessageEnd()
5158 
    result = getInsurer_result()
5159 
    result.success = self._handler.getInsurer(args.insurerId)
5160 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5161 
    result.write(oprot)
5162 
    oprot.writeMessageEnd()
5163 
    oprot.trans.flush()
5164 
 
6838 vikram.rag 5165 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5166 
    args = getAllInsurers_args()
5167 
    args.read(iprot)
5168 
    iprot.readMessageEnd()
5169 
    result = getAllInsurers_result()
5170 
    result.success = self._handler.getAllInsurers()
5171 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5172 
    result.write(oprot)
5173 
    oprot.writeMessageEnd()
5174 
    oprot.trans.flush()
6805 anupam.sin 5175 
 
6962 rajveer 5176 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
5177 
    args = updateInsuranceDeclaredAmount_args()
5178 
    args.read(iprot)
5179 
    iprot.readMessageEnd()
5180 
    result = updateInsuranceDeclaredAmount_result()
5181 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
5182 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
5183 
    result.write(oprot)
5184 
    oprot.writeMessageEnd()
5185 
    oprot.trans.flush()
6838 vikram.rag 5186 
 
7190 amar.kumar 5187 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
5188 
    args = getFreebieForItem_args()
5189 
    args.read(iprot)
5190 
    iprot.readMessageEnd()
5191 
    result = getFreebieForItem_result()
5192 
    result.success = self._handler.getFreebieForItem(args.itemId)
5193 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5194 
    result.write(oprot)
5195 
    oprot.writeMessageEnd()
5196 
    oprot.trans.flush()
6962 rajveer 5197 
 
7190 amar.kumar 5198 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5199 
    args = addOrUpdateFreebieForItem_args()
5200 
    args.read(iprot)
5201 
    iprot.readMessageEnd()
5202 
    result = addOrUpdateFreebieForItem_result()
5203 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5204 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5205 
    result.write(oprot)
5206 
    oprot.writeMessageEnd()
5207 
    oprot.trans.flush()
5208 
 
7272 amit.gupta 5209 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5210 
    args = addOrUpdateBrandInfo_args()
5211 
    args.read(iprot)
5212 
    iprot.readMessageEnd()
5213 
    result = addOrUpdateBrandInfo_result()
5214 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5215 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5216 
    result.write(oprot)
5217 
    oprot.writeMessageEnd()
5218 
    oprot.trans.flush()
5219 
 
5220 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5221 
    args = getBrandInfo_args()
5222 
    args.read(iprot)
5223 
    iprot.readMessageEnd()
5224 
    result = getBrandInfo_result()
5225 
    result.success = self._handler.getBrandInfo()
5226 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5227 
    result.write(oprot)
5228 
    oprot.writeMessageEnd()
5229 
    oprot.trans.flush()
5230 
 
7256 rajveer 5231 
  def process_getStorePricing(self, seqid, iprot, oprot):
5232 
    args = getStorePricing_args()
5233 
    args.read(iprot)
5234 
    iprot.readMessageEnd()
5235 
    result = getStorePricing_result()
5236 
    result.success = self._handler.getStorePricing(args.itemId)
5237 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5238 
    result.write(oprot)
5239 
    oprot.writeMessageEnd()
5240 
    oprot.trans.flush()
7190 amar.kumar 5241 
 
7306 rajveer 5242 
  def process_getStorePricings(self, seqid, iprot, oprot):
5243 
    args = getStorePricings_args()
5244 
    args.read(iprot)
5245 
    iprot.readMessageEnd()
5246 
    result = getStorePricings_result()
5247 
    result.success = self._handler.getStorePricings(args.itemIds)
5248 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5249 
    result.write(oprot)
5250 
    oprot.writeMessageEnd()
5251 
    oprot.trans.flush()
5252 
 
7265 rajveer 5253 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5254 
    args = updateStorePricing_args()
5255 
    args.read(iprot)
5256 
    iprot.readMessageEnd()
5257 
    result = updateStorePricing_result()
7382 rajveer 5258 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5259 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5260 
    result.write(oprot)
5261 
    oprot.writeMessageEnd()
5262 
    oprot.trans.flush()
7256 rajveer 5263 
 
7281 kshitij.so 5264 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5265 
    args = getAllAmazonListedItems_args()
5266 
    args.read(iprot)
5267 
    iprot.readMessageEnd()
5268 
    result = getAllAmazonListedItems_result()
5269 
    result.success = self._handler.getAllAmazonListedItems()
5270 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5271 
    result.write(oprot)
5272 
    oprot.writeMessageEnd()
5273 
    oprot.trans.flush()
7265 rajveer 5274 
 
7281 kshitij.so 5275 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5276 
    args = getAmazonItemDetails_args()
5277 
    args.read(iprot)
5278 
    iprot.readMessageEnd()
5279 
    result = getAmazonItemDetails_result()
5280 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5281 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5282 
    result.write(oprot)
5283 
    oprot.writeMessageEnd()
5284 
    oprot.trans.flush()
5285 
 
5286 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5287 
    args = updateAmazonItemDetails_args()
5288 
    args.read(iprot)
5289 
    iprot.readMessageEnd()
5290 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5291 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5292 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5293 
    result.write(oprot)
5294 
    oprot.writeMessageEnd()
5295 
    oprot.trans.flush()
5296 
 
5297 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5298 
    args = addAmazonItem_args()
5299 
    args.read(iprot)
5300 
    iprot.readMessageEnd()
5301 
    result = addAmazonItem_result()
5302 
    self._handler.addAmazonItem(args.amazonlisted)
5303 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5304 
    result.write(oprot)
5305 
    oprot.writeMessageEnd()
5306 
    oprot.trans.flush()
5307 
 
7291 vikram.rag 5308 
  def process_getAsinItems(self, seqid, iprot, oprot):
5309 
    args = getAsinItems_args()
5310 
    args.read(iprot)
5311 
    iprot.readMessageEnd()
5312 
    result = getAsinItems_result()
5313 
    result.success = self._handler.getAsinItems()
5314 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5315 
    result.write(oprot)
5316 
    oprot.writeMessageEnd()
5317 
    oprot.trans.flush()
7281 kshitij.so 5318 
 
7291 vikram.rag 5319 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5320 
    args = getAllFbaListedItems_args()
5321 
    args.read(iprot)
5322 
    iprot.readMessageEnd()
5323 
    result = getAllFbaListedItems_result()
5324 
    result.success = self._handler.getAllFbaListedItems()
5325 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5326 
    result.write(oprot)
5327 
    oprot.writeMessageEnd()
5328 
    oprot.trans.flush()
5329 
 
5330 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5331 
    args = getAllNonFbaListedItems_args()
5332 
    args.read(iprot)
5333 
    iprot.readMessageEnd()
5334 
    result = getAllNonFbaListedItems_result()
5335 
    result.success = self._handler.getAllNonFbaListedItems()
5336 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5337 
    result.write(oprot)
5338 
    oprot.writeMessageEnd()
5339 
    oprot.trans.flush()
5340 
 
7460 kshitij.so 5341 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5342 
    args = updateItemInventory_args()
5343 
    args.read(iprot)
5344 
    iprot.readMessageEnd()
5345 
    result = updateItemInventory_result()
5346 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5347 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5348 
    result.write(oprot)
5349 
    oprot.writeMessageEnd()
5350 
    oprot.trans.flush()
7291 vikram.rag 5351 
 
7770 kshitij.so 5352 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
5353 
    args = updateTimestampForAmazonFeeds_args()
5354 
    args.read(iprot)
5355 
    iprot.readMessageEnd()
5356 
    result = updateTimestampForAmazonFeeds_result()
5357 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
5358 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
5359 
    result.write(oprot)
5360 
    oprot.writeMessageEnd()
5361 
    oprot.trans.flush()
7460 kshitij.so 5362 
 
7897 amar.kumar 5363 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
5364 
    args = getAllParentCategories_args()
5365 
    args.read(iprot)
5366 
    iprot.readMessageEnd()
5367 
    result = getAllParentCategories_result()
5368 
    result.success = self._handler.getAllParentCategories()
5369 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
5370 
    result.write(oprot)
5371 
    oprot.writeMessageEnd()
5372 
    oprot.trans.flush()
7770 kshitij.so 5373 
 
7977 kshitij.so 5374 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
5375 
    args = addPageViewEvent_args()
5376 
    args.read(iprot)
5377 
    iprot.readMessageEnd()
5378 
    result = addPageViewEvent_result()
5379 
    self._handler.addPageViewEvent(args.pageViewEvents)
5380 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
5381 
    result.write(oprot)
5382 
    oprot.writeMessageEnd()
5383 
    oprot.trans.flush()
7897 amar.kumar 5384 
 
7977 kshitij.so 5385 
  def process_addCartEvent(self, seqid, iprot, oprot):
5386 
    args = addCartEvent_args()
5387 
    args.read(iprot)
5388 
    iprot.readMessageEnd()
5389 
    result = addCartEvent_result()
5390 
    self._handler.addCartEvent(args.cartEvents)
5391 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
5392 
    result.write(oprot)
5393 
    oprot.writeMessageEnd()
5394 
    oprot.trans.flush()
5395 
 
8139 kshitij.so 5396 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
5397 
    args = getAmazonListedItems_args()
5398 
    args.read(iprot)
5399 
    iprot.readMessageEnd()
5400 
    result = getAmazonListedItems_result()
5401 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
5402 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
5403 
    result.write(oprot)
5404 
    oprot.writeMessageEnd()
5405 
    oprot.trans.flush()
7977 kshitij.so 5406 
 
8139 kshitij.so 5407 
 
5944 mandeep.dh 5408 
# HELPER FUNCTIONS AND STRUCTURES
5409 
 
5410 
class addItem_args:
5411 
  """
5412 
  Attributes:
5413 
   - item
5414 
  """
5415 
 
5416 
  thrift_spec = (
5417 
    None, # 0
5418 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5419 
  )
5420 
 
5421 
  def __init__(self, item=None,):
5422 
    self.item = item
5423 
 
5424 
  def read(self, iprot):
5425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5427 
      return
5428 
    iprot.readStructBegin()
5429 
    while True:
5430 
      (fname, ftype, fid) = iprot.readFieldBegin()
5431 
      if ftype == TType.STOP:
5432 
        break
5433 
      if fid == 1:
5434 
        if ftype == TType.STRUCT:
5435 
          self.item = Item()
5436 
          self.item.read(iprot)
5437 
        else:
5438 
          iprot.skip(ftype)
5439 
      else:
5440 
        iprot.skip(ftype)
5441 
      iprot.readFieldEnd()
5442 
    iprot.readStructEnd()
5443 
 
5444 
  def write(self, oprot):
5445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5447 
      return
5448 
    oprot.writeStructBegin('addItem_args')
5449 
    if self.item is not None:
5450 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5451 
      self.item.write(oprot)
5452 
      oprot.writeFieldEnd()
5453 
    oprot.writeFieldStop()
5454 
    oprot.writeStructEnd()
5455 
 
5456 
  def validate(self):
5457 
    return
5458 
 
5459 
 
5460 
  def __repr__(self):
5461 
    L = ['%s=%r' % (key, value)
5462 
      for key, value in self.__dict__.iteritems()]
5463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5464 
 
5465 
  def __eq__(self, other):
5466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5467 
 
5468 
  def __ne__(self, other):
5469 
    return not (self == other)
5470 
 
5471 
class addItem_result:
5472 
  """
5473 
  Attributes:
5474 
   - success
5475 
   - cex
5476 
  """
5477 
 
5478 
  thrift_spec = (
5479 
    (0, TType.I64, 'success', None, None, ), # 0
5480 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5481 
  )
5482 
 
5483 
  def __init__(self, success=None, cex=None,):
5484 
    self.success = success
5485 
    self.cex = cex
5486 
 
5487 
  def read(self, iprot):
5488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5490 
      return
5491 
    iprot.readStructBegin()
5492 
    while True:
5493 
      (fname, ftype, fid) = iprot.readFieldBegin()
5494 
      if ftype == TType.STOP:
5495 
        break
5496 
      if fid == 0:
5497 
        if ftype == TType.I64:
5498 
          self.success = iprot.readI64();
5499 
        else:
5500 
          iprot.skip(ftype)
5501 
      elif fid == 1:
5502 
        if ftype == TType.STRUCT:
5503 
          self.cex = CatalogServiceException()
5504 
          self.cex.read(iprot)
5505 
        else:
5506 
          iprot.skip(ftype)
5507 
      else:
5508 
        iprot.skip(ftype)
5509 
      iprot.readFieldEnd()
5510 
    iprot.readStructEnd()
5511 
 
5512 
  def write(self, oprot):
5513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5515 
      return
5516 
    oprot.writeStructBegin('addItem_result')
5517 
    if self.success is not None:
5518 
      oprot.writeFieldBegin('success', TType.I64, 0)
5519 
      oprot.writeI64(self.success)
5520 
      oprot.writeFieldEnd()
5521 
    if self.cex is not None:
5522 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5523 
      self.cex.write(oprot)
5524 
      oprot.writeFieldEnd()
5525 
    oprot.writeFieldStop()
5526 
    oprot.writeStructEnd()
5527 
 
5528 
  def validate(self):
5529 
    return
5530 
 
5531 
 
5532 
  def __repr__(self):
5533 
    L = ['%s=%r' % (key, value)
5534 
      for key, value in self.__dict__.iteritems()]
5535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5536 
 
5537 
  def __eq__(self, other):
5538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5539 
 
5540 
  def __ne__(self, other):
5541 
    return not (self == other)
5542 
 
5543 
class updateItem_args:
5544 
  """
5545 
  Attributes:
5546 
   - item
5547 
  """
5548 
 
5549 
  thrift_spec = (
5550 
    None, # 0
5551 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5552 
  )
5553 
 
5554 
  def __init__(self, item=None,):
5555 
    self.item = item
5556 
 
5557 
  def read(self, iprot):
5558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5560 
      return
5561 
    iprot.readStructBegin()
5562 
    while True:
5563 
      (fname, ftype, fid) = iprot.readFieldBegin()
5564 
      if ftype == TType.STOP:
5565 
        break
5566 
      if fid == 1:
5567 
        if ftype == TType.STRUCT:
5568 
          self.item = Item()
5569 
          self.item.read(iprot)
5570 
        else:
5571 
          iprot.skip(ftype)
5572 
      else:
5573 
        iprot.skip(ftype)
5574 
      iprot.readFieldEnd()
5575 
    iprot.readStructEnd()
5576 
 
5577 
  def write(self, oprot):
5578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5580 
      return
5581 
    oprot.writeStructBegin('updateItem_args')
5582 
    if self.item is not None:
5583 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5584 
      self.item.write(oprot)
5585 
      oprot.writeFieldEnd()
5586 
    oprot.writeFieldStop()
5587 
    oprot.writeStructEnd()
5588 
 
5589 
  def validate(self):
5590 
    return
5591 
 
5592 
 
5593 
  def __repr__(self):
5594 
    L = ['%s=%r' % (key, value)
5595 
      for key, value in self.__dict__.iteritems()]
5596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5597 
 
5598 
  def __eq__(self, other):
5599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5600 
 
5601 
  def __ne__(self, other):
5602 
    return not (self == other)
5603 
 
5604 
class updateItem_result:
5605 
  """
5606 
  Attributes:
5607 
   - success
5608 
   - cex
5609 
  """
5610 
 
5611 
  thrift_spec = (
5612 
    (0, TType.I64, 'success', None, None, ), # 0
5613 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5614 
  )
5615 
 
5616 
  def __init__(self, success=None, cex=None,):
5617 
    self.success = success
5618 
    self.cex = cex
5619 
 
5620 
  def read(self, iprot):
5621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5623 
      return
5624 
    iprot.readStructBegin()
5625 
    while True:
5626 
      (fname, ftype, fid) = iprot.readFieldBegin()
5627 
      if ftype == TType.STOP:
5628 
        break
5629 
      if fid == 0:
5630 
        if ftype == TType.I64:
5631 
          self.success = iprot.readI64();
5632 
        else:
5633 
          iprot.skip(ftype)
5634 
      elif fid == 1:
5635 
        if ftype == TType.STRUCT:
5636 
          self.cex = CatalogServiceException()
5637 
          self.cex.read(iprot)
5638 
        else:
5639 
          iprot.skip(ftype)
5640 
      else:
5641 
        iprot.skip(ftype)
5642 
      iprot.readFieldEnd()
5643 
    iprot.readStructEnd()
5644 
 
5645 
  def write(self, oprot):
5646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5648 
      return
5649 
    oprot.writeStructBegin('updateItem_result')
5650 
    if self.success is not None:
5651 
      oprot.writeFieldBegin('success', TType.I64, 0)
5652 
      oprot.writeI64(self.success)
5653 
      oprot.writeFieldEnd()
5654 
    if self.cex is not None:
5655 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5656 
      self.cex.write(oprot)
5657 
      oprot.writeFieldEnd()
5658 
    oprot.writeFieldStop()
5659 
    oprot.writeStructEnd()
5660 
 
5661 
  def validate(self):
5662 
    return
5663 
 
5664 
 
5665 
  def __repr__(self):
5666 
    L = ['%s=%r' % (key, value)
5667 
      for key, value in self.__dict__.iteritems()]
5668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5669 
 
5670 
  def __eq__(self, other):
5671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5672 
 
5673 
  def __ne__(self, other):
5674 
    return not (self == other)
5675 
 
5676 
class isActive_args:
5677 
  """
5678 
  Attributes:
5679 
   - itemId
5680 
  """
5681 
 
5682 
  thrift_spec = (
5683 
    None, # 0
5684 
    (1, TType.I64, 'itemId', None, None, ), # 1
5685 
  )
5686 
 
5687 
  def __init__(self, itemId=None,):
5688 
    self.itemId = itemId
5689 
 
5690 
  def read(self, iprot):
5691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5693 
      return
5694 
    iprot.readStructBegin()
5695 
    while True:
5696 
      (fname, ftype, fid) = iprot.readFieldBegin()
5697 
      if ftype == TType.STOP:
5698 
        break
5699 
      if fid == 1:
5700 
        if ftype == TType.I64:
5701 
          self.itemId = iprot.readI64();
5702 
        else:
5703 
          iprot.skip(ftype)
5704 
      else:
5705 
        iprot.skip(ftype)
5706 
      iprot.readFieldEnd()
5707 
    iprot.readStructEnd()
5708 
 
5709 
  def write(self, oprot):
5710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5712 
      return
5713 
    oprot.writeStructBegin('isActive_args')
5714 
    if self.itemId is not None:
5715 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5716 
      oprot.writeI64(self.itemId)
5717 
      oprot.writeFieldEnd()
5718 
    oprot.writeFieldStop()
5719 
    oprot.writeStructEnd()
5720 
 
5721 
  def validate(self):
5722 
    return
5723 
 
5724 
 
5725 
  def __repr__(self):
5726 
    L = ['%s=%r' % (key, value)
5727 
      for key, value in self.__dict__.iteritems()]
5728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5729 
 
5730 
  def __eq__(self, other):
5731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5732 
 
5733 
  def __ne__(self, other):
5734 
    return not (self == other)
5735 
 
5736 
class isActive_result:
5737 
  """
5738 
  Attributes:
5739 
   - success
5740 
   - isex
5741 
  """
5742 
 
5743 
  thrift_spec = (
5744 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5745 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5746 
  )
5747 
 
5748 
  def __init__(self, success=None, isex=None,):
5749 
    self.success = success
5750 
    self.isex = isex
5751 
 
5752 
  def read(self, iprot):
5753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5755 
      return
5756 
    iprot.readStructBegin()
5757 
    while True:
5758 
      (fname, ftype, fid) = iprot.readFieldBegin()
5759 
      if ftype == TType.STOP:
5760 
        break
5761 
      if fid == 0:
5762 
        if ftype == TType.STRUCT:
5763 
          self.success = ItemShippingInfo()
5764 
          self.success.read(iprot)
5765 
        else:
5766 
          iprot.skip(ftype)
5767 
      elif fid == 1:
5768 
        if ftype == TType.STRUCT:
5769 
          self.isex = CatalogServiceException()
5770 
          self.isex.read(iprot)
5771 
        else:
5772 
          iprot.skip(ftype)
5773 
      else:
5774 
        iprot.skip(ftype)
5775 
      iprot.readFieldEnd()
5776 
    iprot.readStructEnd()
5777 
 
5778 
  def write(self, oprot):
5779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5781 
      return
5782 
    oprot.writeStructBegin('isActive_result')
5783 
    if self.success is not None:
5784 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5785 
      self.success.write(oprot)
5786 
      oprot.writeFieldEnd()
5787 
    if self.isex is not None:
5788 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5789 
      self.isex.write(oprot)
5790 
      oprot.writeFieldEnd()
5791 
    oprot.writeFieldStop()
5792 
    oprot.writeStructEnd()
5793 
 
5794 
  def validate(self):
5795 
    return
5796 
 
5797 
 
5798 
  def __repr__(self):
5799 
    L = ['%s=%r' % (key, value)
5800 
      for key, value in self.__dict__.iteritems()]
5801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5802 
 
5803 
  def __eq__(self, other):
5804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5805 
 
5806 
  def __ne__(self, other):
5807 
    return not (self == other)
5808 
 
7438 amit.gupta 5809 
class getItemsStatus_args:
5810 
  """
5811 
  Attributes:
5812 
   - itemIds
5813 
  """
5814 
 
5815 
  thrift_spec = (
5816 
    None, # 0
5817 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5818 
  )
5819 
 
5820 
  def __init__(self, itemIds=None,):
5821 
    self.itemIds = itemIds
5822 
 
5823 
  def read(self, iprot):
5824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5826 
      return
5827 
    iprot.readStructBegin()
5828 
    while True:
5829 
      (fname, ftype, fid) = iprot.readFieldBegin()
5830 
      if ftype == TType.STOP:
5831 
        break
5832 
      if fid == 1:
5833 
        if ftype == TType.LIST:
5834 
          self.itemIds = []
5835 
          (_etype19, _size16) = iprot.readListBegin()
5836 
          for _i20 in xrange(_size16):
5837 
            _elem21 = iprot.readI64();
5838 
            self.itemIds.append(_elem21)
5839 
          iprot.readListEnd()
5840 
        else:
5841 
          iprot.skip(ftype)
5842 
      else:
5843 
        iprot.skip(ftype)
5844 
      iprot.readFieldEnd()
5845 
    iprot.readStructEnd()
5846 
 
5847 
  def write(self, oprot):
5848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5850 
      return
5851 
    oprot.writeStructBegin('getItemsStatus_args')
5852 
    if self.itemIds is not None:
5853 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
5854 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5855 
      for iter22 in self.itemIds:
5856 
        oprot.writeI64(iter22)
5857 
      oprot.writeListEnd()
5858 
      oprot.writeFieldEnd()
5859 
    oprot.writeFieldStop()
5860 
    oprot.writeStructEnd()
5861 
 
5862 
  def validate(self):
5863 
    return
5864 
 
5865 
 
5866 
  def __repr__(self):
5867 
    L = ['%s=%r' % (key, value)
5868 
      for key, value in self.__dict__.iteritems()]
5869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5870 
 
5871 
  def __eq__(self, other):
5872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5873 
 
5874 
  def __ne__(self, other):
5875 
    return not (self == other)
5876 
 
5877 
class getItemsStatus_result:
5878 
  """
5879 
  Attributes:
5880 
   - success
5881 
   - isex
5882 
  """
5883 
 
5884 
  thrift_spec = (
5885 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
5886 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5887 
  )
5888 
 
5889 
  def __init__(self, success=None, isex=None,):
5890 
    self.success = success
5891 
    self.isex = isex
5892 
 
5893 
  def read(self, iprot):
5894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5896 
      return
5897 
    iprot.readStructBegin()
5898 
    while True:
5899 
      (fname, ftype, fid) = iprot.readFieldBegin()
5900 
      if ftype == TType.STOP:
5901 
        break
5902 
      if fid == 0:
5903 
        if ftype == TType.MAP:
5904 
          self.success = {}
5905 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
5906 
          for _i27 in xrange(_size23):
5907 
            _key28 = iprot.readI64();
5908 
            _val29 = iprot.readBool();
5909 
            self.success[_key28] = _val29
5910 
          iprot.readMapEnd()
5911 
        else:
5912 
          iprot.skip(ftype)
5913 
      elif fid == 1:
5914 
        if ftype == TType.STRUCT:
5915 
          self.isex = CatalogServiceException()
5916 
          self.isex.read(iprot)
5917 
        else:
5918 
          iprot.skip(ftype)
5919 
      else:
5920 
        iprot.skip(ftype)
5921 
      iprot.readFieldEnd()
5922 
    iprot.readStructEnd()
5923 
 
5924 
  def write(self, oprot):
5925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5927 
      return
5928 
    oprot.writeStructBegin('getItemsStatus_result')
5929 
    if self.success is not None:
5930 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5931 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
5932 
      for kiter30,viter31 in self.success.items():
5933 
        oprot.writeI64(kiter30)
5934 
        oprot.writeBool(viter31)
5935 
      oprot.writeMapEnd()
5936 
      oprot.writeFieldEnd()
5937 
    if self.isex is not None:
5938 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5939 
      self.isex.write(oprot)
5940 
      oprot.writeFieldEnd()
5941 
    oprot.writeFieldStop()
5942 
    oprot.writeStructEnd()
5943 
 
5944 
  def validate(self):
5945 
    return
5946 
 
5947 
 
5948 
  def __repr__(self):
5949 
    L = ['%s=%r' % (key, value)
5950 
      for key, value in self.__dict__.iteritems()]
5951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5952 
 
5953 
  def __eq__(self, other):
5954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5955 
 
5956 
  def __ne__(self, other):
5957 
    return not (self == other)
5958 
 
5944 mandeep.dh 5959 
class getItemStatusDescription_args:
5960 
  """
5961 
  Attributes:
5962 
   - itemId
5963 
  """
5964 
 
5965 
  thrift_spec = (
5966 
    None, # 0
5967 
    (1, TType.I64, 'itemId', None, None, ), # 1
5968 
  )
5969 
 
5970 
  def __init__(self, itemId=None,):
5971 
    self.itemId = itemId
5972 
 
5973 
  def read(self, iprot):
5974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5976 
      return
5977 
    iprot.readStructBegin()
5978 
    while True:
5979 
      (fname, ftype, fid) = iprot.readFieldBegin()
5980 
      if ftype == TType.STOP:
5981 
        break
5982 
      if fid == 1:
5983 
        if ftype == TType.I64:
5984 
          self.itemId = iprot.readI64();
5985 
        else:
5986 
          iprot.skip(ftype)
5987 
      else:
5988 
        iprot.skip(ftype)
5989 
      iprot.readFieldEnd()
5990 
    iprot.readStructEnd()
5991 
 
5992 
  def write(self, oprot):
5993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5995 
      return
5996 
    oprot.writeStructBegin('getItemStatusDescription_args')
5997 
    if self.itemId is not None:
5998 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5999 
      oprot.writeI64(self.itemId)
6000 
      oprot.writeFieldEnd()
6001 
    oprot.writeFieldStop()
6002 
    oprot.writeStructEnd()
6003 
 
6004 
  def validate(self):
6005 
    return
6006 
 
6007 
 
6008 
  def __repr__(self):
6009 
    L = ['%s=%r' % (key, value)
6010 
      for key, value in self.__dict__.iteritems()]
6011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6012 
 
6013 
  def __eq__(self, other):
6014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6015 
 
6016 
  def __ne__(self, other):
6017 
    return not (self == other)
6018 
 
6019 
class getItemStatusDescription_result:
6020 
  """
6021 
  Attributes:
6022 
   - success
6023 
   - isex
6024 
  """
6025 
 
6026 
  thrift_spec = (
6027 
    (0, TType.STRING, 'success', None, None, ), # 0
6028 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6029 
  )
6030 
 
6031 
  def __init__(self, success=None, isex=None,):
6032 
    self.success = success
6033 
    self.isex = isex
6034 
 
6035 
  def read(self, iprot):
6036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6038 
      return
6039 
    iprot.readStructBegin()
6040 
    while True:
6041 
      (fname, ftype, fid) = iprot.readFieldBegin()
6042 
      if ftype == TType.STOP:
6043 
        break
6044 
      if fid == 0:
6045 
        if ftype == TType.STRING:
6046 
          self.success = iprot.readString();
6047 
        else:
6048 
          iprot.skip(ftype)
6049 
      elif fid == 1:
6050 
        if ftype == TType.STRUCT:
6051 
          self.isex = CatalogServiceException()
6052 
          self.isex.read(iprot)
6053 
        else:
6054 
          iprot.skip(ftype)
6055 
      else:
6056 
        iprot.skip(ftype)
6057 
      iprot.readFieldEnd()
6058 
    iprot.readStructEnd()
6059 
 
6060 
  def write(self, oprot):
6061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6063 
      return
6064 
    oprot.writeStructBegin('getItemStatusDescription_result')
6065 
    if self.success is not None:
6066 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6067 
      oprot.writeString(self.success)
6068 
      oprot.writeFieldEnd()
6069 
    if self.isex is not None:
6070 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6071 
      self.isex.write(oprot)
6072 
      oprot.writeFieldEnd()
6073 
    oprot.writeFieldStop()
6074 
    oprot.writeStructEnd()
6075 
 
6076 
  def validate(self):
6077 
    return
6078 
 
6079 
 
6080 
  def __repr__(self):
6081 
    L = ['%s=%r' % (key, value)
6082 
      for key, value in self.__dict__.iteritems()]
6083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6084 
 
6085 
  def __eq__(self, other):
6086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6087 
 
6088 
  def __ne__(self, other):
6089 
    return not (self == other)
6090 
 
6091 
class startItemOn_args:
6092 
  """
6093 
  Attributes:
6094 
   - item_id
6095 
   - timestamp
6096 
  """
6097 
 
6098 
  thrift_spec = (
6099 
    None, # 0
6100 
    (1, TType.I64, 'item_id', None, None, ), # 1
6101 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6102 
  )
6103 
 
6104 
  def __init__(self, item_id=None, timestamp=None,):
6105 
    self.item_id = item_id
6106 
    self.timestamp = timestamp
6107 
 
6108 
  def read(self, iprot):
6109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6111 
      return
6112 
    iprot.readStructBegin()
6113 
    while True:
6114 
      (fname, ftype, fid) = iprot.readFieldBegin()
6115 
      if ftype == TType.STOP:
6116 
        break
6117 
      if fid == 1:
6118 
        if ftype == TType.I64:
6119 
          self.item_id = iprot.readI64();
6120 
        else:
6121 
          iprot.skip(ftype)
6122 
      elif fid == 2:
6123 
        if ftype == TType.I64:
6124 
          self.timestamp = iprot.readI64();
6125 
        else:
6126 
          iprot.skip(ftype)
6127 
      else:
6128 
        iprot.skip(ftype)
6129 
      iprot.readFieldEnd()
6130 
    iprot.readStructEnd()
6131 
 
6132 
  def write(self, oprot):
6133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6135 
      return
6136 
    oprot.writeStructBegin('startItemOn_args')
6137 
    if self.item_id is not None:
6138 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6139 
      oprot.writeI64(self.item_id)
6140 
      oprot.writeFieldEnd()
6141 
    if self.timestamp is not None:
6142 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6143 
      oprot.writeI64(self.timestamp)
6144 
      oprot.writeFieldEnd()
6145 
    oprot.writeFieldStop()
6146 
    oprot.writeStructEnd()
6147 
 
6148 
  def validate(self):
6149 
    return
6150 
 
6151 
 
6152 
  def __repr__(self):
6153 
    L = ['%s=%r' % (key, value)
6154 
      for key, value in self.__dict__.iteritems()]
6155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6156 
 
6157 
  def __eq__(self, other):
6158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6159 
 
6160 
  def __ne__(self, other):
6161 
    return not (self == other)
6162 
 
6163 
class startItemOn_result:
6164 
  """
6165 
  Attributes:
6166 
   - cex
6167 
  """
6168 
 
6169 
  thrift_spec = (
6170 
    None, # 0
6171 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6172 
  )
6173 
 
6174 
  def __init__(self, cex=None,):
6175 
    self.cex = cex
6176 
 
6177 
  def read(self, iprot):
6178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6180 
      return
6181 
    iprot.readStructBegin()
6182 
    while True:
6183 
      (fname, ftype, fid) = iprot.readFieldBegin()
6184 
      if ftype == TType.STOP:
6185 
        break
6186 
      if fid == 1:
6187 
        if ftype == TType.STRUCT:
6188 
          self.cex = CatalogServiceException()
6189 
          self.cex.read(iprot)
6190 
        else:
6191 
          iprot.skip(ftype)
6192 
      else:
6193 
        iprot.skip(ftype)
6194 
      iprot.readFieldEnd()
6195 
    iprot.readStructEnd()
6196 
 
6197 
  def write(self, oprot):
6198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6200 
      return
6201 
    oprot.writeStructBegin('startItemOn_result')
6202 
    if self.cex is not None:
6203 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6204 
      self.cex.write(oprot)
6205 
      oprot.writeFieldEnd()
6206 
    oprot.writeFieldStop()
6207 
    oprot.writeStructEnd()
6208 
 
6209 
  def validate(self):
6210 
    return
6211 
 
6212 
 
6213 
  def __repr__(self):
6214 
    L = ['%s=%r' % (key, value)
6215 
      for key, value in self.__dict__.iteritems()]
6216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6217 
 
6218 
  def __eq__(self, other):
6219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6220 
 
6221 
  def __ne__(self, other):
6222 
    return not (self == other)
6223 
 
6224 
class retireItemOn_args:
6225 
  """
6226 
  Attributes:
6227 
   - item_id
6228 
   - timestamp
6229 
  """
6230 
 
6231 
  thrift_spec = (
6232 
    None, # 0
6233 
    (1, TType.I64, 'item_id', None, None, ), # 1
6234 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6235 
  )
6236 
 
6237 
  def __init__(self, item_id=None, timestamp=None,):
6238 
    self.item_id = item_id
6239 
    self.timestamp = timestamp
6240 
 
6241 
  def read(self, iprot):
6242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6244 
      return
6245 
    iprot.readStructBegin()
6246 
    while True:
6247 
      (fname, ftype, fid) = iprot.readFieldBegin()
6248 
      if ftype == TType.STOP:
6249 
        break
6250 
      if fid == 1:
6251 
        if ftype == TType.I64:
6252 
          self.item_id = iprot.readI64();
6253 
        else:
6254 
          iprot.skip(ftype)
6255 
      elif fid == 2:
6256 
        if ftype == TType.I64:
6257 
          self.timestamp = iprot.readI64();
6258 
        else:
6259 
          iprot.skip(ftype)
6260 
      else:
6261 
        iprot.skip(ftype)
6262 
      iprot.readFieldEnd()
6263 
    iprot.readStructEnd()
6264 
 
6265 
  def write(self, oprot):
6266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6268 
      return
6269 
    oprot.writeStructBegin('retireItemOn_args')
6270 
    if self.item_id is not None:
6271 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6272 
      oprot.writeI64(self.item_id)
6273 
      oprot.writeFieldEnd()
6274 
    if self.timestamp is not None:
6275 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6276 
      oprot.writeI64(self.timestamp)
6277 
      oprot.writeFieldEnd()
6278 
    oprot.writeFieldStop()
6279 
    oprot.writeStructEnd()
6280 
 
6281 
  def validate(self):
6282 
    return
6283 
 
6284 
 
6285 
  def __repr__(self):
6286 
    L = ['%s=%r' % (key, value)
6287 
      for key, value in self.__dict__.iteritems()]
6288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6289 
 
6290 
  def __eq__(self, other):
6291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6292 
 
6293 
  def __ne__(self, other):
6294 
    return not (self == other)
6295 
 
6296 
class retireItemOn_result:
6297 
  """
6298 
  Attributes:
6299 
   - cex
6300 
  """
6301 
 
6302 
  thrift_spec = (
6303 
    None, # 0
6304 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6305 
  )
6306 
 
6307 
  def __init__(self, cex=None,):
6308 
    self.cex = cex
6309 
 
6310 
  def read(self, iprot):
6311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6313 
      return
6314 
    iprot.readStructBegin()
6315 
    while True:
6316 
      (fname, ftype, fid) = iprot.readFieldBegin()
6317 
      if ftype == TType.STOP:
6318 
        break
6319 
      if fid == 1:
6320 
        if ftype == TType.STRUCT:
6321 
          self.cex = CatalogServiceException()
6322 
          self.cex.read(iprot)
6323 
        else:
6324 
          iprot.skip(ftype)
6325 
      else:
6326 
        iprot.skip(ftype)
6327 
      iprot.readFieldEnd()
6328 
    iprot.readStructEnd()
6329 
 
6330 
  def write(self, oprot):
6331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6333 
      return
6334 
    oprot.writeStructBegin('retireItemOn_result')
6335 
    if self.cex is not None:
6336 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6337 
      self.cex.write(oprot)
6338 
      oprot.writeFieldEnd()
6339 
    oprot.writeFieldStop()
6340 
    oprot.writeStructEnd()
6341 
 
6342 
  def validate(self):
6343 
    return
6344 
 
6345 
 
6346 
  def __repr__(self):
6347 
    L = ['%s=%r' % (key, value)
6348 
      for key, value in self.__dict__.iteritems()]
6349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6350 
 
6351 
  def __eq__(self, other):
6352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6353 
 
6354 
  def __ne__(self, other):
6355 
    return not (self == other)
6356 
 
6357 
class changeItemStatus_args:
6358 
  """
6359 
  Attributes:
6360 
   - item_id
6361 
   - timestamp
6362 
   - newstatus
6363 
  """
6364 
 
6365 
  thrift_spec = (
6366 
    None, # 0
6367 
    (1, TType.I64, 'item_id', None, None, ), # 1
6368 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6369 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6370 
  )
6371 
 
6372 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6373 
    self.item_id = item_id
6374 
    self.timestamp = timestamp
6375 
    self.newstatus = newstatus
6376 
 
6377 
  def read(self, iprot):
6378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6380 
      return
6381 
    iprot.readStructBegin()
6382 
    while True:
6383 
      (fname, ftype, fid) = iprot.readFieldBegin()
6384 
      if ftype == TType.STOP:
6385 
        break
6386 
      if fid == 1:
6387 
        if ftype == TType.I64:
6388 
          self.item_id = iprot.readI64();
6389 
        else:
6390 
          iprot.skip(ftype)
6391 
      elif fid == 2:
6392 
        if ftype == TType.I64:
6393 
          self.timestamp = iprot.readI64();
6394 
        else:
6395 
          iprot.skip(ftype)
6396 
      elif fid == 3:
6397 
        if ftype == TType.I32:
6398 
          self.newstatus = iprot.readI32();
6399 
        else:
6400 
          iprot.skip(ftype)
6401 
      else:
6402 
        iprot.skip(ftype)
6403 
      iprot.readFieldEnd()
6404 
    iprot.readStructEnd()
6405 
 
6406 
  def write(self, oprot):
6407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6409 
      return
6410 
    oprot.writeStructBegin('changeItemStatus_args')
6411 
    if self.item_id is not None:
6412 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6413 
      oprot.writeI64(self.item_id)
6414 
      oprot.writeFieldEnd()
6415 
    if self.timestamp is not None:
6416 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6417 
      oprot.writeI64(self.timestamp)
6418 
      oprot.writeFieldEnd()
6419 
    if self.newstatus is not None:
6420 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6421 
      oprot.writeI32(self.newstatus)
6422 
      oprot.writeFieldEnd()
6423 
    oprot.writeFieldStop()
6424 
    oprot.writeStructEnd()
6425 
 
6426 
  def validate(self):
6427 
    return
6428 
 
6429 
 
6430 
  def __repr__(self):
6431 
    L = ['%s=%r' % (key, value)
6432 
      for key, value in self.__dict__.iteritems()]
6433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6434 
 
6435 
  def __eq__(self, other):
6436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6437 
 
6438 
  def __ne__(self, other):
6439 
    return not (self == other)
6440 
 
6441 
class changeItemStatus_result:
6442 
  """
6443 
  Attributes:
6444 
   - cex
6445 
  """
6446 
 
6447 
  thrift_spec = (
6448 
    None, # 0
6449 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6450 
  )
6451 
 
6452 
  def __init__(self, cex=None,):
6453 
    self.cex = cex
6454 
 
6455 
  def read(self, iprot):
6456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6458 
      return
6459 
    iprot.readStructBegin()
6460 
    while True:
6461 
      (fname, ftype, fid) = iprot.readFieldBegin()
6462 
      if ftype == TType.STOP:
6463 
        break
6464 
      if fid == 1:
6465 
        if ftype == TType.STRUCT:
6466 
          self.cex = CatalogServiceException()
6467 
          self.cex.read(iprot)
6468 
        else:
6469 
          iprot.skip(ftype)
6470 
      else:
6471 
        iprot.skip(ftype)
6472 
      iprot.readFieldEnd()
6473 
    iprot.readStructEnd()
6474 
 
6475 
  def write(self, oprot):
6476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6478 
      return
6479 
    oprot.writeStructBegin('changeItemStatus_result')
6480 
    if self.cex is not None:
6481 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6482 
      self.cex.write(oprot)
6483 
      oprot.writeFieldEnd()
6484 
    oprot.writeFieldStop()
6485 
    oprot.writeStructEnd()
6486 
 
6487 
  def validate(self):
6488 
    return
6489 
 
6490 
 
6491 
  def __repr__(self):
6492 
    L = ['%s=%r' % (key, value)
6493 
      for key, value in self.__dict__.iteritems()]
6494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6495 
 
6496 
  def __eq__(self, other):
6497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6498 
 
6499 
  def __ne__(self, other):
6500 
    return not (self == other)
6501 
 
6502 
class getItem_args:
6503 
  """
6504 
  Attributes:
6505 
   - item_id
6506 
  """
6507 
 
6508 
  thrift_spec = (
6509 
    None, # 0
6510 
    (1, TType.I64, 'item_id', None, None, ), # 1
6511 
  )
6512 
 
6513 
  def __init__(self, item_id=None,):
6514 
    self.item_id = item_id
6515 
 
6516 
  def read(self, iprot):
6517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6519 
      return
6520 
    iprot.readStructBegin()
6521 
    while True:
6522 
      (fname, ftype, fid) = iprot.readFieldBegin()
6523 
      if ftype == TType.STOP:
6524 
        break
6525 
      if fid == 1:
6526 
        if ftype == TType.I64:
6527 
          self.item_id = iprot.readI64();
6528 
        else:
6529 
          iprot.skip(ftype)
6530 
      else:
6531 
        iprot.skip(ftype)
6532 
      iprot.readFieldEnd()
6533 
    iprot.readStructEnd()
6534 
 
6535 
  def write(self, oprot):
6536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6538 
      return
6539 
    oprot.writeStructBegin('getItem_args')
6540 
    if self.item_id is not None:
6541 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6542 
      oprot.writeI64(self.item_id)
6543 
      oprot.writeFieldEnd()
6544 
    oprot.writeFieldStop()
6545 
    oprot.writeStructEnd()
6546 
 
6547 
  def validate(self):
6548 
    return
6549 
 
6550 
 
6551 
  def __repr__(self):
6552 
    L = ['%s=%r' % (key, value)
6553 
      for key, value in self.__dict__.iteritems()]
6554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6555 
 
6556 
  def __eq__(self, other):
6557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6558 
 
6559 
  def __ne__(self, other):
6560 
    return not (self == other)
6561 
 
6562 
class getItem_result:
6563 
  """
6564 
  Attributes:
6565 
   - success
6566 
   - cex
6567 
  """
6568 
 
6569 
  thrift_spec = (
6570 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6571 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6572 
  )
6573 
 
6574 
  def __init__(self, success=None, cex=None,):
6575 
    self.success = success
6576 
    self.cex = cex
6577 
 
6578 
  def read(self, iprot):
6579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6581 
      return
6582 
    iprot.readStructBegin()
6583 
    while True:
6584 
      (fname, ftype, fid) = iprot.readFieldBegin()
6585 
      if ftype == TType.STOP:
6586 
        break
6587 
      if fid == 0:
6588 
        if ftype == TType.STRUCT:
6589 
          self.success = Item()
6590 
          self.success.read(iprot)
6591 
        else:
6592 
          iprot.skip(ftype)
6593 
      elif fid == 1:
6594 
        if ftype == TType.STRUCT:
6595 
          self.cex = CatalogServiceException()
6596 
          self.cex.read(iprot)
6597 
        else:
6598 
          iprot.skip(ftype)
6599 
      else:
6600 
        iprot.skip(ftype)
6601 
      iprot.readFieldEnd()
6602 
    iprot.readStructEnd()
6603 
 
6604 
  def write(self, oprot):
6605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6607 
      return
6608 
    oprot.writeStructBegin('getItem_result')
6609 
    if self.success is not None:
6610 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6611 
      self.success.write(oprot)
6612 
      oprot.writeFieldEnd()
6613 
    if self.cex is not None:
6614 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6615 
      self.cex.write(oprot)
6616 
      oprot.writeFieldEnd()
6617 
    oprot.writeFieldStop()
6618 
    oprot.writeStructEnd()
6619 
 
6620 
  def validate(self):
6621 
    return
6622 
 
6623 
 
6624 
  def __repr__(self):
6625 
    L = ['%s=%r' % (key, value)
6626 
      for key, value in self.__dict__.iteritems()]
6627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6628 
 
6629 
  def __eq__(self, other):
6630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6631 
 
6632 
  def __ne__(self, other):
6633 
    return not (self == other)
6634 
 
6635 
class getItemsByCatalogId_args:
6636 
  """
6637 
  Attributes:
6638 
   - catalog_item_id
6639 
  """
6640 
 
6641 
  thrift_spec = (
6642 
    None, # 0
6643 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6644 
  )
6645 
 
6646 
  def __init__(self, catalog_item_id=None,):
6647 
    self.catalog_item_id = catalog_item_id
6648 
 
6649 
  def read(self, iprot):
6650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6652 
      return
6653 
    iprot.readStructBegin()
6654 
    while True:
6655 
      (fname, ftype, fid) = iprot.readFieldBegin()
6656 
      if ftype == TType.STOP:
6657 
        break
6658 
      if fid == 1:
6659 
        if ftype == TType.I64:
6660 
          self.catalog_item_id = iprot.readI64();
6661 
        else:
6662 
          iprot.skip(ftype)
6663 
      else:
6664 
        iprot.skip(ftype)
6665 
      iprot.readFieldEnd()
6666 
    iprot.readStructEnd()
6667 
 
6668 
  def write(self, oprot):
6669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6671 
      return
6672 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6673 
    if self.catalog_item_id is not None:
6674 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6675 
      oprot.writeI64(self.catalog_item_id)
6676 
      oprot.writeFieldEnd()
6677 
    oprot.writeFieldStop()
6678 
    oprot.writeStructEnd()
6679 
 
6680 
  def validate(self):
6681 
    return
6682 
 
6683 
 
6684 
  def __repr__(self):
6685 
    L = ['%s=%r' % (key, value)
6686 
      for key, value in self.__dict__.iteritems()]
6687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6688 
 
6689 
  def __eq__(self, other):
6690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6691 
 
6692 
  def __ne__(self, other):
6693 
    return not (self == other)
6694 
 
6695 
class getItemsByCatalogId_result:
6696 
  """
6697 
  Attributes:
6698 
   - success
6699 
   - cex
6700 
  """
6701 
 
6702 
  thrift_spec = (
6703 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6704 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6705 
  )
6706 
 
6707 
  def __init__(self, success=None, cex=None,):
6708 
    self.success = success
6709 
    self.cex = cex
6710 
 
6711 
  def read(self, iprot):
6712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6714 
      return
6715 
    iprot.readStructBegin()
6716 
    while True:
6717 
      (fname, ftype, fid) = iprot.readFieldBegin()
6718 
      if ftype == TType.STOP:
6719 
        break
6720 
      if fid == 0:
6721 
        if ftype == TType.LIST:
6722 
          self.success = []
7438 amit.gupta 6723 
          (_etype35, _size32) = iprot.readListBegin()
6724 
          for _i36 in xrange(_size32):
6725 
            _elem37 = Item()
6726 
            _elem37.read(iprot)
6727 
            self.success.append(_elem37)
5944 mandeep.dh 6728 
          iprot.readListEnd()
6729 
        else:
6730 
          iprot.skip(ftype)
6731 
      elif fid == 1:
6732 
        if ftype == TType.STRUCT:
6733 
          self.cex = CatalogServiceException()
6734 
          self.cex.read(iprot)
6735 
        else:
6736 
          iprot.skip(ftype)
6737 
      else:
6738 
        iprot.skip(ftype)
6739 
      iprot.readFieldEnd()
6740 
    iprot.readStructEnd()
6741 
 
6742 
  def write(self, oprot):
6743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6745 
      return
6746 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6747 
    if self.success is not None:
6748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6749 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6750 
      for iter38 in self.success:
6751 
        iter38.write(oprot)
5944 mandeep.dh 6752 
      oprot.writeListEnd()
6753 
      oprot.writeFieldEnd()
6754 
    if self.cex is not None:
6755 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6756 
      self.cex.write(oprot)
6757 
      oprot.writeFieldEnd()
6758 
    oprot.writeFieldStop()
6759 
    oprot.writeStructEnd()
6760 
 
6761 
  def validate(self):
6762 
    return
6763 
 
6764 
 
6765 
  def __repr__(self):
6766 
    L = ['%s=%r' % (key, value)
6767 
      for key, value in self.__dict__.iteritems()]
6768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6769 
 
6770 
  def __eq__(self, other):
6771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6772 
 
6773 
  def __ne__(self, other):
6774 
    return not (self == other)
6775 
 
6776 
class getValidItemsByCatalogId_args:
6777 
  """
6778 
  Attributes:
6779 
   - catalog_item_id
6780 
  """
6781 
 
6782 
  thrift_spec = (
6783 
    None, # 0
6784 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6785 
  )
6786 
 
6787 
  def __init__(self, catalog_item_id=None,):
6788 
    self.catalog_item_id = catalog_item_id
6789 
 
6790 
  def read(self, iprot):
6791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6793 
      return
6794 
    iprot.readStructBegin()
6795 
    while True:
6796 
      (fname, ftype, fid) = iprot.readFieldBegin()
6797 
      if ftype == TType.STOP:
6798 
        break
6799 
      if fid == 1:
6800 
        if ftype == TType.I64:
6801 
          self.catalog_item_id = iprot.readI64();
6802 
        else:
6803 
          iprot.skip(ftype)
6804 
      else:
6805 
        iprot.skip(ftype)
6806 
      iprot.readFieldEnd()
6807 
    iprot.readStructEnd()
6808 
 
6809 
  def write(self, oprot):
6810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6812 
      return
6813 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6814 
    if self.catalog_item_id is not None:
6815 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6816 
      oprot.writeI64(self.catalog_item_id)
6817 
      oprot.writeFieldEnd()
6818 
    oprot.writeFieldStop()
6819 
    oprot.writeStructEnd()
6820 
 
6821 
  def validate(self):
6822 
    return
6823 
 
6824 
 
6825 
  def __repr__(self):
6826 
    L = ['%s=%r' % (key, value)
6827 
      for key, value in self.__dict__.iteritems()]
6828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6829 
 
6830 
  def __eq__(self, other):
6831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6832 
 
6833 
  def __ne__(self, other):
6834 
    return not (self == other)
6835 
 
6836 
class getValidItemsByCatalogId_result:
6837 
  """
6838 
  Attributes:
6839 
   - success
6840 
   - cex
6841 
  """
6842 
 
6843 
  thrift_spec = (
6844 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6845 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6846 
  )
6847 
 
6848 
  def __init__(self, success=None, cex=None,):
6849 
    self.success = success
6850 
    self.cex = cex
6851 
 
6852 
  def read(self, iprot):
6853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6855 
      return
6856 
    iprot.readStructBegin()
6857 
    while True:
6858 
      (fname, ftype, fid) = iprot.readFieldBegin()
6859 
      if ftype == TType.STOP:
6860 
        break
6861 
      if fid == 0:
6862 
        if ftype == TType.LIST:
6863 
          self.success = []
7438 amit.gupta 6864 
          (_etype42, _size39) = iprot.readListBegin()
6865 
          for _i43 in xrange(_size39):
6866 
            _elem44 = Item()
6867 
            _elem44.read(iprot)
6868 
            self.success.append(_elem44)
5944 mandeep.dh 6869 
          iprot.readListEnd()
6870 
        else:
6871 
          iprot.skip(ftype)
6872 
      elif fid == 1:
6873 
        if ftype == TType.STRUCT:
6874 
          self.cex = CatalogServiceException()
6875 
          self.cex.read(iprot)
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      else:
6879 
        iprot.skip(ftype)
6880 
      iprot.readFieldEnd()
6881 
    iprot.readStructEnd()
6882 
 
6883 
  def write(self, oprot):
6884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6886 
      return
6887 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6888 
    if self.success is not None:
6889 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6890 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6891 
      for iter45 in self.success:
6892 
        iter45.write(oprot)
5944 mandeep.dh 6893 
      oprot.writeListEnd()
6894 
      oprot.writeFieldEnd()
6895 
    if self.cex is not None:
6896 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6897 
      self.cex.write(oprot)
6898 
      oprot.writeFieldEnd()
6899 
    oprot.writeFieldStop()
6900 
    oprot.writeStructEnd()
6901 
 
6902 
  def validate(self):
6903 
    return
6904 
 
6905 
 
6906 
  def __repr__(self):
6907 
    L = ['%s=%r' % (key, value)
6908 
      for key, value in self.__dict__.iteritems()]
6909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6910 
 
6911 
  def __eq__(self, other):
6912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6913 
 
6914 
  def __ne__(self, other):
6915 
    return not (self == other)
6916 
 
6917 
class getAllItems_args:
6918 
  """
6919 
  Attributes:
6920 
   - isActive
6921 
  """
6922 
 
6923 
  thrift_spec = (
6924 
    None, # 0
6925 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6926 
  )
6927 
 
6928 
  def __init__(self, isActive=None,):
6929 
    self.isActive = isActive
6930 
 
6931 
  def read(self, iprot):
6932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6934 
      return
6935 
    iprot.readStructBegin()
6936 
    while True:
6937 
      (fname, ftype, fid) = iprot.readFieldBegin()
6938 
      if ftype == TType.STOP:
6939 
        break
6940 
      if fid == 1:
6941 
        if ftype == TType.BOOL:
6942 
          self.isActive = iprot.readBool();
6943 
        else:
6944 
          iprot.skip(ftype)
6945 
      else:
6946 
        iprot.skip(ftype)
6947 
      iprot.readFieldEnd()
6948 
    iprot.readStructEnd()
6949 
 
6950 
  def write(self, oprot):
6951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6953 
      return
6954 
    oprot.writeStructBegin('getAllItems_args')
6955 
    if self.isActive is not None:
6956 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6957 
      oprot.writeBool(self.isActive)
6958 
      oprot.writeFieldEnd()
6959 
    oprot.writeFieldStop()
6960 
    oprot.writeStructEnd()
6961 
 
6962 
  def validate(self):
6963 
    return
6964 
 
6965 
 
6966 
  def __repr__(self):
6967 
    L = ['%s=%r' % (key, value)
6968 
      for key, value in self.__dict__.iteritems()]
6969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6970 
 
6971 
  def __eq__(self, other):
6972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6973 
 
6974 
  def __ne__(self, other):
6975 
    return not (self == other)
6976 
 
6977 
class getAllItems_result:
6978 
  """
6979 
  Attributes:
6980 
   - success
6981 
   - cex
6982 
  """
6983 
 
6984 
  thrift_spec = (
6985 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6986 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6987 
  )
6988 
 
6989 
  def __init__(self, success=None, cex=None,):
6990 
    self.success = success
6991 
    self.cex = cex
6992 
 
6993 
  def read(self, iprot):
6994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6996 
      return
6997 
    iprot.readStructBegin()
6998 
    while True:
6999 
      (fname, ftype, fid) = iprot.readFieldBegin()
7000 
      if ftype == TType.STOP:
7001 
        break
7002 
      if fid == 0:
7003 
        if ftype == TType.LIST:
7004 
          self.success = []
7438 amit.gupta 7005 
          (_etype49, _size46) = iprot.readListBegin()
7006 
          for _i50 in xrange(_size46):
7007 
            _elem51 = Item()
7008 
            _elem51.read(iprot)
7009 
            self.success.append(_elem51)
5944 mandeep.dh 7010 
          iprot.readListEnd()
7011 
        else:
7012 
          iprot.skip(ftype)
7013 
      elif fid == 1:
7014 
        if ftype == TType.STRUCT:
7015 
          self.cex = CatalogServiceException()
7016 
          self.cex.read(iprot)
7017 
        else:
7018 
          iprot.skip(ftype)
7019 
      else:
7020 
        iprot.skip(ftype)
7021 
      iprot.readFieldEnd()
7022 
    iprot.readStructEnd()
7023 
 
7024 
  def write(self, oprot):
7025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7027 
      return
7028 
    oprot.writeStructBegin('getAllItems_result')
7029 
    if self.success is not None:
7030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7032 
      for iter52 in self.success:
7033 
        iter52.write(oprot)
5944 mandeep.dh 7034 
      oprot.writeListEnd()
7035 
      oprot.writeFieldEnd()
7036 
    if self.cex is not None:
7037 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7038 
      self.cex.write(oprot)
7039 
      oprot.writeFieldEnd()
7040 
    oprot.writeFieldStop()
7041 
    oprot.writeStructEnd()
7042 
 
7043 
  def validate(self):
7044 
    return
7045 
 
7046 
 
7047 
  def __repr__(self):
7048 
    L = ['%s=%r' % (key, value)
7049 
      for key, value in self.__dict__.iteritems()]
7050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7051 
 
7052 
  def __eq__(self, other):
7053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7054 
 
7055 
  def __ne__(self, other):
7056 
    return not (self == other)
7057 
 
7058 
class getAllItemsByStatus_args:
7059 
  """
7060 
  Attributes:
7061 
   - itemStatus
7062 
  """
7063 
 
7064 
  thrift_spec = (
7065 
    None, # 0
7066 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7067 
  )
7068 
 
7069 
  def __init__(self, itemStatus=None,):
7070 
    self.itemStatus = itemStatus
7071 
 
7072 
  def read(self, iprot):
7073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7075 
      return
7076 
    iprot.readStructBegin()
7077 
    while True:
7078 
      (fname, ftype, fid) = iprot.readFieldBegin()
7079 
      if ftype == TType.STOP:
7080 
        break
7081 
      if fid == 1:
7082 
        if ftype == TType.I32:
7083 
          self.itemStatus = iprot.readI32();
7084 
        else:
7085 
          iprot.skip(ftype)
7086 
      else:
7087 
        iprot.skip(ftype)
7088 
      iprot.readFieldEnd()
7089 
    iprot.readStructEnd()
7090 
 
7091 
  def write(self, oprot):
7092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7094 
      return
7095 
    oprot.writeStructBegin('getAllItemsByStatus_args')
7096 
    if self.itemStatus is not None:
7097 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7098 
      oprot.writeI32(self.itemStatus)
7099 
      oprot.writeFieldEnd()
7100 
    oprot.writeFieldStop()
7101 
    oprot.writeStructEnd()
7102 
 
7103 
  def validate(self):
7104 
    return
7105 
 
7106 
 
7107 
  def __repr__(self):
7108 
    L = ['%s=%r' % (key, value)
7109 
      for key, value in self.__dict__.iteritems()]
7110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7111 
 
7112 
  def __eq__(self, other):
7113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7114 
 
7115 
  def __ne__(self, other):
7116 
    return not (self == other)
7117 
 
7118 
class getAllItemsByStatus_result:
7119 
  """
7120 
  Attributes:
7121 
   - success
7122 
   - cex
7123 
  """
7124 
 
7125 
  thrift_spec = (
7126 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7127 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7128 
  )
7129 
 
7130 
  def __init__(self, success=None, cex=None,):
7131 
    self.success = success
7132 
    self.cex = cex
7133 
 
7134 
  def read(self, iprot):
7135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7137 
      return
7138 
    iprot.readStructBegin()
7139 
    while True:
7140 
      (fname, ftype, fid) = iprot.readFieldBegin()
7141 
      if ftype == TType.STOP:
7142 
        break
7143 
      if fid == 0:
7144 
        if ftype == TType.LIST:
7145 
          self.success = []
7438 amit.gupta 7146 
          (_etype56, _size53) = iprot.readListBegin()
7147 
          for _i57 in xrange(_size53):
7148 
            _elem58 = Item()
7149 
            _elem58.read(iprot)
7150 
            self.success.append(_elem58)
5944 mandeep.dh 7151 
          iprot.readListEnd()
7152 
        else:
7153 
          iprot.skip(ftype)
7154 
      elif fid == 1:
7155 
        if ftype == TType.STRUCT:
7156 
          self.cex = CatalogServiceException()
7157 
          self.cex.read(iprot)
7158 
        else:
7159 
          iprot.skip(ftype)
7160 
      else:
7161 
        iprot.skip(ftype)
7162 
      iprot.readFieldEnd()
7163 
    iprot.readStructEnd()
7164 
 
7165 
  def write(self, oprot):
7166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7168 
      return
7169 
    oprot.writeStructBegin('getAllItemsByStatus_result')
7170 
    if self.success is not None:
7171 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7172 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7173 
      for iter59 in self.success:
7174 
        iter59.write(oprot)
5944 mandeep.dh 7175 
      oprot.writeListEnd()
7176 
      oprot.writeFieldEnd()
7177 
    if self.cex is not None:
7178 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7179 
      self.cex.write(oprot)
7180 
      oprot.writeFieldEnd()
7181 
    oprot.writeFieldStop()
7182 
    oprot.writeStructEnd()
7183 
 
7184 
  def validate(self):
7185 
    return
7186 
 
7187 
 
7188 
  def __repr__(self):
7189 
    L = ['%s=%r' % (key, value)
7190 
      for key, value in self.__dict__.iteritems()]
7191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7192 
 
7193 
  def __eq__(self, other):
7194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7195 
 
7196 
  def __ne__(self, other):
7197 
    return not (self == other)
7198 
 
7199 
class markItemAsContentComplete_args:
7200 
  """
7201 
  Attributes:
7202 
   - entityId
7203 
   - category
7204 
   - brand
7205 
   - modelName
7206 
   - modelNumber
7207 
  """
7208 
 
7209 
  thrift_spec = (
7210 
    None, # 0
7211 
    (1, TType.I64, 'entityId', None, None, ), # 1
7212 
    (2, TType.I64, 'category', None, None, ), # 2
7213 
    (3, TType.STRING, 'brand', None, None, ), # 3
7214 
    (4, TType.STRING, 'modelName', None, None, ), # 4
7215 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
7216 
  )
7217 
 
7218 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
7219 
    self.entityId = entityId
7220 
    self.category = category
7221 
    self.brand = brand
7222 
    self.modelName = modelName
7223 
    self.modelNumber = modelNumber
7224 
 
7225 
  def read(self, iprot):
7226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7228 
      return
7229 
    iprot.readStructBegin()
7230 
    while True:
7231 
      (fname, ftype, fid) = iprot.readFieldBegin()
7232 
      if ftype == TType.STOP:
7233 
        break
7234 
      if fid == 1:
7235 
        if ftype == TType.I64:
7236 
          self.entityId = iprot.readI64();
7237 
        else:
7238 
          iprot.skip(ftype)
7239 
      elif fid == 2:
7240 
        if ftype == TType.I64:
7241 
          self.category = iprot.readI64();
7242 
        else:
7243 
          iprot.skip(ftype)
7244 
      elif fid == 3:
7245 
        if ftype == TType.STRING:
7246 
          self.brand = iprot.readString();
7247 
        else:
7248 
          iprot.skip(ftype)
7249 
      elif fid == 4:
7250 
        if ftype == TType.STRING:
7251 
          self.modelName = iprot.readString();
7252 
        else:
7253 
          iprot.skip(ftype)
7254 
      elif fid == 5:
7255 
        if ftype == TType.STRING:
7256 
          self.modelNumber = iprot.readString();
7257 
        else:
7258 
          iprot.skip(ftype)
7259 
      else:
7260 
        iprot.skip(ftype)
7261 
      iprot.readFieldEnd()
7262 
    iprot.readStructEnd()
7263 
 
7264 
  def write(self, oprot):
7265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7267 
      return
7268 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7269 
    if self.entityId is not None:
7270 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7271 
      oprot.writeI64(self.entityId)
7272 
      oprot.writeFieldEnd()
7273 
    if self.category is not None:
7274 
      oprot.writeFieldBegin('category', TType.I64, 2)
7275 
      oprot.writeI64(self.category)
7276 
      oprot.writeFieldEnd()
7277 
    if self.brand is not None:
7278 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7279 
      oprot.writeString(self.brand)
7280 
      oprot.writeFieldEnd()
7281 
    if self.modelName is not None:
7282 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7283 
      oprot.writeString(self.modelName)
7284 
      oprot.writeFieldEnd()
7285 
    if self.modelNumber is not None:
7286 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7287 
      oprot.writeString(self.modelNumber)
7288 
      oprot.writeFieldEnd()
7289 
    oprot.writeFieldStop()
7290 
    oprot.writeStructEnd()
7291 
 
7292 
  def validate(self):
7293 
    return
7294 
 
7295 
 
7296 
  def __repr__(self):
7297 
    L = ['%s=%r' % (key, value)
7298 
      for key, value in self.__dict__.iteritems()]
7299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7300 
 
7301 
  def __eq__(self, other):
7302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7303 
 
7304 
  def __ne__(self, other):
7305 
    return not (self == other)
7306 
 
7307 
class markItemAsContentComplete_result:
7308 
  """
7309 
  Attributes:
7310 
   - success
7311 
   - cex
7312 
  """
7313 
 
7314 
  thrift_spec = (
7315 
    (0, TType.BOOL, 'success', None, None, ), # 0
7316 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7317 
  )
7318 
 
7319 
  def __init__(self, success=None, cex=None,):
7320 
    self.success = success
7321 
    self.cex = cex
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 == 0:
7333 
        if ftype == TType.BOOL:
7334 
          self.success = iprot.readBool();
7335 
        else:
7336 
          iprot.skip(ftype)
7337 
      elif fid == 1:
7338 
        if ftype == TType.STRUCT:
7339 
          self.cex = CatalogServiceException()
7340 
          self.cex.read(iprot)
7341 
        else:
7342 
          iprot.skip(ftype)
7343 
      else:
7344 
        iprot.skip(ftype)
7345 
      iprot.readFieldEnd()
7346 
    iprot.readStructEnd()
7347 
 
7348 
  def write(self, oprot):
7349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7351 
      return
7352 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7353 
    if self.success is not None:
7354 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7355 
      oprot.writeBool(self.success)
7356 
      oprot.writeFieldEnd()
7357 
    if self.cex is not None:
7358 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7359 
      self.cex.write(oprot)
7360 
      oprot.writeFieldEnd()
7361 
    oprot.writeFieldStop()
7362 
    oprot.writeStructEnd()
7363 
 
7364 
  def validate(self):
7365 
    return
7366 
 
7367 
 
7368 
  def __repr__(self):
7369 
    L = ['%s=%r' % (key, value)
7370 
      for key, value in self.__dict__.iteritems()]
7371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7372 
 
7373 
  def __eq__(self, other):
7374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7375 
 
7376 
  def __ne__(self, other):
7377 
    return not (self == other)
7378 
 
7379 
class getAllItemsInRange_args:
7380 
  """
7381 
  Attributes:
7382 
   - offset
7383 
   - limit
7384 
  """
7385 
 
7386 
  thrift_spec = (
7387 
    None, # 0
7388 
    (1, TType.I64, 'offset', None, None, ), # 1
7389 
    (2, TType.I64, 'limit', None, None, ), # 2
7390 
  )
7391 
 
7392 
  def __init__(self, offset=None, limit=None,):
7393 
    self.offset = offset
7394 
    self.limit = limit
7395 
 
7396 
  def read(self, iprot):
7397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7399 
      return
7400 
    iprot.readStructBegin()
7401 
    while True:
7402 
      (fname, ftype, fid) = iprot.readFieldBegin()
7403 
      if ftype == TType.STOP:
7404 
        break
7405 
      if fid == 1:
7406 
        if ftype == TType.I64:
7407 
          self.offset = iprot.readI64();
7408 
        else:
7409 
          iprot.skip(ftype)
7410 
      elif fid == 2:
7411 
        if ftype == TType.I64:
7412 
          self.limit = iprot.readI64();
7413 
        else:
7414 
          iprot.skip(ftype)
7415 
      else:
7416 
        iprot.skip(ftype)
7417 
      iprot.readFieldEnd()
7418 
    iprot.readStructEnd()
7419 
 
7420 
  def write(self, oprot):
7421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7423 
      return
7424 
    oprot.writeStructBegin('getAllItemsInRange_args')
7425 
    if self.offset is not None:
7426 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7427 
      oprot.writeI64(self.offset)
7428 
      oprot.writeFieldEnd()
7429 
    if self.limit is not None:
7430 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7431 
      oprot.writeI64(self.limit)
7432 
      oprot.writeFieldEnd()
7433 
    oprot.writeFieldStop()
7434 
    oprot.writeStructEnd()
7435 
 
7436 
  def validate(self):
7437 
    return
7438 
 
7439 
 
7440 
  def __repr__(self):
7441 
    L = ['%s=%r' % (key, value)
7442 
      for key, value in self.__dict__.iteritems()]
7443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7444 
 
7445 
  def __eq__(self, other):
7446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7447 
 
7448 
  def __ne__(self, other):
7449 
    return not (self == other)
7450 
 
7451 
class getAllItemsInRange_result:
7452 
  """
7453 
  Attributes:
7454 
   - success
7455 
   - cex
7456 
  """
7457 
 
7458 
  thrift_spec = (
7459 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7460 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7461 
  )
7462 
 
7463 
  def __init__(self, success=None, cex=None,):
7464 
    self.success = success
7465 
    self.cex = cex
7466 
 
7467 
  def read(self, iprot):
7468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7470 
      return
7471 
    iprot.readStructBegin()
7472 
    while True:
7473 
      (fname, ftype, fid) = iprot.readFieldBegin()
7474 
      if ftype == TType.STOP:
7475 
        break
7476 
      if fid == 0:
7477 
        if ftype == TType.LIST:
7478 
          self.success = []
7438 amit.gupta 7479 
          (_etype63, _size60) = iprot.readListBegin()
7480 
          for _i64 in xrange(_size60):
7481 
            _elem65 = Item()
7482 
            _elem65.read(iprot)
7483 
            self.success.append(_elem65)
5944 mandeep.dh 7484 
          iprot.readListEnd()
7485 
        else:
7486 
          iprot.skip(ftype)
7487 
      elif fid == 1:
7488 
        if ftype == TType.STRUCT:
7489 
          self.cex = CatalogServiceException()
7490 
          self.cex.read(iprot)
7491 
        else:
7492 
          iprot.skip(ftype)
7493 
      else:
7494 
        iprot.skip(ftype)
7495 
      iprot.readFieldEnd()
7496 
    iprot.readStructEnd()
7497 
 
7498 
  def write(self, oprot):
7499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7501 
      return
7502 
    oprot.writeStructBegin('getAllItemsInRange_result')
7503 
    if self.success is not None:
7504 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7505 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7506 
      for iter66 in self.success:
7507 
        iter66.write(oprot)
5944 mandeep.dh 7508 
      oprot.writeListEnd()
7509 
      oprot.writeFieldEnd()
7510 
    if self.cex is not None:
7511 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7512 
      self.cex.write(oprot)
7513 
      oprot.writeFieldEnd()
7514 
    oprot.writeFieldStop()
7515 
    oprot.writeStructEnd()
7516 
 
7517 
  def validate(self):
7518 
    return
7519 
 
7520 
 
7521 
  def __repr__(self):
7522 
    L = ['%s=%r' % (key, value)
7523 
      for key, value in self.__dict__.iteritems()]
7524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7525 
 
7526 
  def __eq__(self, other):
7527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7528 
 
7529 
  def __ne__(self, other):
7530 
    return not (self == other)
7531 
 
7532 
class getAllItemsByStatusInRange_args:
7533 
  """
7534 
  Attributes:
7535 
   - itemStatus
7536 
   - offset
7537 
   - limit
7538 
  """
7539 
 
7540 
  thrift_spec = (
7541 
    None, # 0
7542 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7543 
    (2, TType.I64, 'offset', None, None, ), # 2
7544 
    (3, TType.I64, 'limit', None, None, ), # 3
7545 
  )
7546 
 
7547 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7548 
    self.itemStatus = itemStatus
7549 
    self.offset = offset
7550 
    self.limit = limit
7551 
 
7552 
  def read(self, iprot):
7553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7555 
      return
7556 
    iprot.readStructBegin()
7557 
    while True:
7558 
      (fname, ftype, fid) = iprot.readFieldBegin()
7559 
      if ftype == TType.STOP:
7560 
        break
7561 
      if fid == 1:
7562 
        if ftype == TType.I32:
7563 
          self.itemStatus = iprot.readI32();
7564 
        else:
7565 
          iprot.skip(ftype)
7566 
      elif fid == 2:
7567 
        if ftype == TType.I64:
7568 
          self.offset = iprot.readI64();
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      elif fid == 3:
7572 
        if ftype == TType.I64:
7573 
          self.limit = iprot.readI64();
7574 
        else:
7575 
          iprot.skip(ftype)
7576 
      else:
7577 
        iprot.skip(ftype)
7578 
      iprot.readFieldEnd()
7579 
    iprot.readStructEnd()
7580 
 
7581 
  def write(self, oprot):
7582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7584 
      return
7585 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7586 
    if self.itemStatus is not None:
7587 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7588 
      oprot.writeI32(self.itemStatus)
7589 
      oprot.writeFieldEnd()
7590 
    if self.offset is not None:
7591 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7592 
      oprot.writeI64(self.offset)
7593 
      oprot.writeFieldEnd()
7594 
    if self.limit is not None:
7595 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7596 
      oprot.writeI64(self.limit)
7597 
      oprot.writeFieldEnd()
7598 
    oprot.writeFieldStop()
7599 
    oprot.writeStructEnd()
7600 
 
7601 
  def validate(self):
7602 
    return
7603 
 
7604 
 
7605 
  def __repr__(self):
7606 
    L = ['%s=%r' % (key, value)
7607 
      for key, value in self.__dict__.iteritems()]
7608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7609 
 
7610 
  def __eq__(self, other):
7611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7612 
 
7613 
  def __ne__(self, other):
7614 
    return not (self == other)
7615 
 
7616 
class getAllItemsByStatusInRange_result:
7617 
  """
7618 
  Attributes:
7619 
   - success
7620 
   - cex
7621 
  """
7622 
 
7623 
  thrift_spec = (
7624 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7625 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7626 
  )
7627 
 
7628 
  def __init__(self, success=None, cex=None,):
7629 
    self.success = success
7630 
    self.cex = cex
7631 
 
7632 
  def read(self, iprot):
7633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7635 
      return
7636 
    iprot.readStructBegin()
7637 
    while True:
7638 
      (fname, ftype, fid) = iprot.readFieldBegin()
7639 
      if ftype == TType.STOP:
7640 
        break
7641 
      if fid == 0:
7642 
        if ftype == TType.LIST:
7643 
          self.success = []
7438 amit.gupta 7644 
          (_etype70, _size67) = iprot.readListBegin()
7645 
          for _i71 in xrange(_size67):
7646 
            _elem72 = Item()
7647 
            _elem72.read(iprot)
7648 
            self.success.append(_elem72)
5944 mandeep.dh 7649 
          iprot.readListEnd()
7650 
        else:
7651 
          iprot.skip(ftype)
7652 
      elif fid == 1:
7653 
        if ftype == TType.STRUCT:
7654 
          self.cex = CatalogServiceException()
7655 
          self.cex.read(iprot)
7656 
        else:
7657 
          iprot.skip(ftype)
7658 
      else:
7659 
        iprot.skip(ftype)
7660 
      iprot.readFieldEnd()
7661 
    iprot.readStructEnd()
7662 
 
7663 
  def write(self, oprot):
7664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7666 
      return
7667 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7668 
    if self.success is not None:
7669 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7670 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7671 
      for iter73 in self.success:
7672 
        iter73.write(oprot)
5944 mandeep.dh 7673 
      oprot.writeListEnd()
7674 
      oprot.writeFieldEnd()
7675 
    if self.cex is not None:
7676 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7677 
      self.cex.write(oprot)
7678 
      oprot.writeFieldEnd()
7679 
    oprot.writeFieldStop()
7680 
    oprot.writeStructEnd()
7681 
 
7682 
  def validate(self):
7683 
    return
7684 
 
7685 
 
7686 
  def __repr__(self):
7687 
    L = ['%s=%r' % (key, value)
7688 
      for key, value in self.__dict__.iteritems()]
7689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7690 
 
7691 
  def __eq__(self, other):
7692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7693 
 
7694 
  def __ne__(self, other):
7695 
    return not (self == other)
7696 
 
7697 
class getItemCountByStatus_args:
7698 
  """
7699 
  Attributes:
7700 
   - useStatus
7701 
   - itemStatus
7702 
  """
7703 
 
7704 
  thrift_spec = (
7705 
    None, # 0
7706 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7707 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7708 
  )
7709 
 
7710 
  def __init__(self, useStatus=None, itemStatus=None,):
7711 
    self.useStatus = useStatus
7712 
    self.itemStatus = itemStatus
7713 
 
7714 
  def read(self, iprot):
7715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7717 
      return
7718 
    iprot.readStructBegin()
7719 
    while True:
7720 
      (fname, ftype, fid) = iprot.readFieldBegin()
7721 
      if ftype == TType.STOP:
7722 
        break
7723 
      if fid == 1:
7724 
        if ftype == TType.BOOL:
7725 
          self.useStatus = iprot.readBool();
7726 
        else:
7727 
          iprot.skip(ftype)
7728 
      elif fid == 2:
7729 
        if ftype == TType.I32:
7730 
          self.itemStatus = iprot.readI32();
7731 
        else:
7732 
          iprot.skip(ftype)
7733 
      else:
7734 
        iprot.skip(ftype)
7735 
      iprot.readFieldEnd()
7736 
    iprot.readStructEnd()
7737 
 
7738 
  def write(self, oprot):
7739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7741 
      return
7742 
    oprot.writeStructBegin('getItemCountByStatus_args')
7743 
    if self.useStatus is not None:
7744 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7745 
      oprot.writeBool(self.useStatus)
7746 
      oprot.writeFieldEnd()
7747 
    if self.itemStatus is not None:
7748 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7749 
      oprot.writeI32(self.itemStatus)
7750 
      oprot.writeFieldEnd()
7751 
    oprot.writeFieldStop()
7752 
    oprot.writeStructEnd()
7753 
 
7754 
  def validate(self):
7755 
    return
7756 
 
7757 
 
7758 
  def __repr__(self):
7759 
    L = ['%s=%r' % (key, value)
7760 
      for key, value in self.__dict__.iteritems()]
7761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7762 
 
7763 
  def __eq__(self, other):
7764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7765 
 
7766 
  def __ne__(self, other):
7767 
    return not (self == other)
7768 
 
7769 
class getItemCountByStatus_result:
7770 
  """
7771 
  Attributes:
7772 
   - success
7773 
  """
7774 
 
7775 
  thrift_spec = (
7776 
    (0, TType.I32, 'success', None, None, ), # 0
7777 
  )
7778 
 
7779 
  def __init__(self, success=None,):
7780 
    self.success = success
7781 
 
7782 
  def read(self, iprot):
7783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7785 
      return
7786 
    iprot.readStructBegin()
7787 
    while True:
7788 
      (fname, ftype, fid) = iprot.readFieldBegin()
7789 
      if ftype == TType.STOP:
7790 
        break
7791 
      if fid == 0:
7792 
        if ftype == TType.I32:
7793 
          self.success = iprot.readI32();
7794 
        else:
7795 
          iprot.skip(ftype)
7796 
      else:
7797 
        iprot.skip(ftype)
7798 
      iprot.readFieldEnd()
7799 
    iprot.readStructEnd()
7800 
 
7801 
  def write(self, oprot):
7802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7804 
      return
7805 
    oprot.writeStructBegin('getItemCountByStatus_result')
7806 
    if self.success is not None:
7807 
      oprot.writeFieldBegin('success', TType.I32, 0)
7808 
      oprot.writeI32(self.success)
7809 
      oprot.writeFieldEnd()
7810 
    oprot.writeFieldStop()
7811 
    oprot.writeStructEnd()
7812 
 
7813 
  def validate(self):
7814 
    return
7815 
 
7816 
 
7817 
  def __repr__(self):
7818 
    L = ['%s=%r' % (key, value)
7819 
      for key, value in self.__dict__.iteritems()]
7820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7821 
 
7822 
  def __eq__(self, other):
7823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7824 
 
7825 
  def __ne__(self, other):
7826 
    return not (self == other)
7827 
 
7828 
class getBestSellers_args:
7829 
 
7830 
  thrift_spec = (
7831 
  )
7832 
 
7833 
  def read(self, iprot):
7834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7836 
      return
7837 
    iprot.readStructBegin()
7838 
    while True:
7839 
      (fname, ftype, fid) = iprot.readFieldBegin()
7840 
      if ftype == TType.STOP:
7841 
        break
7842 
      else:
7843 
        iprot.skip(ftype)
7844 
      iprot.readFieldEnd()
7845 
    iprot.readStructEnd()
7846 
 
7847 
  def write(self, oprot):
7848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7850 
      return
7851 
    oprot.writeStructBegin('getBestSellers_args')
7852 
    oprot.writeFieldStop()
7853 
    oprot.writeStructEnd()
7854 
 
7855 
  def validate(self):
7856 
    return
7857 
 
7858 
 
7859 
  def __repr__(self):
7860 
    L = ['%s=%r' % (key, value)
7861 
      for key, value in self.__dict__.iteritems()]
7862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7863 
 
7864 
  def __eq__(self, other):
7865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7866 
 
7867 
  def __ne__(self, other):
7868 
    return not (self == other)
7869 
 
7870 
class getBestSellers_result:
7871 
  """
7872 
  Attributes:
7873 
   - success
7874 
   - isex
7875 
  """
7876 
 
7877 
  thrift_spec = (
7878 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7879 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7880 
  )
7881 
 
7882 
  def __init__(self, success=None, isex=None,):
7883 
    self.success = success
7884 
    self.isex = isex
7885 
 
7886 
  def read(self, iprot):
7887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7889 
      return
7890 
    iprot.readStructBegin()
7891 
    while True:
7892 
      (fname, ftype, fid) = iprot.readFieldBegin()
7893 
      if ftype == TType.STOP:
7894 
        break
7895 
      if fid == 0:
7896 
        if ftype == TType.LIST:
7897 
          self.success = []
7438 amit.gupta 7898 
          (_etype77, _size74) = iprot.readListBegin()
7899 
          for _i78 in xrange(_size74):
7900 
            _elem79 = Item()
7901 
            _elem79.read(iprot)
7902 
            self.success.append(_elem79)
5944 mandeep.dh 7903 
          iprot.readListEnd()
7904 
        else:
7905 
          iprot.skip(ftype)
7906 
      elif fid == 1:
7907 
        if ftype == TType.STRUCT:
7908 
          self.isex = CatalogServiceException()
7909 
          self.isex.read(iprot)
7910 
        else:
7911 
          iprot.skip(ftype)
7912 
      else:
7913 
        iprot.skip(ftype)
7914 
      iprot.readFieldEnd()
7915 
    iprot.readStructEnd()
7916 
 
7917 
  def write(self, oprot):
7918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7920 
      return
7921 
    oprot.writeStructBegin('getBestSellers_result')
7922 
    if self.success is not None:
7923 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7924 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7925 
      for iter80 in self.success:
7926 
        iter80.write(oprot)
5944 mandeep.dh 7927 
      oprot.writeListEnd()
7928 
      oprot.writeFieldEnd()
7929 
    if self.isex is not None:
7930 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7931 
      self.isex.write(oprot)
7932 
      oprot.writeFieldEnd()
7933 
    oprot.writeFieldStop()
7934 
    oprot.writeStructEnd()
7935 
 
7936 
  def validate(self):
7937 
    return
7938 
 
7939 
 
7940 
  def __repr__(self):
7941 
    L = ['%s=%r' % (key, value)
7942 
      for key, value in self.__dict__.iteritems()]
7943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7944 
 
7945 
  def __eq__(self, other):
7946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7947 
 
7948 
  def __ne__(self, other):
7949 
    return not (self == other)
7950 
 
7951 
class getBestSellersCatalogIds_args:
7952 
  """
7953 
  Attributes:
7954 
   - beginIndex
7955 
   - totalItems
7956 
   - brand
7957 
   - category
7958 
  """
7959 
 
7960 
  thrift_spec = (
7961 
    None, # 0
7962 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7963 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7964 
    (3, TType.STRING, 'brand', None, None, ), # 3
7965 
    (4, TType.I64, 'category', None, None, ), # 4
7966 
  )
7967 
 
7968 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7969 
    self.beginIndex = beginIndex
7970 
    self.totalItems = totalItems
7971 
    self.brand = brand
7972 
    self.category = category
7973 
 
7974 
  def read(self, iprot):
7975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7977 
      return
7978 
    iprot.readStructBegin()
7979 
    while True:
7980 
      (fname, ftype, fid) = iprot.readFieldBegin()
7981 
      if ftype == TType.STOP:
7982 
        break
7983 
      if fid == 1:
7984 
        if ftype == TType.I64:
7985 
          self.beginIndex = iprot.readI64();
7986 
        else:
7987 
          iprot.skip(ftype)
7988 
      elif fid == 2:
7989 
        if ftype == TType.I64:
7990 
          self.totalItems = iprot.readI64();
7991 
        else:
7992 
          iprot.skip(ftype)
7993 
      elif fid == 3:
7994 
        if ftype == TType.STRING:
7995 
          self.brand = iprot.readString();
7996 
        else:
7997 
          iprot.skip(ftype)
7998 
      elif fid == 4:
7999 
        if ftype == TType.I64:
8000 
          self.category = iprot.readI64();
8001 
        else:
8002 
          iprot.skip(ftype)
8003 
      else:
8004 
        iprot.skip(ftype)
8005 
      iprot.readFieldEnd()
8006 
    iprot.readStructEnd()
8007 
 
8008 
  def write(self, oprot):
8009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8011 
      return
8012 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8013 
    if self.beginIndex is not None:
8014 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8015 
      oprot.writeI64(self.beginIndex)
8016 
      oprot.writeFieldEnd()
8017 
    if self.totalItems is not None:
8018 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8019 
      oprot.writeI64(self.totalItems)
8020 
      oprot.writeFieldEnd()
8021 
    if self.brand is not None:
8022 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8023 
      oprot.writeString(self.brand)
8024 
      oprot.writeFieldEnd()
8025 
    if self.category is not None:
8026 
      oprot.writeFieldBegin('category', TType.I64, 4)
8027 
      oprot.writeI64(self.category)
8028 
      oprot.writeFieldEnd()
8029 
    oprot.writeFieldStop()
8030 
    oprot.writeStructEnd()
8031 
 
8032 
  def validate(self):
8033 
    return
8034 
 
8035 
 
8036 
  def __repr__(self):
8037 
    L = ['%s=%r' % (key, value)
8038 
      for key, value in self.__dict__.iteritems()]
8039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8040 
 
8041 
  def __eq__(self, other):
8042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8043 
 
8044 
  def __ne__(self, other):
8045 
    return not (self == other)
8046 
 
8047 
class getBestSellersCatalogIds_result:
8048 
  """
8049 
  Attributes:
8050 
   - success
8051 
   - cex
8052 
  """
8053 
 
8054 
  thrift_spec = (
8055 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8056 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8057 
  )
8058 
 
8059 
  def __init__(self, success=None, cex=None,):
8060 
    self.success = success
8061 
    self.cex = cex
8062 
 
8063 
  def read(self, iprot):
8064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8066 
      return
8067 
    iprot.readStructBegin()
8068 
    while True:
8069 
      (fname, ftype, fid) = iprot.readFieldBegin()
8070 
      if ftype == TType.STOP:
8071 
        break
8072 
      if fid == 0:
8073 
        if ftype == TType.LIST:
8074 
          self.success = []
7438 amit.gupta 8075 
          (_etype84, _size81) = iprot.readListBegin()
8076 
          for _i85 in xrange(_size81):
8077 
            _elem86 = iprot.readI64();
8078 
            self.success.append(_elem86)
5944 mandeep.dh 8079 
          iprot.readListEnd()
8080 
        else:
8081 
          iprot.skip(ftype)
8082 
      elif fid == 1:
8083 
        if ftype == TType.STRUCT:
8084 
          self.cex = CatalogServiceException()
8085 
          self.cex.read(iprot)
8086 
        else:
8087 
          iprot.skip(ftype)
8088 
      else:
8089 
        iprot.skip(ftype)
8090 
      iprot.readFieldEnd()
8091 
    iprot.readStructEnd()
8092 
 
8093 
  def write(self, oprot):
8094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8096 
      return
8097 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
8098 
    if self.success is not None:
8099 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8100 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8101 
      for iter87 in self.success:
8102 
        oprot.writeI64(iter87)
5944 mandeep.dh 8103 
      oprot.writeListEnd()
8104 
      oprot.writeFieldEnd()
8105 
    if self.cex is not None:
8106 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8107 
      self.cex.write(oprot)
8108 
      oprot.writeFieldEnd()
8109 
    oprot.writeFieldStop()
8110 
    oprot.writeStructEnd()
8111 
 
8112 
  def validate(self):
8113 
    return
8114 
 
8115 
 
8116 
  def __repr__(self):
8117 
    L = ['%s=%r' % (key, value)
8118 
      for key, value in self.__dict__.iteritems()]
8119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8120 
 
8121 
  def __eq__(self, other):
8122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8123 
 
8124 
  def __ne__(self, other):
8125 
    return not (self == other)
8126 
 
8127 
class getBestSellersCount_args:
8128 
 
8129 
  thrift_spec = (
8130 
  )
8131 
 
8132 
  def read(self, iprot):
8133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8135 
      return
8136 
    iprot.readStructBegin()
8137 
    while True:
8138 
      (fname, ftype, fid) = iprot.readFieldBegin()
8139 
      if ftype == TType.STOP:
8140 
        break
8141 
      else:
8142 
        iprot.skip(ftype)
8143 
      iprot.readFieldEnd()
8144 
    iprot.readStructEnd()
8145 
 
8146 
  def write(self, oprot):
8147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8149 
      return
8150 
    oprot.writeStructBegin('getBestSellersCount_args')
8151 
    oprot.writeFieldStop()
8152 
    oprot.writeStructEnd()
8153 
 
8154 
  def validate(self):
8155 
    return
8156 
 
8157 
 
8158 
  def __repr__(self):
8159 
    L = ['%s=%r' % (key, value)
8160 
      for key, value in self.__dict__.iteritems()]
8161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8162 
 
8163 
  def __eq__(self, other):
8164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8165 
 
8166 
  def __ne__(self, other):
8167 
    return not (self == other)
8168 
 
8169 
class getBestSellersCount_result:
8170 
  """
8171 
  Attributes:
8172 
   - success
8173 
   - cex
8174 
  """
8175 
 
8176 
  thrift_spec = (
8177 
    (0, TType.I64, 'success', None, None, ), # 0
8178 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8179 
  )
8180 
 
8181 
  def __init__(self, success=None, cex=None,):
8182 
    self.success = success
8183 
    self.cex = cex
8184 
 
8185 
  def read(self, iprot):
8186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8188 
      return
8189 
    iprot.readStructBegin()
8190 
    while True:
8191 
      (fname, ftype, fid) = iprot.readFieldBegin()
8192 
      if ftype == TType.STOP:
8193 
        break
8194 
      if fid == 0:
8195 
        if ftype == TType.I64:
8196 
          self.success = iprot.readI64();
8197 
        else:
8198 
          iprot.skip(ftype)
8199 
      elif fid == 1:
8200 
        if ftype == TType.STRUCT:
8201 
          self.cex = CatalogServiceException()
8202 
          self.cex.read(iprot)
8203 
        else:
8204 
          iprot.skip(ftype)
8205 
      else:
8206 
        iprot.skip(ftype)
8207 
      iprot.readFieldEnd()
8208 
    iprot.readStructEnd()
8209 
 
8210 
  def write(self, oprot):
8211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8213 
      return
8214 
    oprot.writeStructBegin('getBestSellersCount_result')
8215 
    if self.success is not None:
8216 
      oprot.writeFieldBegin('success', TType.I64, 0)
8217 
      oprot.writeI64(self.success)
8218 
      oprot.writeFieldEnd()
8219 
    if self.cex is not None:
8220 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8221 
      self.cex.write(oprot)
8222 
      oprot.writeFieldEnd()
8223 
    oprot.writeFieldStop()
8224 
    oprot.writeStructEnd()
8225 
 
8226 
  def validate(self):
8227 
    return
8228 
 
8229 
 
8230 
  def __repr__(self):
8231 
    L = ['%s=%r' % (key, value)
8232 
      for key, value in self.__dict__.iteritems()]
8233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8234 
 
8235 
  def __eq__(self, other):
8236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8237 
 
8238 
  def __ne__(self, other):
8239 
    return not (self == other)
8240 
 
8241 
class getBestDeals_args:
8242 
 
8243 
  thrift_spec = (
8244 
  )
8245 
 
8246 
  def read(self, iprot):
8247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8249 
      return
8250 
    iprot.readStructBegin()
8251 
    while True:
8252 
      (fname, ftype, fid) = iprot.readFieldBegin()
8253 
      if ftype == TType.STOP:
8254 
        break
8255 
      else:
8256 
        iprot.skip(ftype)
8257 
      iprot.readFieldEnd()
8258 
    iprot.readStructEnd()
8259 
 
8260 
  def write(self, oprot):
8261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8263 
      return
8264 
    oprot.writeStructBegin('getBestDeals_args')
8265 
    oprot.writeFieldStop()
8266 
    oprot.writeStructEnd()
8267 
 
8268 
  def validate(self):
8269 
    return
8270 
 
8271 
 
8272 
  def __repr__(self):
8273 
    L = ['%s=%r' % (key, value)
8274 
      for key, value in self.__dict__.iteritems()]
8275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8276 
 
8277 
  def __eq__(self, other):
8278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8279 
 
8280 
  def __ne__(self, other):
8281 
    return not (self == other)
8282 
 
8283 
class getBestDeals_result:
8284 
  """
8285 
  Attributes:
8286 
   - success
8287 
   - isex
8288 
  """
8289 
 
8290 
  thrift_spec = (
8291 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8292 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8293 
  )
8294 
 
8295 
  def __init__(self, success=None, isex=None,):
8296 
    self.success = success
8297 
    self.isex = isex
8298 
 
8299 
  def read(self, iprot):
8300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8302 
      return
8303 
    iprot.readStructBegin()
8304 
    while True:
8305 
      (fname, ftype, fid) = iprot.readFieldBegin()
8306 
      if ftype == TType.STOP:
8307 
        break
8308 
      if fid == 0:
8309 
        if ftype == TType.LIST:
8310 
          self.success = []
7438 amit.gupta 8311 
          (_etype91, _size88) = iprot.readListBegin()
8312 
          for _i92 in xrange(_size88):
8313 
            _elem93 = Item()
8314 
            _elem93.read(iprot)
8315 
            self.success.append(_elem93)
5944 mandeep.dh 8316 
          iprot.readListEnd()
8317 
        else:
8318 
          iprot.skip(ftype)
8319 
      elif fid == 1:
8320 
        if ftype == TType.STRUCT:
8321 
          self.isex = CatalogServiceException()
8322 
          self.isex.read(iprot)
8323 
        else:
8324 
          iprot.skip(ftype)
8325 
      else:
8326 
        iprot.skip(ftype)
8327 
      iprot.readFieldEnd()
8328 
    iprot.readStructEnd()
8329 
 
8330 
  def write(self, oprot):
8331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8333 
      return
8334 
    oprot.writeStructBegin('getBestDeals_result')
8335 
    if self.success is not None:
8336 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8337 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8338 
      for iter94 in self.success:
8339 
        iter94.write(oprot)
5944 mandeep.dh 8340 
      oprot.writeListEnd()
8341 
      oprot.writeFieldEnd()
8342 
    if self.isex is not None:
8343 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8344 
      self.isex.write(oprot)
8345 
      oprot.writeFieldEnd()
8346 
    oprot.writeFieldStop()
8347 
    oprot.writeStructEnd()
8348 
 
8349 
  def validate(self):
8350 
    return
8351 
 
8352 
 
8353 
  def __repr__(self):
8354 
    L = ['%s=%r' % (key, value)
8355 
      for key, value in self.__dict__.iteritems()]
8356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8357 
 
8358 
  def __eq__(self, other):
8359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8360 
 
8361 
  def __ne__(self, other):
8362 
    return not (self == other)
8363 
 
8364 
class getBestDealsCatalogIds_args:
8365 
  """
8366 
  Attributes:
8367 
   - beginIndex
8368 
   - totalItems
8369 
   - brand
8370 
   - category
8371 
  """
8372 
 
8373 
  thrift_spec = (
8374 
    None, # 0
8375 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8376 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8377 
    (3, TType.STRING, 'brand', None, None, ), # 3
8378 
    (4, TType.I64, 'category', None, None, ), # 4
8379 
  )
8380 
 
8381 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8382 
    self.beginIndex = beginIndex
8383 
    self.totalItems = totalItems
8384 
    self.brand = brand
8385 
    self.category = category
8386 
 
8387 
  def read(self, iprot):
8388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8390 
      return
8391 
    iprot.readStructBegin()
8392 
    while True:
8393 
      (fname, ftype, fid) = iprot.readFieldBegin()
8394 
      if ftype == TType.STOP:
8395 
        break
8396 
      if fid == 1:
8397 
        if ftype == TType.I64:
8398 
          self.beginIndex = iprot.readI64();
8399 
        else:
8400 
          iprot.skip(ftype)
8401 
      elif fid == 2:
8402 
        if ftype == TType.I64:
8403 
          self.totalItems = iprot.readI64();
8404 
        else:
8405 
          iprot.skip(ftype)
8406 
      elif fid == 3:
8407 
        if ftype == TType.STRING:
8408 
          self.brand = iprot.readString();
8409 
        else:
8410 
          iprot.skip(ftype)
8411 
      elif fid == 4:
8412 
        if ftype == TType.I64:
8413 
          self.category = iprot.readI64();
8414 
        else:
8415 
          iprot.skip(ftype)
8416 
      else:
8417 
        iprot.skip(ftype)
8418 
      iprot.readFieldEnd()
8419 
    iprot.readStructEnd()
8420 
 
8421 
  def write(self, oprot):
8422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8424 
      return
8425 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8426 
    if self.beginIndex is not None:
8427 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8428 
      oprot.writeI64(self.beginIndex)
8429 
      oprot.writeFieldEnd()
8430 
    if self.totalItems is not None:
8431 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8432 
      oprot.writeI64(self.totalItems)
8433 
      oprot.writeFieldEnd()
8434 
    if self.brand is not None:
8435 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8436 
      oprot.writeString(self.brand)
8437 
      oprot.writeFieldEnd()
8438 
    if self.category is not None:
8439 
      oprot.writeFieldBegin('category', TType.I64, 4)
8440 
      oprot.writeI64(self.category)
8441 
      oprot.writeFieldEnd()
8442 
    oprot.writeFieldStop()
8443 
    oprot.writeStructEnd()
8444 
 
8445 
  def validate(self):
8446 
    return
8447 
 
8448 
 
8449 
  def __repr__(self):
8450 
    L = ['%s=%r' % (key, value)
8451 
      for key, value in self.__dict__.iteritems()]
8452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8453 
 
8454 
  def __eq__(self, other):
8455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8456 
 
8457 
  def __ne__(self, other):
8458 
    return not (self == other)
8459 
 
8460 
class getBestDealsCatalogIds_result:
8461 
  """
8462 
  Attributes:
8463 
   - success
8464 
   - cex
8465 
  """
8466 
 
8467 
  thrift_spec = (
8468 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8469 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8470 
  )
8471 
 
8472 
  def __init__(self, success=None, cex=None,):
8473 
    self.success = success
8474 
    self.cex = cex
8475 
 
8476 
  def read(self, iprot):
8477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8479 
      return
8480 
    iprot.readStructBegin()
8481 
    while True:
8482 
      (fname, ftype, fid) = iprot.readFieldBegin()
8483 
      if ftype == TType.STOP:
8484 
        break
8485 
      if fid == 0:
8486 
        if ftype == TType.LIST:
8487 
          self.success = []
7438 amit.gupta 8488 
          (_etype98, _size95) = iprot.readListBegin()
8489 
          for _i99 in xrange(_size95):
8490 
            _elem100 = iprot.readI64();
8491 
            self.success.append(_elem100)
5944 mandeep.dh 8492 
          iprot.readListEnd()
8493 
        else:
8494 
          iprot.skip(ftype)
8495 
      elif fid == 1:
8496 
        if ftype == TType.STRUCT:
8497 
          self.cex = CatalogServiceException()
8498 
          self.cex.read(iprot)
8499 
        else:
8500 
          iprot.skip(ftype)
8501 
      else:
8502 
        iprot.skip(ftype)
8503 
      iprot.readFieldEnd()
8504 
    iprot.readStructEnd()
8505 
 
8506 
  def write(self, oprot):
8507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8509 
      return
8510 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8511 
    if self.success is not None:
8512 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8513 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8514 
      for iter101 in self.success:
8515 
        oprot.writeI64(iter101)
5944 mandeep.dh 8516 
      oprot.writeListEnd()
8517 
      oprot.writeFieldEnd()
8518 
    if self.cex is not None:
8519 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8520 
      self.cex.write(oprot)
8521 
      oprot.writeFieldEnd()
8522 
    oprot.writeFieldStop()
8523 
    oprot.writeStructEnd()
8524 
 
8525 
  def validate(self):
8526 
    return
8527 
 
8528 
 
8529 
  def __repr__(self):
8530 
    L = ['%s=%r' % (key, value)
8531 
      for key, value in self.__dict__.iteritems()]
8532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8533 
 
8534 
  def __eq__(self, other):
8535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8536 
 
8537 
  def __ne__(self, other):
8538 
    return not (self == other)
8539 
 
8540 
class getBestDealsCount_args:
8541 
 
8542 
  thrift_spec = (
8543 
  )
8544 
 
8545 
  def read(self, iprot):
8546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8548 
      return
8549 
    iprot.readStructBegin()
8550 
    while True:
8551 
      (fname, ftype, fid) = iprot.readFieldBegin()
8552 
      if ftype == TType.STOP:
8553 
        break
8554 
      else:
8555 
        iprot.skip(ftype)
8556 
      iprot.readFieldEnd()
8557 
    iprot.readStructEnd()
8558 
 
8559 
  def write(self, oprot):
8560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8562 
      return
8563 
    oprot.writeStructBegin('getBestDealsCount_args')
8564 
    oprot.writeFieldStop()
8565 
    oprot.writeStructEnd()
8566 
 
8567 
  def validate(self):
8568 
    return
8569 
 
8570 
 
8571 
  def __repr__(self):
8572 
    L = ['%s=%r' % (key, value)
8573 
      for key, value in self.__dict__.iteritems()]
8574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8575 
 
8576 
  def __eq__(self, other):
8577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8578 
 
8579 
  def __ne__(self, other):
8580 
    return not (self == other)
8581 
 
8582 
class getBestDealsCount_result:
8583 
  """
8584 
  Attributes:
8585 
   - success
8586 
   - cex
8587 
  """
8588 
 
8589 
  thrift_spec = (
8590 
    (0, TType.I64, 'success', None, None, ), # 0
8591 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8592 
  )
8593 
 
8594 
  def __init__(self, success=None, cex=None,):
8595 
    self.success = success
8596 
    self.cex = cex
8597 
 
8598 
  def read(self, iprot):
8599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8601 
      return
8602 
    iprot.readStructBegin()
8603 
    while True:
8604 
      (fname, ftype, fid) = iprot.readFieldBegin()
8605 
      if ftype == TType.STOP:
8606 
        break
8607 
      if fid == 0:
8608 
        if ftype == TType.I64:
8609 
          self.success = iprot.readI64();
8610 
        else:
8611 
          iprot.skip(ftype)
8612 
      elif fid == 1:
8613 
        if ftype == TType.STRUCT:
8614 
          self.cex = CatalogServiceException()
8615 
          self.cex.read(iprot)
8616 
        else:
8617 
          iprot.skip(ftype)
8618 
      else:
8619 
        iprot.skip(ftype)
8620 
      iprot.readFieldEnd()
8621 
    iprot.readStructEnd()
8622 
 
8623 
  def write(self, oprot):
8624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8626 
      return
8627 
    oprot.writeStructBegin('getBestDealsCount_result')
8628 
    if self.success is not None:
8629 
      oprot.writeFieldBegin('success', TType.I64, 0)
8630 
      oprot.writeI64(self.success)
8631 
      oprot.writeFieldEnd()
8632 
    if self.cex is not None:
8633 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8634 
      self.cex.write(oprot)
8635 
      oprot.writeFieldEnd()
8636 
    oprot.writeFieldStop()
8637 
    oprot.writeStructEnd()
8638 
 
8639 
  def validate(self):
8640 
    return
8641 
 
8642 
 
8643 
  def __repr__(self):
8644 
    L = ['%s=%r' % (key, value)
8645 
      for key, value in self.__dict__.iteritems()]
8646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8647 
 
8648 
  def __eq__(self, other):
8649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8650 
 
8651 
  def __ne__(self, other):
8652 
    return not (self == other)
8653 
 
8654 
class getComingSoon_args:
8655 
 
8656 
  thrift_spec = (
8657 
  )
8658 
 
8659 
  def read(self, iprot):
8660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8662 
      return
8663 
    iprot.readStructBegin()
8664 
    while True:
8665 
      (fname, ftype, fid) = iprot.readFieldBegin()
8666 
      if ftype == TType.STOP:
8667 
        break
8668 
      else:
8669 
        iprot.skip(ftype)
8670 
      iprot.readFieldEnd()
8671 
    iprot.readStructEnd()
8672 
 
8673 
  def write(self, oprot):
8674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8676 
      return
8677 
    oprot.writeStructBegin('getComingSoon_args')
8678 
    oprot.writeFieldStop()
8679 
    oprot.writeStructEnd()
8680 
 
8681 
  def validate(self):
8682 
    return
8683 
 
8684 
 
8685 
  def __repr__(self):
8686 
    L = ['%s=%r' % (key, value)
8687 
      for key, value in self.__dict__.iteritems()]
8688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8689 
 
8690 
  def __eq__(self, other):
8691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8692 
 
8693 
  def __ne__(self, other):
8694 
    return not (self == other)
8695 
 
8696 
class getComingSoon_result:
8697 
  """
8698 
  Attributes:
8699 
   - success
8700 
   - isex
8701 
  """
8702 
 
8703 
  thrift_spec = (
8704 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8705 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8706 
  )
8707 
 
8708 
  def __init__(self, success=None, isex=None,):
8709 
    self.success = success
8710 
    self.isex = isex
8711 
 
8712 
  def read(self, iprot):
8713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8715 
      return
8716 
    iprot.readStructBegin()
8717 
    while True:
8718 
      (fname, ftype, fid) = iprot.readFieldBegin()
8719 
      if ftype == TType.STOP:
8720 
        break
8721 
      if fid == 0:
8722 
        if ftype == TType.LIST:
8723 
          self.success = []
7438 amit.gupta 8724 
          (_etype105, _size102) = iprot.readListBegin()
8725 
          for _i106 in xrange(_size102):
8726 
            _elem107 = Item()
8727 
            _elem107.read(iprot)
8728 
            self.success.append(_elem107)
5944 mandeep.dh 8729 
          iprot.readListEnd()
8730 
        else:
8731 
          iprot.skip(ftype)
8732 
      elif fid == 1:
8733 
        if ftype == TType.STRUCT:
8734 
          self.isex = CatalogServiceException()
8735 
          self.isex.read(iprot)
8736 
        else:
8737 
          iprot.skip(ftype)
8738 
      else:
8739 
        iprot.skip(ftype)
8740 
      iprot.readFieldEnd()
8741 
    iprot.readStructEnd()
8742 
 
8743 
  def write(self, oprot):
8744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8746 
      return
8747 
    oprot.writeStructBegin('getComingSoon_result')
8748 
    if self.success is not None:
8749 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8750 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8751 
      for iter108 in self.success:
8752 
        iter108.write(oprot)
5944 mandeep.dh 8753 
      oprot.writeListEnd()
8754 
      oprot.writeFieldEnd()
8755 
    if self.isex is not None:
8756 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8757 
      self.isex.write(oprot)
8758 
      oprot.writeFieldEnd()
8759 
    oprot.writeFieldStop()
8760 
    oprot.writeStructEnd()
8761 
 
8762 
  def validate(self):
8763 
    return
8764 
 
8765 
 
8766 
  def __repr__(self):
8767 
    L = ['%s=%r' % (key, value)
8768 
      for key, value in self.__dict__.iteritems()]
8769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8770 
 
8771 
  def __eq__(self, other):
8772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8773 
 
8774 
  def __ne__(self, other):
8775 
    return not (self == other)
8776 
 
8777 
class getComingSoonCatalogIds_args:
8778 
  """
8779 
  Attributes:
8780 
   - beginIndex
8781 
   - totalItems
8782 
   - brand
8783 
   - category
8784 
  """
8785 
 
8786 
  thrift_spec = (
8787 
    None, # 0
8788 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8789 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8790 
    (3, TType.STRING, 'brand', None, None, ), # 3
8791 
    (4, TType.I64, 'category', None, None, ), # 4
8792 
  )
8793 
 
8794 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8795 
    self.beginIndex = beginIndex
8796 
    self.totalItems = totalItems
8797 
    self.brand = brand
8798 
    self.category = category
8799 
 
8800 
  def read(self, iprot):
8801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8803 
      return
8804 
    iprot.readStructBegin()
8805 
    while True:
8806 
      (fname, ftype, fid) = iprot.readFieldBegin()
8807 
      if ftype == TType.STOP:
8808 
        break
8809 
      if fid == 1:
8810 
        if ftype == TType.I64:
8811 
          self.beginIndex = iprot.readI64();
8812 
        else:
8813 
          iprot.skip(ftype)
8814 
      elif fid == 2:
8815 
        if ftype == TType.I64:
8816 
          self.totalItems = iprot.readI64();
8817 
        else:
8818 
          iprot.skip(ftype)
8819 
      elif fid == 3:
8820 
        if ftype == TType.STRING:
8821 
          self.brand = iprot.readString();
8822 
        else:
8823 
          iprot.skip(ftype)
8824 
      elif fid == 4:
8825 
        if ftype == TType.I64:
8826 
          self.category = iprot.readI64();
8827 
        else:
8828 
          iprot.skip(ftype)
8829 
      else:
8830 
        iprot.skip(ftype)
8831 
      iprot.readFieldEnd()
8832 
    iprot.readStructEnd()
8833 
 
8834 
  def write(self, oprot):
8835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8837 
      return
8838 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8839 
    if self.beginIndex is not None:
8840 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8841 
      oprot.writeI64(self.beginIndex)
8842 
      oprot.writeFieldEnd()
8843 
    if self.totalItems is not None:
8844 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8845 
      oprot.writeI64(self.totalItems)
8846 
      oprot.writeFieldEnd()
8847 
    if self.brand is not None:
8848 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8849 
      oprot.writeString(self.brand)
8850 
      oprot.writeFieldEnd()
8851 
    if self.category is not None:
8852 
      oprot.writeFieldBegin('category', TType.I64, 4)
8853 
      oprot.writeI64(self.category)
8854 
      oprot.writeFieldEnd()
8855 
    oprot.writeFieldStop()
8856 
    oprot.writeStructEnd()
8857 
 
8858 
  def validate(self):
8859 
    return
8860 
 
8861 
 
8862 
  def __repr__(self):
8863 
    L = ['%s=%r' % (key, value)
8864 
      for key, value in self.__dict__.iteritems()]
8865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8866 
 
8867 
  def __eq__(self, other):
8868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8869 
 
8870 
  def __ne__(self, other):
8871 
    return not (self == other)
8872 
 
8873 
class getComingSoonCatalogIds_result:
8874 
  """
8875 
  Attributes:
8876 
   - success
8877 
   - cex
8878 
  """
8879 
 
8880 
  thrift_spec = (
8881 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8882 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8883 
  )
8884 
 
8885 
  def __init__(self, success=None, cex=None,):
8886 
    self.success = success
8887 
    self.cex = cex
8888 
 
8889 
  def read(self, iprot):
8890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8892 
      return
8893 
    iprot.readStructBegin()
8894 
    while True:
8895 
      (fname, ftype, fid) = iprot.readFieldBegin()
8896 
      if ftype == TType.STOP:
8897 
        break
8898 
      if fid == 0:
8899 
        if ftype == TType.LIST:
8900 
          self.success = []
7438 amit.gupta 8901 
          (_etype112, _size109) = iprot.readListBegin()
8902 
          for _i113 in xrange(_size109):
8903 
            _elem114 = iprot.readI64();
8904 
            self.success.append(_elem114)
5944 mandeep.dh 8905 
          iprot.readListEnd()
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      elif fid == 1:
8909 
        if ftype == TType.STRUCT:
8910 
          self.cex = CatalogServiceException()
8911 
          self.cex.read(iprot)
8912 
        else:
8913 
          iprot.skip(ftype)
8914 
      else:
8915 
        iprot.skip(ftype)
8916 
      iprot.readFieldEnd()
8917 
    iprot.readStructEnd()
8918 
 
8919 
  def write(self, oprot):
8920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8922 
      return
8923 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8924 
    if self.success is not None:
8925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8926 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8927 
      for iter115 in self.success:
8928 
        oprot.writeI64(iter115)
5944 mandeep.dh 8929 
      oprot.writeListEnd()
8930 
      oprot.writeFieldEnd()
8931 
    if self.cex is not None:
8932 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8933 
      self.cex.write(oprot)
8934 
      oprot.writeFieldEnd()
8935 
    oprot.writeFieldStop()
8936 
    oprot.writeStructEnd()
8937 
 
8938 
  def validate(self):
8939 
    return
8940 
 
8941 
 
8942 
  def __repr__(self):
8943 
    L = ['%s=%r' % (key, value)
8944 
      for key, value in self.__dict__.iteritems()]
8945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8946 
 
8947 
  def __eq__(self, other):
8948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8949 
 
8950 
  def __ne__(self, other):
8951 
    return not (self == other)
8952 
 
8953 
class getComingSoonCount_args:
8954 
 
8955 
  thrift_spec = (
8956 
  )
8957 
 
8958 
  def read(self, iprot):
8959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8961 
      return
8962 
    iprot.readStructBegin()
8963 
    while True:
8964 
      (fname, ftype, fid) = iprot.readFieldBegin()
8965 
      if ftype == TType.STOP:
8966 
        break
8967 
      else:
8968 
        iprot.skip(ftype)
8969 
      iprot.readFieldEnd()
8970 
    iprot.readStructEnd()
8971 
 
8972 
  def write(self, oprot):
8973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8975 
      return
8976 
    oprot.writeStructBegin('getComingSoonCount_args')
8977 
    oprot.writeFieldStop()
8978 
    oprot.writeStructEnd()
8979 
 
8980 
  def validate(self):
8981 
    return
8982 
 
8983 
 
8984 
  def __repr__(self):
8985 
    L = ['%s=%r' % (key, value)
8986 
      for key, value in self.__dict__.iteritems()]
8987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8988 
 
8989 
  def __eq__(self, other):
8990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8991 
 
8992 
  def __ne__(self, other):
8993 
    return not (self == other)
8994 
 
8995 
class getComingSoonCount_result:
8996 
  """
8997 
  Attributes:
8998 
   - success
8999 
   - cex
9000 
  """
9001 
 
9002 
  thrift_spec = (
9003 
    (0, TType.I64, 'success', None, None, ), # 0
9004 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9005 
  )
9006 
 
9007 
  def __init__(self, success=None, cex=None,):
9008 
    self.success = success
9009 
    self.cex = cex
9010 
 
9011 
  def read(self, iprot):
9012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9014 
      return
9015 
    iprot.readStructBegin()
9016 
    while True:
9017 
      (fname, ftype, fid) = iprot.readFieldBegin()
9018 
      if ftype == TType.STOP:
9019 
        break
9020 
      if fid == 0:
9021 
        if ftype == TType.I64:
9022 
          self.success = iprot.readI64();
9023 
        else:
9024 
          iprot.skip(ftype)
9025 
      elif fid == 1:
9026 
        if ftype == TType.STRUCT:
9027 
          self.cex = CatalogServiceException()
9028 
          self.cex.read(iprot)
9029 
        else:
9030 
          iprot.skip(ftype)
9031 
      else:
9032 
        iprot.skip(ftype)
9033 
      iprot.readFieldEnd()
9034 
    iprot.readStructEnd()
9035 
 
9036 
  def write(self, oprot):
9037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9039 
      return
9040 
    oprot.writeStructBegin('getComingSoonCount_result')
9041 
    if self.success is not None:
9042 
      oprot.writeFieldBegin('success', TType.I64, 0)
9043 
      oprot.writeI64(self.success)
9044 
      oprot.writeFieldEnd()
9045 
    if self.cex is not None:
9046 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9047 
      self.cex.write(oprot)
9048 
      oprot.writeFieldEnd()
9049 
    oprot.writeFieldStop()
9050 
    oprot.writeStructEnd()
9051 
 
9052 
  def validate(self):
9053 
    return
9054 
 
9055 
 
9056 
  def __repr__(self):
9057 
    L = ['%s=%r' % (key, value)
9058 
      for key, value in self.__dict__.iteritems()]
9059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9060 
 
9061 
  def __eq__(self, other):
9062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9063 
 
9064 
  def __ne__(self, other):
9065 
    return not (self == other)
9066 
 
9067 
class getLatestArrivals_args:
9068 
 
9069 
  thrift_spec = (
9070 
  )
9071 
 
9072 
  def read(self, iprot):
9073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9075 
      return
9076 
    iprot.readStructBegin()
9077 
    while True:
9078 
      (fname, ftype, fid) = iprot.readFieldBegin()
9079 
      if ftype == TType.STOP:
9080 
        break
9081 
      else:
9082 
        iprot.skip(ftype)
9083 
      iprot.readFieldEnd()
9084 
    iprot.readStructEnd()
9085 
 
9086 
  def write(self, oprot):
9087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9089 
      return
9090 
    oprot.writeStructBegin('getLatestArrivals_args')
9091 
    oprot.writeFieldStop()
9092 
    oprot.writeStructEnd()
9093 
 
9094 
  def validate(self):
9095 
    return
9096 
 
9097 
 
9098 
  def __repr__(self):
9099 
    L = ['%s=%r' % (key, value)
9100 
      for key, value in self.__dict__.iteritems()]
9101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9102 
 
9103 
  def __eq__(self, other):
9104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9105 
 
9106 
  def __ne__(self, other):
9107 
    return not (self == other)
9108 
 
9109 
class getLatestArrivals_result:
9110 
  """
9111 
  Attributes:
9112 
   - success
9113 
   - isex
9114 
  """
9115 
 
9116 
  thrift_spec = (
9117 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9118 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9119 
  )
9120 
 
9121 
  def __init__(self, success=None, isex=None,):
9122 
    self.success = success
9123 
    self.isex = isex
9124 
 
9125 
  def read(self, iprot):
9126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9128 
      return
9129 
    iprot.readStructBegin()
9130 
    while True:
9131 
      (fname, ftype, fid) = iprot.readFieldBegin()
9132 
      if ftype == TType.STOP:
9133 
        break
9134 
      if fid == 0:
9135 
        if ftype == TType.LIST:
9136 
          self.success = []
7438 amit.gupta 9137 
          (_etype119, _size116) = iprot.readListBegin()
9138 
          for _i120 in xrange(_size116):
9139 
            _elem121 = Item()
9140 
            _elem121.read(iprot)
9141 
            self.success.append(_elem121)
5944 mandeep.dh 9142 
          iprot.readListEnd()
9143 
        else:
9144 
          iprot.skip(ftype)
9145 
      elif fid == 1:
9146 
        if ftype == TType.STRUCT:
9147 
          self.isex = CatalogServiceException()
9148 
          self.isex.read(iprot)
9149 
        else:
9150 
          iprot.skip(ftype)
9151 
      else:
9152 
        iprot.skip(ftype)
9153 
      iprot.readFieldEnd()
9154 
    iprot.readStructEnd()
9155 
 
9156 
  def write(self, oprot):
9157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9159 
      return
9160 
    oprot.writeStructBegin('getLatestArrivals_result')
9161 
    if self.success is not None:
9162 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9163 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9164 
      for iter122 in self.success:
9165 
        iter122.write(oprot)
5944 mandeep.dh 9166 
      oprot.writeListEnd()
9167 
      oprot.writeFieldEnd()
9168 
    if self.isex is not None:
9169 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9170 
      self.isex.write(oprot)
9171 
      oprot.writeFieldEnd()
9172 
    oprot.writeFieldStop()
9173 
    oprot.writeStructEnd()
9174 
 
9175 
  def validate(self):
9176 
    return
9177 
 
9178 
 
9179 
  def __repr__(self):
9180 
    L = ['%s=%r' % (key, value)
9181 
      for key, value in self.__dict__.iteritems()]
9182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9183 
 
9184 
  def __eq__(self, other):
9185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9186 
 
9187 
  def __ne__(self, other):
9188 
    return not (self == other)
9189 
 
9190 
class getLatestArrivalsCatalogIds_args:
9191 
  """
9192 
  Attributes:
9193 
   - beginIndex
9194 
   - totalItems
9195 
   - brand
9196 
   - categories
9197 
  """
9198 
 
9199 
  thrift_spec = (
9200 
    None, # 0
9201 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9202 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9203 
    (3, TType.STRING, 'brand', None, None, ), # 3
9204 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
9205 
  )
9206 
 
9207 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
9208 
    self.beginIndex = beginIndex
9209 
    self.totalItems = totalItems
9210 
    self.brand = brand
9211 
    self.categories = categories
9212 
 
9213 
  def read(self, iprot):
9214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9216 
      return
9217 
    iprot.readStructBegin()
9218 
    while True:
9219 
      (fname, ftype, fid) = iprot.readFieldBegin()
9220 
      if ftype == TType.STOP:
9221 
        break
9222 
      if fid == 1:
9223 
        if ftype == TType.I64:
9224 
          self.beginIndex = iprot.readI64();
9225 
        else:
9226 
          iprot.skip(ftype)
9227 
      elif fid == 2:
9228 
        if ftype == TType.I64:
9229 
          self.totalItems = iprot.readI64();
9230 
        else:
9231 
          iprot.skip(ftype)
9232 
      elif fid == 3:
9233 
        if ftype == TType.STRING:
9234 
          self.brand = iprot.readString();
9235 
        else:
9236 
          iprot.skip(ftype)
9237 
      elif fid == 4:
9238 
        if ftype == TType.LIST:
9239 
          self.categories = []
7438 amit.gupta 9240 
          (_etype126, _size123) = iprot.readListBegin()
9241 
          for _i127 in xrange(_size123):
9242 
            _elem128 = iprot.readI64();
9243 
            self.categories.append(_elem128)
5944 mandeep.dh 9244 
          iprot.readListEnd()
9245 
        else:
9246 
          iprot.skip(ftype)
9247 
      else:
9248 
        iprot.skip(ftype)
9249 
      iprot.readFieldEnd()
9250 
    iprot.readStructEnd()
9251 
 
9252 
  def write(self, oprot):
9253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9255 
      return
9256 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9257 
    if self.beginIndex is not None:
9258 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9259 
      oprot.writeI64(self.beginIndex)
9260 
      oprot.writeFieldEnd()
9261 
    if self.totalItems is not None:
9262 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9263 
      oprot.writeI64(self.totalItems)
9264 
      oprot.writeFieldEnd()
9265 
    if self.brand is not None:
9266 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9267 
      oprot.writeString(self.brand)
9268 
      oprot.writeFieldEnd()
9269 
    if self.categories is not None:
9270 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9271 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9272 
      for iter129 in self.categories:
9273 
        oprot.writeI64(iter129)
5944 mandeep.dh 9274 
      oprot.writeListEnd()
9275 
      oprot.writeFieldEnd()
9276 
    oprot.writeFieldStop()
9277 
    oprot.writeStructEnd()
9278 
 
9279 
  def validate(self):
9280 
    return
9281 
 
9282 
 
9283 
  def __repr__(self):
9284 
    L = ['%s=%r' % (key, value)
9285 
      for key, value in self.__dict__.iteritems()]
9286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9287 
 
9288 
  def __eq__(self, other):
9289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9290 
 
9291 
  def __ne__(self, other):
9292 
    return not (self == other)
9293 
 
9294 
class getLatestArrivalsCatalogIds_result:
9295 
  """
9296 
  Attributes:
9297 
   - success
9298 
   - cex
9299 
  """
9300 
 
9301 
  thrift_spec = (
9302 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9303 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9304 
  )
9305 
 
9306 
  def __init__(self, success=None, cex=None,):
9307 
    self.success = success
9308 
    self.cex = cex
9309 
 
9310 
  def read(self, iprot):
9311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9313 
      return
9314 
    iprot.readStructBegin()
9315 
    while True:
9316 
      (fname, ftype, fid) = iprot.readFieldBegin()
9317 
      if ftype == TType.STOP:
9318 
        break
9319 
      if fid == 0:
9320 
        if ftype == TType.LIST:
9321 
          self.success = []
7438 amit.gupta 9322 
          (_etype133, _size130) = iprot.readListBegin()
9323 
          for _i134 in xrange(_size130):
9324 
            _elem135 = iprot.readI64();
9325 
            self.success.append(_elem135)
5944 mandeep.dh 9326 
          iprot.readListEnd()
9327 
        else:
9328 
          iprot.skip(ftype)
9329 
      elif fid == 1:
9330 
        if ftype == TType.STRUCT:
9331 
          self.cex = CatalogServiceException()
9332 
          self.cex.read(iprot)
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      else:
9336 
        iprot.skip(ftype)
9337 
      iprot.readFieldEnd()
9338 
    iprot.readStructEnd()
9339 
 
9340 
  def write(self, oprot):
9341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9343 
      return
9344 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9345 
    if self.success is not None:
9346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9347 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9348 
      for iter136 in self.success:
9349 
        oprot.writeI64(iter136)
5944 mandeep.dh 9350 
      oprot.writeListEnd()
9351 
      oprot.writeFieldEnd()
9352 
    if self.cex is not None:
9353 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9354 
      self.cex.write(oprot)
9355 
      oprot.writeFieldEnd()
9356 
    oprot.writeFieldStop()
9357 
    oprot.writeStructEnd()
9358 
 
9359 
  def validate(self):
9360 
    return
9361 
 
9362 
 
9363 
  def __repr__(self):
9364 
    L = ['%s=%r' % (key, value)
9365 
      for key, value in self.__dict__.iteritems()]
9366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9367 
 
9368 
  def __eq__(self, other):
9369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9370 
 
9371 
  def __ne__(self, other):
9372 
    return not (self == other)
9373 
 
9374 
class getLatestArrivalsCount_args:
9375 
 
9376 
  thrift_spec = (
9377 
  )
9378 
 
9379 
  def read(self, iprot):
9380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9382 
      return
9383 
    iprot.readStructBegin()
9384 
    while True:
9385 
      (fname, ftype, fid) = iprot.readFieldBegin()
9386 
      if ftype == TType.STOP:
9387 
        break
9388 
      else:
9389 
        iprot.skip(ftype)
9390 
      iprot.readFieldEnd()
9391 
    iprot.readStructEnd()
9392 
 
9393 
  def write(self, oprot):
9394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9396 
      return
9397 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9398 
    oprot.writeFieldStop()
9399 
    oprot.writeStructEnd()
9400 
 
9401 
  def validate(self):
9402 
    return
9403 
 
9404 
 
9405 
  def __repr__(self):
9406 
    L = ['%s=%r' % (key, value)
9407 
      for key, value in self.__dict__.iteritems()]
9408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9409 
 
9410 
  def __eq__(self, other):
9411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9412 
 
9413 
  def __ne__(self, other):
9414 
    return not (self == other)
9415 
 
9416 
class getLatestArrivalsCount_result:
9417 
  """
9418 
  Attributes:
9419 
   - success
9420 
   - cex
9421 
  """
9422 
 
9423 
  thrift_spec = (
9424 
    (0, TType.I64, 'success', None, None, ), # 0
9425 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9426 
  )
9427 
 
9428 
  def __init__(self, success=None, cex=None,):
9429 
    self.success = success
9430 
    self.cex = cex
9431 
 
9432 
  def read(self, iprot):
9433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9435 
      return
9436 
    iprot.readStructBegin()
9437 
    while True:
9438 
      (fname, ftype, fid) = iprot.readFieldBegin()
9439 
      if ftype == TType.STOP:
9440 
        break
9441 
      if fid == 0:
9442 
        if ftype == TType.I64:
9443 
          self.success = iprot.readI64();
9444 
        else:
9445 
          iprot.skip(ftype)
9446 
      elif fid == 1:
9447 
        if ftype == TType.STRUCT:
9448 
          self.cex = CatalogServiceException()
9449 
          self.cex.read(iprot)
9450 
        else:
9451 
          iprot.skip(ftype)
9452 
      else:
9453 
        iprot.skip(ftype)
9454 
      iprot.readFieldEnd()
9455 
    iprot.readStructEnd()
9456 
 
9457 
  def write(self, oprot):
9458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9460 
      return
9461 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9462 
    if self.success is not None:
9463 
      oprot.writeFieldBegin('success', TType.I64, 0)
9464 
      oprot.writeI64(self.success)
9465 
      oprot.writeFieldEnd()
9466 
    if self.cex is not None:
9467 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9468 
      self.cex.write(oprot)
9469 
      oprot.writeFieldEnd()
9470 
    oprot.writeFieldStop()
9471 
    oprot.writeStructEnd()
9472 
 
9473 
  def validate(self):
9474 
    return
9475 
 
9476 
 
9477 
  def __repr__(self):
9478 
    L = ['%s=%r' % (key, value)
9479 
      for key, value in self.__dict__.iteritems()]
9480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9481 
 
9482 
  def __eq__(self, other):
9483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9484 
 
9485 
  def __ne__(self, other):
9486 
    return not (self == other)
9487 
 
9488 
class generateNewEntityID_args:
9489 
 
9490 
  thrift_spec = (
9491 
  )
9492 
 
9493 
  def read(self, iprot):
9494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9496 
      return
9497 
    iprot.readStructBegin()
9498 
    while True:
9499 
      (fname, ftype, fid) = iprot.readFieldBegin()
9500 
      if ftype == TType.STOP:
9501 
        break
9502 
      else:
9503 
        iprot.skip(ftype)
9504 
      iprot.readFieldEnd()
9505 
    iprot.readStructEnd()
9506 
 
9507 
  def write(self, oprot):
9508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9510 
      return
9511 
    oprot.writeStructBegin('generateNewEntityID_args')
9512 
    oprot.writeFieldStop()
9513 
    oprot.writeStructEnd()
9514 
 
9515 
  def validate(self):
9516 
    return
9517 
 
9518 
 
9519 
  def __repr__(self):
9520 
    L = ['%s=%r' % (key, value)
9521 
      for key, value in self.__dict__.iteritems()]
9522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9523 
 
9524 
  def __eq__(self, other):
9525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9526 
 
9527 
  def __ne__(self, other):
9528 
    return not (self == other)
9529 
 
9530 
class generateNewEntityID_result:
9531 
  """
9532 
  Attributes:
9533 
   - success
9534 
  """
9535 
 
9536 
  thrift_spec = (
9537 
    (0, TType.I64, 'success', None, None, ), # 0
9538 
  )
9539 
 
9540 
  def __init__(self, success=None,):
9541 
    self.success = success
9542 
 
9543 
  def read(self, iprot):
9544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9546 
      return
9547 
    iprot.readStructBegin()
9548 
    while True:
9549 
      (fname, ftype, fid) = iprot.readFieldBegin()
9550 
      if ftype == TType.STOP:
9551 
        break
9552 
      if fid == 0:
9553 
        if ftype == TType.I64:
9554 
          self.success = iprot.readI64();
9555 
        else:
9556 
          iprot.skip(ftype)
9557 
      else:
9558 
        iprot.skip(ftype)
9559 
      iprot.readFieldEnd()
9560 
    iprot.readStructEnd()
9561 
 
9562 
  def write(self, oprot):
9563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9565 
      return
9566 
    oprot.writeStructBegin('generateNewEntityID_result')
9567 
    if self.success is not None:
9568 
      oprot.writeFieldBegin('success', TType.I64, 0)
9569 
      oprot.writeI64(self.success)
9570 
      oprot.writeFieldEnd()
9571 
    oprot.writeFieldStop()
9572 
    oprot.writeStructEnd()
9573 
 
9574 
  def validate(self):
9575 
    return
9576 
 
9577 
 
9578 
  def __repr__(self):
9579 
    L = ['%s=%r' % (key, value)
9580 
      for key, value in self.__dict__.iteritems()]
9581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9582 
 
9583 
  def __eq__(self, other):
9584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9585 
 
9586 
  def __ne__(self, other):
9587 
    return not (self == other)
9588 
 
9589 
class addCategory_args:
9590 
  """
9591 
  Attributes:
9592 
   - category
9593 
  """
9594 
 
9595 
  thrift_spec = (
9596 
    None, # 0
9597 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9598 
  )
9599 
 
9600 
  def __init__(self, category=None,):
9601 
    self.category = category
9602 
 
9603 
  def read(self, iprot):
9604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9606 
      return
9607 
    iprot.readStructBegin()
9608 
    while True:
9609 
      (fname, ftype, fid) = iprot.readFieldBegin()
9610 
      if ftype == TType.STOP:
9611 
        break
9612 
      if fid == 1:
9613 
        if ftype == TType.STRUCT:
9614 
          self.category = Category()
9615 
          self.category.read(iprot)
9616 
        else:
9617 
          iprot.skip(ftype)
9618 
      else:
9619 
        iprot.skip(ftype)
9620 
      iprot.readFieldEnd()
9621 
    iprot.readStructEnd()
9622 
 
9623 
  def write(self, oprot):
9624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9626 
      return
9627 
    oprot.writeStructBegin('addCategory_args')
9628 
    if self.category is not None:
9629 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9630 
      self.category.write(oprot)
9631 
      oprot.writeFieldEnd()
9632 
    oprot.writeFieldStop()
9633 
    oprot.writeStructEnd()
9634 
 
9635 
  def validate(self):
9636 
    return
9637 
 
9638 
 
9639 
  def __repr__(self):
9640 
    L = ['%s=%r' % (key, value)
9641 
      for key, value in self.__dict__.iteritems()]
9642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9643 
 
9644 
  def __eq__(self, other):
9645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9646 
 
9647 
  def __ne__(self, other):
9648 
    return not (self == other)
9649 
 
9650 
class addCategory_result:
9651 
  """
9652 
  Attributes:
9653 
   - success
9654 
  """
9655 
 
9656 
  thrift_spec = (
9657 
    (0, TType.BOOL, 'success', None, None, ), # 0
9658 
  )
9659 
 
9660 
  def __init__(self, success=None,):
9661 
    self.success = success
9662 
 
9663 
  def read(self, iprot):
9664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9666 
      return
9667 
    iprot.readStructBegin()
9668 
    while True:
9669 
      (fname, ftype, fid) = iprot.readFieldBegin()
9670 
      if ftype == TType.STOP:
9671 
        break
9672 
      if fid == 0:
9673 
        if ftype == TType.BOOL:
9674 
          self.success = iprot.readBool();
9675 
        else:
9676 
          iprot.skip(ftype)
9677 
      else:
9678 
        iprot.skip(ftype)
9679 
      iprot.readFieldEnd()
9680 
    iprot.readStructEnd()
9681 
 
9682 
  def write(self, oprot):
9683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9685 
      return
9686 
    oprot.writeStructBegin('addCategory_result')
9687 
    if self.success is not None:
9688 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9689 
      oprot.writeBool(self.success)
9690 
      oprot.writeFieldEnd()
9691 
    oprot.writeFieldStop()
9692 
    oprot.writeStructEnd()
9693 
 
9694 
  def validate(self):
9695 
    return
9696 
 
9697 
 
9698 
  def __repr__(self):
9699 
    L = ['%s=%r' % (key, value)
9700 
      for key, value in self.__dict__.iteritems()]
9701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9702 
 
9703 
  def __eq__(self, other):
9704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9705 
 
9706 
  def __ne__(self, other):
9707 
    return not (self == other)
9708 
 
9709 
class getCategory_args:
9710 
  """
9711 
  Attributes:
9712 
   - id
9713 
  """
9714 
 
9715 
  thrift_spec = (
9716 
    None, # 0
9717 
    (1, TType.I64, 'id', None, None, ), # 1
9718 
  )
9719 
 
9720 
  def __init__(self, id=None,):
9721 
    self.id = id
9722 
 
9723 
  def read(self, iprot):
9724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9726 
      return
9727 
    iprot.readStructBegin()
9728 
    while True:
9729 
      (fname, ftype, fid) = iprot.readFieldBegin()
9730 
      if ftype == TType.STOP:
9731 
        break
9732 
      if fid == 1:
9733 
        if ftype == TType.I64:
9734 
          self.id = iprot.readI64();
9735 
        else:
9736 
          iprot.skip(ftype)
9737 
      else:
9738 
        iprot.skip(ftype)
9739 
      iprot.readFieldEnd()
9740 
    iprot.readStructEnd()
9741 
 
9742 
  def write(self, oprot):
9743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9745 
      return
9746 
    oprot.writeStructBegin('getCategory_args')
9747 
    if self.id is not None:
9748 
      oprot.writeFieldBegin('id', TType.I64, 1)
9749 
      oprot.writeI64(self.id)
9750 
      oprot.writeFieldEnd()
9751 
    oprot.writeFieldStop()
9752 
    oprot.writeStructEnd()
9753 
 
9754 
  def validate(self):
9755 
    return
9756 
 
9757 
 
9758 
  def __repr__(self):
9759 
    L = ['%s=%r' % (key, value)
9760 
      for key, value in self.__dict__.iteritems()]
9761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9762 
 
9763 
  def __eq__(self, other):
9764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9765 
 
9766 
  def __ne__(self, other):
9767 
    return not (self == other)
9768 
 
9769 
class getCategory_result:
9770 
  """
9771 
  Attributes:
9772 
   - success
9773 
  """
9774 
 
9775 
  thrift_spec = (
9776 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9777 
  )
9778 
 
9779 
  def __init__(self, success=None,):
9780 
    self.success = success
9781 
 
9782 
  def read(self, iprot):
9783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9785 
      return
9786 
    iprot.readStructBegin()
9787 
    while True:
9788 
      (fname, ftype, fid) = iprot.readFieldBegin()
9789 
      if ftype == TType.STOP:
9790 
        break
9791 
      if fid == 0:
9792 
        if ftype == TType.STRUCT:
9793 
          self.success = Category()
9794 
          self.success.read(iprot)
9795 
        else:
9796 
          iprot.skip(ftype)
9797 
      else:
9798 
        iprot.skip(ftype)
9799 
      iprot.readFieldEnd()
9800 
    iprot.readStructEnd()
9801 
 
9802 
  def write(self, oprot):
9803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9805 
      return
9806 
    oprot.writeStructBegin('getCategory_result')
9807 
    if self.success is not None:
9808 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9809 
      self.success.write(oprot)
9810 
      oprot.writeFieldEnd()
9811 
    oprot.writeFieldStop()
9812 
    oprot.writeStructEnd()
9813 
 
9814 
  def validate(self):
9815 
    return
9816 
 
9817 
 
9818 
  def __repr__(self):
9819 
    L = ['%s=%r' % (key, value)
9820 
      for key, value in self.__dict__.iteritems()]
9821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9822 
 
9823 
  def __eq__(self, other):
9824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9825 
 
9826 
  def __ne__(self, other):
9827 
    return not (self == other)
9828 
 
9829 
class getAllCategories_args:
9830 
 
9831 
  thrift_spec = (
9832 
  )
9833 
 
9834 
  def read(self, iprot):
9835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9837 
      return
9838 
    iprot.readStructBegin()
9839 
    while True:
9840 
      (fname, ftype, fid) = iprot.readFieldBegin()
9841 
      if ftype == TType.STOP:
9842 
        break
9843 
      else:
9844 
        iprot.skip(ftype)
9845 
      iprot.readFieldEnd()
9846 
    iprot.readStructEnd()
9847 
 
9848 
  def write(self, oprot):
9849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9851 
      return
9852 
    oprot.writeStructBegin('getAllCategories_args')
9853 
    oprot.writeFieldStop()
9854 
    oprot.writeStructEnd()
9855 
 
9856 
  def validate(self):
9857 
    return
9858 
 
9859 
 
9860 
  def __repr__(self):
9861 
    L = ['%s=%r' % (key, value)
9862 
      for key, value in self.__dict__.iteritems()]
9863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9864 
 
9865 
  def __eq__(self, other):
9866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9867 
 
9868 
  def __ne__(self, other):
9869 
    return not (self == other)
9870 
 
9871 
class getAllCategories_result:
9872 
  """
9873 
  Attributes:
9874 
   - success
9875 
  """
9876 
 
9877 
  thrift_spec = (
9878 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9879 
  )
9880 
 
9881 
  def __init__(self, success=None,):
9882 
    self.success = success
9883 
 
9884 
  def read(self, iprot):
9885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9887 
      return
9888 
    iprot.readStructBegin()
9889 
    while True:
9890 
      (fname, ftype, fid) = iprot.readFieldBegin()
9891 
      if ftype == TType.STOP:
9892 
        break
9893 
      if fid == 0:
9894 
        if ftype == TType.LIST:
9895 
          self.success = []
7438 amit.gupta 9896 
          (_etype140, _size137) = iprot.readListBegin()
9897 
          for _i141 in xrange(_size137):
9898 
            _elem142 = Category()
9899 
            _elem142.read(iprot)
9900 
            self.success.append(_elem142)
5944 mandeep.dh 9901 
          iprot.readListEnd()
9902 
        else:
9903 
          iprot.skip(ftype)
9904 
      else:
9905 
        iprot.skip(ftype)
9906 
      iprot.readFieldEnd()
9907 
    iprot.readStructEnd()
9908 
 
9909 
  def write(self, oprot):
9910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9912 
      return
9913 
    oprot.writeStructBegin('getAllCategories_result')
9914 
    if self.success is not None:
9915 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9916 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9917 
      for iter143 in self.success:
9918 
        iter143.write(oprot)
5944 mandeep.dh 9919 
      oprot.writeListEnd()
9920 
      oprot.writeFieldEnd()
9921 
    oprot.writeFieldStop()
9922 
    oprot.writeStructEnd()
9923 
 
9924 
  def validate(self):
9925 
    return
9926 
 
9927 
 
9928 
  def __repr__(self):
9929 
    L = ['%s=%r' % (key, value)
9930 
      for key, value in self.__dict__.iteritems()]
9931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9932 
 
9933 
  def __eq__(self, other):
9934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9935 
 
9936 
  def __ne__(self, other):
9937 
    return not (self == other)
9938 
 
9939 
class getAllSimilarItems_args:
9940 
  """
9941 
  Attributes:
9942 
   - itemId
9943 
  """
9944 
 
9945 
  thrift_spec = (
9946 
    None, # 0
9947 
    (1, TType.I64, 'itemId', None, None, ), # 1
9948 
  )
9949 
 
9950 
  def __init__(self, itemId=None,):
9951 
    self.itemId = itemId
9952 
 
9953 
  def read(self, iprot):
9954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9956 
      return
9957 
    iprot.readStructBegin()
9958 
    while True:
9959 
      (fname, ftype, fid) = iprot.readFieldBegin()
9960 
      if ftype == TType.STOP:
9961 
        break
9962 
      if fid == 1:
9963 
        if ftype == TType.I64:
9964 
          self.itemId = iprot.readI64();
9965 
        else:
9966 
          iprot.skip(ftype)
9967 
      else:
9968 
        iprot.skip(ftype)
9969 
      iprot.readFieldEnd()
9970 
    iprot.readStructEnd()
9971 
 
9972 
  def write(self, oprot):
9973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9975 
      return
9976 
    oprot.writeStructBegin('getAllSimilarItems_args')
9977 
    if self.itemId is not None:
9978 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9979 
      oprot.writeI64(self.itemId)
9980 
      oprot.writeFieldEnd()
9981 
    oprot.writeFieldStop()
9982 
    oprot.writeStructEnd()
9983 
 
9984 
  def validate(self):
9985 
    return
9986 
 
9987 
 
9988 
  def __repr__(self):
9989 
    L = ['%s=%r' % (key, value)
9990 
      for key, value in self.__dict__.iteritems()]
9991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9992 
 
9993 
  def __eq__(self, other):
9994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9995 
 
9996 
  def __ne__(self, other):
9997 
    return not (self == other)
9998 
 
9999 
class getAllSimilarItems_result:
10000 
  """
10001 
  Attributes:
10002 
   - success
10003 
  """
10004 
 
10005 
  thrift_spec = (
10006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10007 
  )
10008 
 
10009 
  def __init__(self, success=None,):
10010 
    self.success = success
10011 
 
10012 
  def read(self, iprot):
10013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10015 
      return
10016 
    iprot.readStructBegin()
10017 
    while True:
10018 
      (fname, ftype, fid) = iprot.readFieldBegin()
10019 
      if ftype == TType.STOP:
10020 
        break
10021 
      if fid == 0:
10022 
        if ftype == TType.LIST:
10023 
          self.success = []
7438 amit.gupta 10024 
          (_etype147, _size144) = iprot.readListBegin()
10025 
          for _i148 in xrange(_size144):
10026 
            _elem149 = Item()
10027 
            _elem149.read(iprot)
10028 
            self.success.append(_elem149)
5944 mandeep.dh 10029 
          iprot.readListEnd()
10030 
        else:
10031 
          iprot.skip(ftype)
10032 
      else:
10033 
        iprot.skip(ftype)
10034 
      iprot.readFieldEnd()
10035 
    iprot.readStructEnd()
10036 
 
10037 
  def write(self, oprot):
10038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10040 
      return
10041 
    oprot.writeStructBegin('getAllSimilarItems_result')
10042 
    if self.success is not None:
10043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 10045 
      for iter150 in self.success:
10046 
        iter150.write(oprot)
5944 mandeep.dh 10047 
      oprot.writeListEnd()
10048 
      oprot.writeFieldEnd()
10049 
    oprot.writeFieldStop()
10050 
    oprot.writeStructEnd()
10051 
 
10052 
  def validate(self):
10053 
    return
10054 
 
10055 
 
10056 
  def __repr__(self):
10057 
    L = ['%s=%r' % (key, value)
10058 
      for key, value in self.__dict__.iteritems()]
10059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10060 
 
10061 
  def __eq__(self, other):
10062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10063 
 
10064 
  def __ne__(self, other):
10065 
    return not (self == other)
10066 
 
10067 
class addSimilarItem_args:
10068 
  """
10069 
  Attributes:
10070 
   - itemId
10071 
   - catalogItemId
10072 
  """
10073 
 
10074 
  thrift_spec = (
10075 
    None, # 0
10076 
    (1, TType.I64, 'itemId', None, None, ), # 1
10077 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
10078 
  )
10079 
 
10080 
  def __init__(self, itemId=None, catalogItemId=None,):
10081 
    self.itemId = itemId
10082 
    self.catalogItemId = catalogItemId
10083 
 
10084 
  def read(self, iprot):
10085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10087 
      return
10088 
    iprot.readStructBegin()
10089 
    while True:
10090 
      (fname, ftype, fid) = iprot.readFieldBegin()
10091 
      if ftype == TType.STOP:
10092 
        break
10093 
      if fid == 1:
10094 
        if ftype == TType.I64:
10095 
          self.itemId = iprot.readI64();
10096 
        else:
10097 
          iprot.skip(ftype)
10098 
      elif fid == 2:
10099 
        if ftype == TType.I64:
10100 
          self.catalogItemId = iprot.readI64();
10101 
        else:
10102 
          iprot.skip(ftype)
10103 
      else:
10104 
        iprot.skip(ftype)
10105 
      iprot.readFieldEnd()
10106 
    iprot.readStructEnd()
10107 
 
10108 
  def write(self, oprot):
10109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10111 
      return
10112 
    oprot.writeStructBegin('addSimilarItem_args')
10113 
    if self.itemId is not None:
10114 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10115 
      oprot.writeI64(self.itemId)
10116 
      oprot.writeFieldEnd()
10117 
    if self.catalogItemId is not None:
10118 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
10119 
      oprot.writeI64(self.catalogItemId)
10120 
      oprot.writeFieldEnd()
10121 
    oprot.writeFieldStop()
10122 
    oprot.writeStructEnd()
10123 
 
10124 
  def validate(self):
10125 
    return
10126 
 
10127 
 
10128 
  def __repr__(self):
10129 
    L = ['%s=%r' % (key, value)
10130 
      for key, value in self.__dict__.iteritems()]
10131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10132 
 
10133 
  def __eq__(self, other):
10134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10135 
 
10136 
  def __ne__(self, other):
10137 
    return not (self == other)
10138 
 
10139 
class addSimilarItem_result:
10140 
  """
10141 
  Attributes:
10142 
   - success
10143 
   - cex
10144 
  """
10145 
 
10146 
  thrift_spec = (
10147 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
10148 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10149 
  )
10150 
 
10151 
  def __init__(self, success=None, cex=None,):
10152 
    self.success = success
10153 
    self.cex = cex
10154 
 
10155 
  def read(self, iprot):
10156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10158 
      return
10159 
    iprot.readStructBegin()
10160 
    while True:
10161 
      (fname, ftype, fid) = iprot.readFieldBegin()
10162 
      if ftype == TType.STOP:
10163 
        break
10164 
      if fid == 0:
10165 
        if ftype == TType.STRUCT:
10166 
          self.success = Item()
10167 
          self.success.read(iprot)
10168 
        else:
10169 
          iprot.skip(ftype)
10170 
      elif fid == 1:
10171 
        if ftype == TType.STRUCT:
10172 
          self.cex = CatalogServiceException()
10173 
          self.cex.read(iprot)
10174 
        else:
10175 
          iprot.skip(ftype)
10176 
      else:
10177 
        iprot.skip(ftype)
10178 
      iprot.readFieldEnd()
10179 
    iprot.readStructEnd()
10180 
 
10181 
  def write(self, oprot):
10182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10184 
      return
10185 
    oprot.writeStructBegin('addSimilarItem_result')
10186 
    if self.success is not None:
10187 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10188 
      self.success.write(oprot)
10189 
      oprot.writeFieldEnd()
10190 
    if self.cex is not None:
10191 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10192 
      self.cex.write(oprot)
10193 
      oprot.writeFieldEnd()
10194 
    oprot.writeFieldStop()
10195 
    oprot.writeStructEnd()
10196 
 
10197 
  def validate(self):
10198 
    return
10199 
 
10200 
 
10201 
  def __repr__(self):
10202 
    L = ['%s=%r' % (key, value)
10203 
      for key, value in self.__dict__.iteritems()]
10204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10205 
 
10206 
  def __eq__(self, other):
10207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10208 
 
10209 
  def __ne__(self, other):
10210 
    return not (self == other)
10211 
 
6512 kshitij.so 10212 
class addTag_args:
10213 
  """
10214 
  Attributes:
10215 
   - displayName
10216 
   - itemId
10217 
  """
10218 
 
10219 
  thrift_spec = (
10220 
    None, # 0
10221 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10222 
    (2, TType.I64, 'itemId', None, None, ), # 2
10223 
  )
10224 
 
10225 
  def __init__(self, displayName=None, itemId=None,):
10226 
    self.displayName = displayName
10227 
    self.itemId = itemId
10228 
 
10229 
  def read(self, iprot):
10230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10232 
      return
10233 
    iprot.readStructBegin()
10234 
    while True:
10235 
      (fname, ftype, fid) = iprot.readFieldBegin()
10236 
      if ftype == TType.STOP:
10237 
        break
10238 
      if fid == 1:
10239 
        if ftype == TType.STRING:
10240 
          self.displayName = iprot.readString();
10241 
        else:
10242 
          iprot.skip(ftype)
10243 
      elif fid == 2:
10244 
        if ftype == TType.I64:
10245 
          self.itemId = iprot.readI64();
10246 
        else:
10247 
          iprot.skip(ftype)
10248 
      else:
10249 
        iprot.skip(ftype)
10250 
      iprot.readFieldEnd()
10251 
    iprot.readStructEnd()
10252 
 
10253 
  def write(self, oprot):
10254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10256 
      return
10257 
    oprot.writeStructBegin('addTag_args')
10258 
    if self.displayName is not None:
10259 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10260 
      oprot.writeString(self.displayName)
10261 
      oprot.writeFieldEnd()
10262 
    if self.itemId is not None:
10263 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10264 
      oprot.writeI64(self.itemId)
10265 
      oprot.writeFieldEnd()
10266 
    oprot.writeFieldStop()
10267 
    oprot.writeStructEnd()
10268 
 
10269 
  def validate(self):
10270 
    return
10271 
 
10272 
 
10273 
  def __repr__(self):
10274 
    L = ['%s=%r' % (key, value)
10275 
      for key, value in self.__dict__.iteritems()]
10276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10277 
 
10278 
  def __eq__(self, other):
10279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10280 
 
10281 
  def __ne__(self, other):
10282 
    return not (self == other)
10283 
 
10284 
class addTag_result:
10285 
  """
10286 
  Attributes:
10287 
   - success
10288 
  """
10289 
 
10290 
  thrift_spec = (
10291 
    (0, TType.BOOL, 'success', None, None, ), # 0
10292 
  )
10293 
 
10294 
  def __init__(self, success=None,):
10295 
    self.success = success
10296 
 
10297 
  def read(self, iprot):
10298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10300 
      return
10301 
    iprot.readStructBegin()
10302 
    while True:
10303 
      (fname, ftype, fid) = iprot.readFieldBegin()
10304 
      if ftype == TType.STOP:
10305 
        break
10306 
      if fid == 0:
10307 
        if ftype == TType.BOOL:
10308 
          self.success = iprot.readBool();
10309 
        else:
10310 
          iprot.skip(ftype)
10311 
      else:
10312 
        iprot.skip(ftype)
10313 
      iprot.readFieldEnd()
10314 
    iprot.readStructEnd()
10315 
 
10316 
  def write(self, oprot):
10317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10319 
      return
10320 
    oprot.writeStructBegin('addTag_result')
10321 
    if self.success is not None:
10322 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10323 
      oprot.writeBool(self.success)
10324 
      oprot.writeFieldEnd()
10325 
    oprot.writeFieldStop()
10326 
    oprot.writeStructEnd()
10327 
 
10328 
  def validate(self):
10329 
    return
10330 
 
10331 
 
10332 
  def __repr__(self):
10333 
    L = ['%s=%r' % (key, value)
10334 
      for key, value in self.__dict__.iteritems()]
10335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10336 
 
10337 
  def __eq__(self, other):
10338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10339 
 
10340 
  def __ne__(self, other):
10341 
    return not (self == other)
10342 
 
10343 
class deleteEntityTag_args:
10344 
  """
10345 
  Attributes:
10346 
   - displayName
10347 
   - itemId
10348 
  """
10349 
 
10350 
  thrift_spec = (
10351 
    None, # 0
10352 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10353 
    (2, TType.I64, 'itemId', None, None, ), # 2
10354 
  )
10355 
 
10356 
  def __init__(self, displayName=None, itemId=None,):
10357 
    self.displayName = displayName
10358 
    self.itemId = itemId
10359 
 
10360 
  def read(self, iprot):
10361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10363 
      return
10364 
    iprot.readStructBegin()
10365 
    while True:
10366 
      (fname, ftype, fid) = iprot.readFieldBegin()
10367 
      if ftype == TType.STOP:
10368 
        break
10369 
      if fid == 1:
10370 
        if ftype == TType.STRING:
10371 
          self.displayName = iprot.readString();
10372 
        else:
10373 
          iprot.skip(ftype)
10374 
      elif fid == 2:
10375 
        if ftype == TType.I64:
10376 
          self.itemId = iprot.readI64();
10377 
        else:
10378 
          iprot.skip(ftype)
10379 
      else:
10380 
        iprot.skip(ftype)
10381 
      iprot.readFieldEnd()
10382 
    iprot.readStructEnd()
10383 
 
10384 
  def write(self, oprot):
10385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10387 
      return
10388 
    oprot.writeStructBegin('deleteEntityTag_args')
10389 
    if self.displayName is not None:
10390 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10391 
      oprot.writeString(self.displayName)
10392 
      oprot.writeFieldEnd()
10393 
    if self.itemId is not None:
10394 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10395 
      oprot.writeI64(self.itemId)
10396 
      oprot.writeFieldEnd()
10397 
    oprot.writeFieldStop()
10398 
    oprot.writeStructEnd()
10399 
 
10400 
  def validate(self):
10401 
    return
10402 
 
10403 
 
10404 
  def __repr__(self):
10405 
    L = ['%s=%r' % (key, value)
10406 
      for key, value in self.__dict__.iteritems()]
10407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10408 
 
10409 
  def __eq__(self, other):
10410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10411 
 
10412 
  def __ne__(self, other):
10413 
    return not (self == other)
10414 
 
10415 
class deleteEntityTag_result:
10416 
  """
10417 
  Attributes:
10418 
   - success
10419 
  """
10420 
 
10421 
  thrift_spec = (
10422 
    (0, TType.BOOL, 'success', None, None, ), # 0
10423 
  )
10424 
 
10425 
  def __init__(self, success=None,):
10426 
    self.success = success
10427 
 
10428 
  def read(self, iprot):
10429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10431 
      return
10432 
    iprot.readStructBegin()
10433 
    while True:
10434 
      (fname, ftype, fid) = iprot.readFieldBegin()
10435 
      if ftype == TType.STOP:
10436 
        break
10437 
      if fid == 0:
10438 
        if ftype == TType.BOOL:
10439 
          self.success = iprot.readBool();
10440 
        else:
10441 
          iprot.skip(ftype)
10442 
      else:
10443 
        iprot.skip(ftype)
10444 
      iprot.readFieldEnd()
10445 
    iprot.readStructEnd()
10446 
 
10447 
  def write(self, oprot):
10448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10450 
      return
10451 
    oprot.writeStructBegin('deleteEntityTag_result')
10452 
    if self.success is not None:
10453 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10454 
      oprot.writeBool(self.success)
10455 
      oprot.writeFieldEnd()
10456 
    oprot.writeFieldStop()
10457 
    oprot.writeStructEnd()
10458 
 
10459 
  def validate(self):
10460 
    return
10461 
 
10462 
 
10463 
  def __repr__(self):
10464 
    L = ['%s=%r' % (key, value)
10465 
      for key, value in self.__dict__.iteritems()]
10466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10467 
 
10468 
  def __eq__(self, other):
10469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10470 
 
10471 
  def __ne__(self, other):
10472 
    return not (self == other)
10473 
 
10474 
class deleteTag_args:
10475 
  """
10476 
  Attributes:
10477 
   - displayName
10478 
  """
10479 
 
10480 
  thrift_spec = (
10481 
    None, # 0
10482 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10483 
  )
10484 
 
10485 
  def __init__(self, displayName=None,):
10486 
    self.displayName = displayName
10487 
 
10488 
  def read(self, iprot):
10489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10491 
      return
10492 
    iprot.readStructBegin()
10493 
    while True:
10494 
      (fname, ftype, fid) = iprot.readFieldBegin()
10495 
      if ftype == TType.STOP:
10496 
        break
10497 
      if fid == 1:
10498 
        if ftype == TType.STRING:
10499 
          self.displayName = iprot.readString();
10500 
        else:
10501 
          iprot.skip(ftype)
10502 
      else:
10503 
        iprot.skip(ftype)
10504 
      iprot.readFieldEnd()
10505 
    iprot.readStructEnd()
10506 
 
10507 
  def write(self, oprot):
10508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10510 
      return
10511 
    oprot.writeStructBegin('deleteTag_args')
10512 
    if self.displayName is not None:
10513 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10514 
      oprot.writeString(self.displayName)
10515 
      oprot.writeFieldEnd()
10516 
    oprot.writeFieldStop()
10517 
    oprot.writeStructEnd()
10518 
 
10519 
  def validate(self):
10520 
    return
10521 
 
10522 
 
10523 
  def __repr__(self):
10524 
    L = ['%s=%r' % (key, value)
10525 
      for key, value in self.__dict__.iteritems()]
10526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10527 
 
10528 
  def __eq__(self, other):
10529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10530 
 
10531 
  def __ne__(self, other):
10532 
    return not (self == other)
10533 
 
10534 
class deleteTag_result:
10535 
  """
10536 
  Attributes:
10537 
   - success
10538 
  """
10539 
 
10540 
  thrift_spec = (
10541 
    (0, TType.BOOL, 'success', None, None, ), # 0
10542 
  )
10543 
 
10544 
  def __init__(self, success=None,):
10545 
    self.success = success
10546 
 
10547 
  def read(self, iprot):
10548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10550 
      return
10551 
    iprot.readStructBegin()
10552 
    while True:
10553 
      (fname, ftype, fid) = iprot.readFieldBegin()
10554 
      if ftype == TType.STOP:
10555 
        break
10556 
      if fid == 0:
10557 
        if ftype == TType.BOOL:
10558 
          self.success = iprot.readBool();
10559 
        else:
10560 
          iprot.skip(ftype)
10561 
      else:
10562 
        iprot.skip(ftype)
10563 
      iprot.readFieldEnd()
10564 
    iprot.readStructEnd()
10565 
 
10566 
  def write(self, oprot):
10567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10569 
      return
10570 
    oprot.writeStructBegin('deleteTag_result')
10571 
    if self.success is not None:
10572 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10573 
      oprot.writeBool(self.success)
10574 
      oprot.writeFieldEnd()
10575 
    oprot.writeFieldStop()
10576 
    oprot.writeStructEnd()
10577 
 
10578 
  def validate(self):
10579 
    return
10580 
 
10581 
 
10582 
  def __repr__(self):
10583 
    L = ['%s=%r' % (key, value)
10584 
      for key, value in self.__dict__.iteritems()]
10585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10586 
 
10587 
  def __eq__(self, other):
10588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10589 
 
10590 
  def __ne__(self, other):
10591 
    return not (self == other)
10592 
 
10593 
class getAllTags_args:
10594 
 
10595 
  thrift_spec = (
10596 
  )
10597 
 
10598 
  def read(self, iprot):
10599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10601 
      return
10602 
    iprot.readStructBegin()
10603 
    while True:
10604 
      (fname, ftype, fid) = iprot.readFieldBegin()
10605 
      if ftype == TType.STOP:
10606 
        break
10607 
      else:
10608 
        iprot.skip(ftype)
10609 
      iprot.readFieldEnd()
10610 
    iprot.readStructEnd()
10611 
 
10612 
  def write(self, oprot):
10613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10615 
      return
10616 
    oprot.writeStructBegin('getAllTags_args')
10617 
    oprot.writeFieldStop()
10618 
    oprot.writeStructEnd()
10619 
 
10620 
  def validate(self):
10621 
    return
10622 
 
10623 
 
10624 
  def __repr__(self):
10625 
    L = ['%s=%r' % (key, value)
10626 
      for key, value in self.__dict__.iteritems()]
10627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10628 
 
10629 
  def __eq__(self, other):
10630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10631 
 
10632 
  def __ne__(self, other):
10633 
    return not (self == other)
10634 
 
10635 
class getAllTags_result:
10636 
  """
10637 
  Attributes:
10638 
   - success
10639 
  """
10640 
 
10641 
  thrift_spec = (
10642 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10643 
  )
10644 
 
10645 
  def __init__(self, success=None,):
10646 
    self.success = success
10647 
 
10648 
  def read(self, iprot):
10649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10651 
      return
10652 
    iprot.readStructBegin()
10653 
    while True:
10654 
      (fname, ftype, fid) = iprot.readFieldBegin()
10655 
      if ftype == TType.STOP:
10656 
        break
10657 
      if fid == 0:
10658 
        if ftype == TType.LIST:
10659 
          self.success = []
7438 amit.gupta 10660 
          (_etype154, _size151) = iprot.readListBegin()
10661 
          for _i155 in xrange(_size151):
10662 
            _elem156 = iprot.readString();
10663 
            self.success.append(_elem156)
6512 kshitij.so 10664 
          iprot.readListEnd()
10665 
        else:
10666 
          iprot.skip(ftype)
10667 
      else:
10668 
        iprot.skip(ftype)
10669 
      iprot.readFieldEnd()
10670 
    iprot.readStructEnd()
10671 
 
10672 
  def write(self, oprot):
10673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10675 
      return
10676 
    oprot.writeStructBegin('getAllTags_result')
10677 
    if self.success is not None:
10678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10679 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10680 
      for iter157 in self.success:
10681 
        oprot.writeString(iter157)
6512 kshitij.so 10682 
      oprot.writeListEnd()
10683 
      oprot.writeFieldEnd()
10684 
    oprot.writeFieldStop()
10685 
    oprot.writeStructEnd()
10686 
 
10687 
  def validate(self):
10688 
    return
10689 
 
10690 
 
10691 
  def __repr__(self):
10692 
    L = ['%s=%r' % (key, value)
10693 
      for key, value in self.__dict__.iteritems()]
10694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10695 
 
10696 
  def __eq__(self, other):
10697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10698 
 
10699 
  def __ne__(self, other):
10700 
    return not (self == other)
10701 
 
10702 
class getAllEntitiesByTagName_args:
10703 
  """
10704 
  Attributes:
10705 
   - displayName
10706 
  """
10707 
 
10708 
  thrift_spec = (
10709 
    None, # 0
10710 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10711 
  )
10712 
 
10713 
  def __init__(self, displayName=None,):
10714 
    self.displayName = displayName
10715 
 
10716 
  def read(self, iprot):
10717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10719 
      return
10720 
    iprot.readStructBegin()
10721 
    while True:
10722 
      (fname, ftype, fid) = iprot.readFieldBegin()
10723 
      if ftype == TType.STOP:
10724 
        break
10725 
      if fid == 1:
10726 
        if ftype == TType.STRING:
10727 
          self.displayName = iprot.readString();
10728 
        else:
10729 
          iprot.skip(ftype)
10730 
      else:
10731 
        iprot.skip(ftype)
10732 
      iprot.readFieldEnd()
10733 
    iprot.readStructEnd()
10734 
 
10735 
  def write(self, oprot):
10736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10738 
      return
10739 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10740 
    if self.displayName is not None:
10741 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10742 
      oprot.writeString(self.displayName)
10743 
      oprot.writeFieldEnd()
10744 
    oprot.writeFieldStop()
10745 
    oprot.writeStructEnd()
10746 
 
10747 
  def validate(self):
10748 
    return
10749 
 
10750 
 
10751 
  def __repr__(self):
10752 
    L = ['%s=%r' % (key, value)
10753 
      for key, value in self.__dict__.iteritems()]
10754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10755 
 
10756 
  def __eq__(self, other):
10757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10758 
 
10759 
  def __ne__(self, other):
10760 
    return not (self == other)
10761 
 
10762 
class getAllEntitiesByTagName_result:
10763 
  """
10764 
  Attributes:
10765 
   - success
10766 
  """
10767 
 
10768 
  thrift_spec = (
10769 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10770 
  )
10771 
 
10772 
  def __init__(self, success=None,):
10773 
    self.success = success
10774 
 
10775 
  def read(self, iprot):
10776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10778 
      return
10779 
    iprot.readStructBegin()
10780 
    while True:
10781 
      (fname, ftype, fid) = iprot.readFieldBegin()
10782 
      if ftype == TType.STOP:
10783 
        break
10784 
      if fid == 0:
10785 
        if ftype == TType.LIST:
10786 
          self.success = []
7438 amit.gupta 10787 
          (_etype161, _size158) = iprot.readListBegin()
10788 
          for _i162 in xrange(_size158):
10789 
            _elem163 = iprot.readI64();
10790 
            self.success.append(_elem163)
6512 kshitij.so 10791 
          iprot.readListEnd()
10792 
        else:
10793 
          iprot.skip(ftype)
10794 
      else:
10795 
        iprot.skip(ftype)
10796 
      iprot.readFieldEnd()
10797 
    iprot.readStructEnd()
10798 
 
10799 
  def write(self, oprot):
10800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10802 
      return
10803 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10804 
    if self.success is not None:
10805 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10806 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10807 
      for iter164 in self.success:
10808 
        oprot.writeI64(iter164)
6512 kshitij.so 10809 
      oprot.writeListEnd()
10810 
      oprot.writeFieldEnd()
10811 
    oprot.writeFieldStop()
10812 
    oprot.writeStructEnd()
10813 
 
10814 
  def validate(self):
10815 
    return
10816 
 
10817 
 
10818 
  def __repr__(self):
10819 
    L = ['%s=%r' % (key, value)
10820 
      for key, value in self.__dict__.iteritems()]
10821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10822 
 
10823 
  def __eq__(self, other):
10824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10825 
 
10826 
  def __ne__(self, other):
10827 
    return not (self == other)
10828 
 
6845 amit.gupta 10829 
class getAllEntityTags_args:
10830 
 
10831 
  thrift_spec = (
10832 
  )
10833 
 
10834 
  def read(self, iprot):
10835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10837 
      return
10838 
    iprot.readStructBegin()
10839 
    while True:
10840 
      (fname, ftype, fid) = iprot.readFieldBegin()
10841 
      if ftype == TType.STOP:
10842 
        break
10843 
      else:
10844 
        iprot.skip(ftype)
10845 
      iprot.readFieldEnd()
10846 
    iprot.readStructEnd()
10847 
 
10848 
  def write(self, oprot):
10849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10851 
      return
10852 
    oprot.writeStructBegin('getAllEntityTags_args')
10853 
    oprot.writeFieldStop()
10854 
    oprot.writeStructEnd()
10855 
 
10856 
  def validate(self):
10857 
    return
10858 
 
10859 
 
10860 
  def __repr__(self):
10861 
    L = ['%s=%r' % (key, value)
10862 
      for key, value in self.__dict__.iteritems()]
10863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10864 
 
10865 
  def __eq__(self, other):
10866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10867 
 
10868 
  def __ne__(self, other):
10869 
    return not (self == other)
10870 
 
10871 
class getAllEntityTags_result:
10872 
  """
10873 
  Attributes:
10874 
   - success
10875 
  """
10876 
 
10877 
  thrift_spec = (
10878 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10879 
  )
10880 
 
10881 
  def __init__(self, success=None,):
10882 
    self.success = success
10883 
 
10884 
  def read(self, iprot):
10885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10887 
      return
10888 
    iprot.readStructBegin()
10889 
    while True:
10890 
      (fname, ftype, fid) = iprot.readFieldBegin()
10891 
      if ftype == TType.STOP:
10892 
        break
10893 
      if fid == 0:
10894 
        if ftype == TType.MAP:
10895 
          self.success = {}
7438 amit.gupta 10896 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10897 
          for _i169 in xrange(_size165):
10898 
            _key170 = iprot.readI64();
10899 
            _val171 = []
10900 
            (_etype175, _size172) = iprot.readListBegin()
10901 
            for _i176 in xrange(_size172):
10902 
              _elem177 = iprot.readString();
10903 
              _val171.append(_elem177)
6845 amit.gupta 10904 
            iprot.readListEnd()
7438 amit.gupta 10905 
            self.success[_key170] = _val171
6845 amit.gupta 10906 
          iprot.readMapEnd()
10907 
        else:
10908 
          iprot.skip(ftype)
10909 
      else:
10910 
        iprot.skip(ftype)
10911 
      iprot.readFieldEnd()
10912 
    iprot.readStructEnd()
10913 
 
10914 
  def write(self, oprot):
10915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10917 
      return
10918 
    oprot.writeStructBegin('getAllEntityTags_result')
10919 
    if self.success is not None:
10920 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10921 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 10922 
      for kiter178,viter179 in self.success.items():
10923 
        oprot.writeI64(kiter178)
10924 
        oprot.writeListBegin(TType.STRING, len(viter179))
10925 
        for iter180 in viter179:
10926 
          oprot.writeString(iter180)
6845 amit.gupta 10927 
        oprot.writeListEnd()
10928 
      oprot.writeMapEnd()
10929 
      oprot.writeFieldEnd()
10930 
    oprot.writeFieldStop()
10931 
    oprot.writeStructEnd()
10932 
 
10933 
  def validate(self):
10934 
    return
10935 
 
10936 
 
10937 
  def __repr__(self):
10938 
    L = ['%s=%r' % (key, value)
10939 
      for key, value in self.__dict__.iteritems()]
10940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10941 
 
10942 
  def __eq__(self, other):
10943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10944 
 
10945 
  def __ne__(self, other):
10946 
    return not (self == other)
10947 
 
6850 kshitij.so 10948 
class addBanner_args:
10949 
  """
10950 
  Attributes:
10951 
   - bannerName
10952 
   - imageName
10953 
   - link
10954 
   - priority
10955 
   - isActive
10956 
   - hasMap
10957 
  """
10958 
 
10959 
  thrift_spec = (
10960 
    None, # 0
10961 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10962 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10963 
    (3, TType.STRING, 'link', None, None, ), # 3
10964 
    (4, TType.I64, 'priority', None, None, ), # 4
10965 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10966 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10967 
  )
10968 
 
10969 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10970 
    self.bannerName = bannerName
10971 
    self.imageName = imageName
10972 
    self.link = link
10973 
    self.priority = priority
10974 
    self.isActive = isActive
10975 
    self.hasMap = hasMap
10976 
 
10977 
  def read(self, iprot):
10978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10980 
      return
10981 
    iprot.readStructBegin()
10982 
    while True:
10983 
      (fname, ftype, fid) = iprot.readFieldBegin()
10984 
      if ftype == TType.STOP:
10985 
        break
10986 
      if fid == 1:
10987 
        if ftype == TType.STRING:
10988 
          self.bannerName = iprot.readString();
10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      elif fid == 2:
10992 
        if ftype == TType.STRING:
10993 
          self.imageName = iprot.readString();
10994 
        else:
10995 
          iprot.skip(ftype)
10996 
      elif fid == 3:
10997 
        if ftype == TType.STRING:
10998 
          self.link = iprot.readString();
10999 
        else:
11000 
          iprot.skip(ftype)
11001 
      elif fid == 4:
11002 
        if ftype == TType.I64:
11003 
          self.priority = iprot.readI64();
11004 
        else:
11005 
          iprot.skip(ftype)
11006 
      elif fid == 5:
11007 
        if ftype == TType.BOOL:
11008 
          self.isActive = iprot.readBool();
11009 
        else:
11010 
          iprot.skip(ftype)
11011 
      elif fid == 6:
11012 
        if ftype == TType.BOOL:
11013 
          self.hasMap = iprot.readBool();
11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      else:
11017 
        iprot.skip(ftype)
11018 
      iprot.readFieldEnd()
11019 
    iprot.readStructEnd()
11020 
 
11021 
  def write(self, oprot):
11022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11024 
      return
11025 
    oprot.writeStructBegin('addBanner_args')
11026 
    if self.bannerName is not None:
11027 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11028 
      oprot.writeString(self.bannerName)
11029 
      oprot.writeFieldEnd()
11030 
    if self.imageName is not None:
11031 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
11032 
      oprot.writeString(self.imageName)
11033 
      oprot.writeFieldEnd()
11034 
    if self.link is not None:
11035 
      oprot.writeFieldBegin('link', TType.STRING, 3)
11036 
      oprot.writeString(self.link)
11037 
      oprot.writeFieldEnd()
11038 
    if self.priority is not None:
11039 
      oprot.writeFieldBegin('priority', TType.I64, 4)
11040 
      oprot.writeI64(self.priority)
11041 
      oprot.writeFieldEnd()
11042 
    if self.isActive is not None:
11043 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
11044 
      oprot.writeBool(self.isActive)
11045 
      oprot.writeFieldEnd()
11046 
    if self.hasMap is not None:
11047 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
11048 
      oprot.writeBool(self.hasMap)
11049 
      oprot.writeFieldEnd()
11050 
    oprot.writeFieldStop()
11051 
    oprot.writeStructEnd()
11052 
 
11053 
  def validate(self):
11054 
    return
11055 
 
11056 
 
11057 
  def __repr__(self):
11058 
    L = ['%s=%r' % (key, value)
11059 
      for key, value in self.__dict__.iteritems()]
11060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11061 
 
11062 
  def __eq__(self, other):
11063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11064 
 
11065 
  def __ne__(self, other):
11066 
    return not (self == other)
11067 
 
11068 
class addBanner_result:
11069 
  """
11070 
  Attributes:
11071 
   - success
11072 
  """
11073 
 
11074 
  thrift_spec = (
11075 
    (0, TType.BOOL, 'success', None, None, ), # 0
11076 
  )
11077 
 
11078 
  def __init__(self, success=None,):
11079 
    self.success = success
11080 
 
11081 
  def read(self, iprot):
11082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11084 
      return
11085 
    iprot.readStructBegin()
11086 
    while True:
11087 
      (fname, ftype, fid) = iprot.readFieldBegin()
11088 
      if ftype == TType.STOP:
11089 
        break
11090 
      if fid == 0:
11091 
        if ftype == TType.BOOL:
11092 
          self.success = iprot.readBool();
11093 
        else:
11094 
          iprot.skip(ftype)
11095 
      else:
11096 
        iprot.skip(ftype)
11097 
      iprot.readFieldEnd()
11098 
    iprot.readStructEnd()
11099 
 
11100 
  def write(self, oprot):
11101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11103 
      return
11104 
    oprot.writeStructBegin('addBanner_result')
11105 
    if self.success is not None:
11106 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11107 
      oprot.writeBool(self.success)
11108 
      oprot.writeFieldEnd()
11109 
    oprot.writeFieldStop()
11110 
    oprot.writeStructEnd()
11111 
 
11112 
  def validate(self):
11113 
    return
11114 
 
11115 
 
11116 
  def __repr__(self):
11117 
    L = ['%s=%r' % (key, value)
11118 
      for key, value in self.__dict__.iteritems()]
11119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11120 
 
11121 
  def __eq__(self, other):
11122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11123 
 
11124 
  def __ne__(self, other):
11125 
    return not (self == other)
11126 
 
11127 
class getAllBanners_args:
11128 
 
11129 
  thrift_spec = (
11130 
  )
11131 
 
11132 
  def read(self, iprot):
11133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11135 
      return
11136 
    iprot.readStructBegin()
11137 
    while True:
11138 
      (fname, ftype, fid) = iprot.readFieldBegin()
11139 
      if ftype == TType.STOP:
11140 
        break
11141 
      else:
11142 
        iprot.skip(ftype)
11143 
      iprot.readFieldEnd()
11144 
    iprot.readStructEnd()
11145 
 
11146 
  def write(self, oprot):
11147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11149 
      return
11150 
    oprot.writeStructBegin('getAllBanners_args')
11151 
    oprot.writeFieldStop()
11152 
    oprot.writeStructEnd()
11153 
 
11154 
  def validate(self):
11155 
    return
11156 
 
11157 
 
11158 
  def __repr__(self):
11159 
    L = ['%s=%r' % (key, value)
11160 
      for key, value in self.__dict__.iteritems()]
11161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11162 
 
11163 
  def __eq__(self, other):
11164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11165 
 
11166 
  def __ne__(self, other):
11167 
    return not (self == other)
11168 
 
11169 
class getAllBanners_result:
11170 
  """
11171 
  Attributes:
11172 
   - success
11173 
  """
11174 
 
11175 
  thrift_spec = (
11176 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11177 
  )
11178 
 
11179 
  def __init__(self, success=None,):
11180 
    self.success = success
11181 
 
11182 
  def read(self, iprot):
11183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11185 
      return
11186 
    iprot.readStructBegin()
11187 
    while True:
11188 
      (fname, ftype, fid) = iprot.readFieldBegin()
11189 
      if ftype == TType.STOP:
11190 
        break
11191 
      if fid == 0:
11192 
        if ftype == TType.LIST:
11193 
          self.success = []
7438 amit.gupta 11194 
          (_etype184, _size181) = iprot.readListBegin()
11195 
          for _i185 in xrange(_size181):
11196 
            _elem186 = iprot.readString();
11197 
            self.success.append(_elem186)
6850 kshitij.so 11198 
          iprot.readListEnd()
11199 
        else:
11200 
          iprot.skip(ftype)
11201 
      else:
11202 
        iprot.skip(ftype)
11203 
      iprot.readFieldEnd()
11204 
    iprot.readStructEnd()
11205 
 
11206 
  def write(self, oprot):
11207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11209 
      return
11210 
    oprot.writeStructBegin('getAllBanners_result')
11211 
    if self.success is not None:
11212 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11213 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 11214 
      for iter187 in self.success:
11215 
        oprot.writeString(iter187)
6850 kshitij.so 11216 
      oprot.writeListEnd()
11217 
      oprot.writeFieldEnd()
11218 
    oprot.writeFieldStop()
11219 
    oprot.writeStructEnd()
11220 
 
11221 
  def validate(self):
11222 
    return
11223 
 
11224 
 
11225 
  def __repr__(self):
11226 
    L = ['%s=%r' % (key, value)
11227 
      for key, value in self.__dict__.iteritems()]
11228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11229 
 
11230 
  def __eq__(self, other):
11231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11232 
 
11233 
  def __ne__(self, other):
11234 
    return not (self == other)
11235 
 
11236 
class deleteBanner_args:
11237 
  """
11238 
  Attributes:
11239 
   - bannerName
11240 
  """
11241 
 
11242 
  thrift_spec = (
11243 
    None, # 0
11244 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11245 
  )
11246 
 
11247 
  def __init__(self, bannerName=None,):
11248 
    self.bannerName = bannerName
11249 
 
11250 
  def read(self, iprot):
11251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11253 
      return
11254 
    iprot.readStructBegin()
11255 
    while True:
11256 
      (fname, ftype, fid) = iprot.readFieldBegin()
11257 
      if ftype == TType.STOP:
11258 
        break
11259 
      if fid == 1:
11260 
        if ftype == TType.STRING:
11261 
          self.bannerName = iprot.readString();
11262 
        else:
11263 
          iprot.skip(ftype)
11264 
      else:
11265 
        iprot.skip(ftype)
11266 
      iprot.readFieldEnd()
11267 
    iprot.readStructEnd()
11268 
 
11269 
  def write(self, oprot):
11270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11272 
      return
11273 
    oprot.writeStructBegin('deleteBanner_args')
11274 
    if self.bannerName is not None:
11275 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11276 
      oprot.writeString(self.bannerName)
11277 
      oprot.writeFieldEnd()
11278 
    oprot.writeFieldStop()
11279 
    oprot.writeStructEnd()
11280 
 
11281 
  def validate(self):
11282 
    return
11283 
 
11284 
 
11285 
  def __repr__(self):
11286 
    L = ['%s=%r' % (key, value)
11287 
      for key, value in self.__dict__.iteritems()]
11288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11289 
 
11290 
  def __eq__(self, other):
11291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11292 
 
11293 
  def __ne__(self, other):
11294 
    return not (self == other)
11295 
 
11296 
class deleteBanner_result:
11297 
  """
11298 
  Attributes:
11299 
   - success
11300 
  """
11301 
 
11302 
  thrift_spec = (
11303 
    (0, TType.BOOL, 'success', None, None, ), # 0
11304 
  )
11305 
 
11306 
  def __init__(self, success=None,):
11307 
    self.success = success
11308 
 
11309 
  def read(self, iprot):
11310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11312 
      return
11313 
    iprot.readStructBegin()
11314 
    while True:
11315 
      (fname, ftype, fid) = iprot.readFieldBegin()
11316 
      if ftype == TType.STOP:
11317 
        break
11318 
      if fid == 0:
11319 
        if ftype == TType.BOOL:
11320 
          self.success = iprot.readBool();
11321 
        else:
11322 
          iprot.skip(ftype)
11323 
      else:
11324 
        iprot.skip(ftype)
11325 
      iprot.readFieldEnd()
11326 
    iprot.readStructEnd()
11327 
 
11328 
  def write(self, oprot):
11329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11331 
      return
11332 
    oprot.writeStructBegin('deleteBanner_result')
11333 
    if self.success is not None:
11334 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11335 
      oprot.writeBool(self.success)
11336 
      oprot.writeFieldEnd()
11337 
    oprot.writeFieldStop()
11338 
    oprot.writeStructEnd()
11339 
 
11340 
  def validate(self):
11341 
    return
11342 
 
11343 
 
11344 
  def __repr__(self):
11345 
    L = ['%s=%r' % (key, value)
11346 
      for key, value in self.__dict__.iteritems()]
11347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11348 
 
11349 
  def __eq__(self, other):
11350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11351 
 
11352 
  def __ne__(self, other):
11353 
    return not (self == other)
11354 
 
11355 
class getBannerDetails_args:
11356 
  """
11357 
  Attributes:
11358 
   - bannerName
11359 
  """
11360 
 
11361 
  thrift_spec = (
11362 
    None, # 0
11363 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11364 
  )
11365 
 
11366 
  def __init__(self, bannerName=None,):
11367 
    self.bannerName = bannerName
11368 
 
11369 
  def read(self, iprot):
11370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11372 
      return
11373 
    iprot.readStructBegin()
11374 
    while True:
11375 
      (fname, ftype, fid) = iprot.readFieldBegin()
11376 
      if ftype == TType.STOP:
11377 
        break
11378 
      if fid == 1:
11379 
        if ftype == TType.STRING:
11380 
          self.bannerName = iprot.readString();
11381 
        else:
11382 
          iprot.skip(ftype)
11383 
      else:
11384 
        iprot.skip(ftype)
11385 
      iprot.readFieldEnd()
11386 
    iprot.readStructEnd()
11387 
 
11388 
  def write(self, oprot):
11389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11391 
      return
11392 
    oprot.writeStructBegin('getBannerDetails_args')
11393 
    if self.bannerName is not None:
11394 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11395 
      oprot.writeString(self.bannerName)
11396 
      oprot.writeFieldEnd()
11397 
    oprot.writeFieldStop()
11398 
    oprot.writeStructEnd()
11399 
 
11400 
  def validate(self):
11401 
    return
11402 
 
11403 
 
11404 
  def __repr__(self):
11405 
    L = ['%s=%r' % (key, value)
11406 
      for key, value in self.__dict__.iteritems()]
11407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11408 
 
11409 
  def __eq__(self, other):
11410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11411 
 
11412 
  def __ne__(self, other):
11413 
    return not (self == other)
11414 
 
11415 
class getBannerDetails_result:
11416 
  """
11417 
  Attributes:
11418 
   - success
11419 
  """
11420 
 
11421 
  thrift_spec = (
11422 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11423 
  )
11424 
 
11425 
  def __init__(self, success=None,):
11426 
    self.success = success
11427 
 
11428 
  def read(self, iprot):
11429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11431 
      return
11432 
    iprot.readStructBegin()
11433 
    while True:
11434 
      (fname, ftype, fid) = iprot.readFieldBegin()
11435 
      if ftype == TType.STOP:
11436 
        break
11437 
      if fid == 0:
11438 
        if ftype == TType.STRUCT:
11439 
          self.success = Banner()
11440 
          self.success.read(iprot)
11441 
        else:
11442 
          iprot.skip(ftype)
11443 
      else:
11444 
        iprot.skip(ftype)
11445 
      iprot.readFieldEnd()
11446 
    iprot.readStructEnd()
11447 
 
11448 
  def write(self, oprot):
11449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11451 
      return
11452 
    oprot.writeStructBegin('getBannerDetails_result')
11453 
    if self.success is not None:
11454 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11455 
      self.success.write(oprot)
11456 
      oprot.writeFieldEnd()
11457 
    oprot.writeFieldStop()
11458 
    oprot.writeStructEnd()
11459 
 
11460 
  def validate(self):
11461 
    return
11462 
 
11463 
 
11464 
  def __repr__(self):
11465 
    L = ['%s=%r' % (key, value)
11466 
      for key, value in self.__dict__.iteritems()]
11467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11468 
 
11469 
  def __eq__(self, other):
11470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11471 
 
11472 
  def __ne__(self, other):
11473 
    return not (self == other)
11474 
 
11475 
class getActiveBanners_args:
11476 
 
11477 
  thrift_spec = (
11478 
  )
11479 
 
11480 
  def read(self, iprot):
11481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11483 
      return
11484 
    iprot.readStructBegin()
11485 
    while True:
11486 
      (fname, ftype, fid) = iprot.readFieldBegin()
11487 
      if ftype == TType.STOP:
11488 
        break
11489 
      else:
11490 
        iprot.skip(ftype)
11491 
      iprot.readFieldEnd()
11492 
    iprot.readStructEnd()
11493 
 
11494 
  def write(self, oprot):
11495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11497 
      return
11498 
    oprot.writeStructBegin('getActiveBanners_args')
11499 
    oprot.writeFieldStop()
11500 
    oprot.writeStructEnd()
11501 
 
11502 
  def validate(self):
11503 
    return
11504 
 
11505 
 
11506 
  def __repr__(self):
11507 
    L = ['%s=%r' % (key, value)
11508 
      for key, value in self.__dict__.iteritems()]
11509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11510 
 
11511 
  def __eq__(self, other):
11512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11513 
 
11514 
  def __ne__(self, other):
11515 
    return not (self == other)
11516 
 
11517 
class getActiveBanners_result:
11518 
  """
11519 
  Attributes:
11520 
   - success
11521 
  """
11522 
 
11523 
  thrift_spec = (
11524 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11525 
  )
11526 
 
11527 
  def __init__(self, success=None,):
11528 
    self.success = success
11529 
 
11530 
  def read(self, iprot):
11531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11533 
      return
11534 
    iprot.readStructBegin()
11535 
    while True:
11536 
      (fname, ftype, fid) = iprot.readFieldBegin()
11537 
      if ftype == TType.STOP:
11538 
        break
11539 
      if fid == 0:
11540 
        if ftype == TType.LIST:
11541 
          self.success = []
7438 amit.gupta 11542 
          (_etype191, _size188) = iprot.readListBegin()
11543 
          for _i192 in xrange(_size188):
11544 
            _elem193 = Banner()
11545 
            _elem193.read(iprot)
11546 
            self.success.append(_elem193)
6850 kshitij.so 11547 
          iprot.readListEnd()
11548 
        else:
11549 
          iprot.skip(ftype)
11550 
      else:
11551 
        iprot.skip(ftype)
11552 
      iprot.readFieldEnd()
11553 
    iprot.readStructEnd()
11554 
 
11555 
  def write(self, oprot):
11556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11558 
      return
11559 
    oprot.writeStructBegin('getActiveBanners_result')
11560 
    if self.success is not None:
11561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11562 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11563 
      for iter194 in self.success:
11564 
        iter194.write(oprot)
6850 kshitij.so 11565 
      oprot.writeListEnd()
11566 
      oprot.writeFieldEnd()
11567 
    oprot.writeFieldStop()
11568 
    oprot.writeStructEnd()
11569 
 
11570 
  def validate(self):
11571 
    return
11572 
 
11573 
 
11574 
  def __repr__(self):
11575 
    L = ['%s=%r' % (key, value)
11576 
      for key, value in self.__dict__.iteritems()]
11577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11578 
 
11579 
  def __eq__(self, other):
11580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11581 
 
11582 
  def __ne__(self, other):
11583 
    return not (self == other)
11584 
 
6849 kshitij.so 11585 
class addBannerMap_args:
11586 
  """
11587 
  Attributes:
11588 
   - bannerName
11589 
   - mapLink
11590 
   - coordinates
11591 
  """
11592 
 
11593 
  thrift_spec = (
11594 
    None, # 0
11595 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11596 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11597 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11598 
  )
11599 
 
11600 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11601 
    self.bannerName = bannerName
11602 
    self.mapLink = mapLink
11603 
    self.coordinates = coordinates
11604 
 
11605 
  def read(self, iprot):
11606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11608 
      return
11609 
    iprot.readStructBegin()
11610 
    while True:
11611 
      (fname, ftype, fid) = iprot.readFieldBegin()
11612 
      if ftype == TType.STOP:
11613 
        break
11614 
      if fid == 1:
11615 
        if ftype == TType.STRING:
11616 
          self.bannerName = iprot.readString();
11617 
        else:
11618 
          iprot.skip(ftype)
11619 
      elif fid == 2:
11620 
        if ftype == TType.STRING:
11621 
          self.mapLink = iprot.readString();
11622 
        else:
11623 
          iprot.skip(ftype)
11624 
      elif fid == 3:
11625 
        if ftype == TType.STRING:
11626 
          self.coordinates = iprot.readString();
11627 
        else:
11628 
          iprot.skip(ftype)
11629 
      else:
11630 
        iprot.skip(ftype)
11631 
      iprot.readFieldEnd()
11632 
    iprot.readStructEnd()
11633 
 
11634 
  def write(self, oprot):
11635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11637 
      return
11638 
    oprot.writeStructBegin('addBannerMap_args')
11639 
    if self.bannerName is not None:
11640 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11641 
      oprot.writeString(self.bannerName)
11642 
      oprot.writeFieldEnd()
11643 
    if self.mapLink is not None:
11644 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11645 
      oprot.writeString(self.mapLink)
11646 
      oprot.writeFieldEnd()
11647 
    if self.coordinates is not None:
11648 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11649 
      oprot.writeString(self.coordinates)
11650 
      oprot.writeFieldEnd()
11651 
    oprot.writeFieldStop()
11652 
    oprot.writeStructEnd()
11653 
 
11654 
  def validate(self):
11655 
    return
11656 
 
11657 
 
11658 
  def __repr__(self):
11659 
    L = ['%s=%r' % (key, value)
11660 
      for key, value in self.__dict__.iteritems()]
11661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11662 
 
11663 
  def __eq__(self, other):
11664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11665 
 
11666 
  def __ne__(self, other):
11667 
    return not (self == other)
11668 
 
11669 
class addBannerMap_result:
11670 
  """
11671 
  Attributes:
11672 
   - success
11673 
  """
11674 
 
11675 
  thrift_spec = (
11676 
    (0, TType.BOOL, 'success', None, None, ), # 0
11677 
  )
11678 
 
11679 
  def __init__(self, success=None,):
11680 
    self.success = success
11681 
 
11682 
  def read(self, iprot):
11683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11685 
      return
11686 
    iprot.readStructBegin()
11687 
    while True:
11688 
      (fname, ftype, fid) = iprot.readFieldBegin()
11689 
      if ftype == TType.STOP:
11690 
        break
11691 
      if fid == 0:
11692 
        if ftype == TType.BOOL:
11693 
          self.success = iprot.readBool();
11694 
        else:
11695 
          iprot.skip(ftype)
11696 
      else:
11697 
        iprot.skip(ftype)
11698 
      iprot.readFieldEnd()
11699 
    iprot.readStructEnd()
11700 
 
11701 
  def write(self, oprot):
11702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11704 
      return
11705 
    oprot.writeStructBegin('addBannerMap_result')
11706 
    if self.success is not None:
11707 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11708 
      oprot.writeBool(self.success)
11709 
      oprot.writeFieldEnd()
11710 
    oprot.writeFieldStop()
11711 
    oprot.writeStructEnd()
11712 
 
11713 
  def validate(self):
11714 
    return
11715 
 
11716 
 
11717 
  def __repr__(self):
11718 
    L = ['%s=%r' % (key, value)
11719 
      for key, value in self.__dict__.iteritems()]
11720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11721 
 
11722 
  def __eq__(self, other):
11723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11724 
 
11725 
  def __ne__(self, other):
11726 
    return not (self == other)
11727 
 
11728 
class deleteBannerMap_args:
11729 
  """
11730 
  Attributes:
11731 
   - bannerName
11732 
  """
11733 
 
11734 
  thrift_spec = (
11735 
    None, # 0
11736 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11737 
  )
11738 
 
11739 
  def __init__(self, bannerName=None,):
11740 
    self.bannerName = bannerName
11741 
 
11742 
  def read(self, iprot):
11743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11745 
      return
11746 
    iprot.readStructBegin()
11747 
    while True:
11748 
      (fname, ftype, fid) = iprot.readFieldBegin()
11749 
      if ftype == TType.STOP:
11750 
        break
11751 
      if fid == 1:
11752 
        if ftype == TType.STRING:
11753 
          self.bannerName = iprot.readString();
11754 
        else:
11755 
          iprot.skip(ftype)
11756 
      else:
11757 
        iprot.skip(ftype)
11758 
      iprot.readFieldEnd()
11759 
    iprot.readStructEnd()
11760 
 
11761 
  def write(self, oprot):
11762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11764 
      return
11765 
    oprot.writeStructBegin('deleteBannerMap_args')
11766 
    if self.bannerName is not None:
11767 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11768 
      oprot.writeString(self.bannerName)
11769 
      oprot.writeFieldEnd()
11770 
    oprot.writeFieldStop()
11771 
    oprot.writeStructEnd()
11772 
 
11773 
  def validate(self):
11774 
    return
11775 
 
11776 
 
11777 
  def __repr__(self):
11778 
    L = ['%s=%r' % (key, value)
11779 
      for key, value in self.__dict__.iteritems()]
11780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11781 
 
11782 
  def __eq__(self, other):
11783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11784 
 
11785 
  def __ne__(self, other):
11786 
    return not (self == other)
11787 
 
11788 
class deleteBannerMap_result:
11789 
  """
11790 
  Attributes:
11791 
   - success
11792 
  """
11793 
 
11794 
  thrift_spec = (
11795 
    (0, TType.BOOL, 'success', None, None, ), # 0
11796 
  )
11797 
 
11798 
  def __init__(self, success=None,):
11799 
    self.success = success
11800 
 
11801 
  def read(self, iprot):
11802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11804 
      return
11805 
    iprot.readStructBegin()
11806 
    while True:
11807 
      (fname, ftype, fid) = iprot.readFieldBegin()
11808 
      if ftype == TType.STOP:
11809 
        break
11810 
      if fid == 0:
11811 
        if ftype == TType.BOOL:
11812 
          self.success = iprot.readBool();
11813 
        else:
11814 
          iprot.skip(ftype)
11815 
      else:
11816 
        iprot.skip(ftype)
11817 
      iprot.readFieldEnd()
11818 
    iprot.readStructEnd()
11819 
 
11820 
  def write(self, oprot):
11821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11823 
      return
11824 
    oprot.writeStructBegin('deleteBannerMap_result')
11825 
    if self.success is not None:
11826 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11827 
      oprot.writeBool(self.success)
11828 
      oprot.writeFieldEnd()
11829 
    oprot.writeFieldStop()
11830 
    oprot.writeStructEnd()
11831 
 
11832 
  def validate(self):
11833 
    return
11834 
 
11835 
 
11836 
  def __repr__(self):
11837 
    L = ['%s=%r' % (key, value)
11838 
      for key, value in self.__dict__.iteritems()]
11839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11840 
 
11841 
  def __eq__(self, other):
11842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11843 
 
11844 
  def __ne__(self, other):
11845 
    return not (self == other)
11846 
 
11847 
class getBannerMapDetails_args:
11848 
  """
11849 
  Attributes:
11850 
   - bannerName
11851 
  """
11852 
 
11853 
  thrift_spec = (
11854 
    None, # 0
11855 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11856 
  )
11857 
 
11858 
  def __init__(self, bannerName=None,):
11859 
    self.bannerName = bannerName
11860 
 
11861 
  def read(self, iprot):
11862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11864 
      return
11865 
    iprot.readStructBegin()
11866 
    while True:
11867 
      (fname, ftype, fid) = iprot.readFieldBegin()
11868 
      if ftype == TType.STOP:
11869 
        break
11870 
      if fid == 1:
11871 
        if ftype == TType.STRING:
11872 
          self.bannerName = iprot.readString();
11873 
        else:
11874 
          iprot.skip(ftype)
11875 
      else:
11876 
        iprot.skip(ftype)
11877 
      iprot.readFieldEnd()
11878 
    iprot.readStructEnd()
11879 
 
11880 
  def write(self, oprot):
11881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11883 
      return
11884 
    oprot.writeStructBegin('getBannerMapDetails_args')
11885 
    if self.bannerName is not None:
11886 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11887 
      oprot.writeString(self.bannerName)
11888 
      oprot.writeFieldEnd()
11889 
    oprot.writeFieldStop()
11890 
    oprot.writeStructEnd()
11891 
 
11892 
  def validate(self):
11893 
    return
11894 
 
11895 
 
11896 
  def __repr__(self):
11897 
    L = ['%s=%r' % (key, value)
11898 
      for key, value in self.__dict__.iteritems()]
11899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11900 
 
11901 
  def __eq__(self, other):
11902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11903 
 
11904 
  def __ne__(self, other):
11905 
    return not (self == other)
11906 
 
11907 
class getBannerMapDetails_result:
11908 
  """
11909 
  Attributes:
11910 
   - success
11911 
  """
11912 
 
11913 
  thrift_spec = (
11914 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11915 
  )
11916 
 
11917 
  def __init__(self, success=None,):
11918 
    self.success = success
11919 
 
11920 
  def read(self, iprot):
11921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11923 
      return
11924 
    iprot.readStructBegin()
11925 
    while True:
11926 
      (fname, ftype, fid) = iprot.readFieldBegin()
11927 
      if ftype == TType.STOP:
11928 
        break
11929 
      if fid == 0:
11930 
        if ftype == TType.LIST:
11931 
          self.success = []
7438 amit.gupta 11932 
          (_etype198, _size195) = iprot.readListBegin()
11933 
          for _i199 in xrange(_size195):
11934 
            _elem200 = BannerMap()
11935 
            _elem200.read(iprot)
11936 
            self.success.append(_elem200)
6849 kshitij.so 11937 
          iprot.readListEnd()
11938 
        else:
11939 
          iprot.skip(ftype)
11940 
      else:
11941 
        iprot.skip(ftype)
11942 
      iprot.readFieldEnd()
11943 
    iprot.readStructEnd()
11944 
 
11945 
  def write(self, oprot):
11946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11948 
      return
11949 
    oprot.writeStructBegin('getBannerMapDetails_result')
11950 
    if self.success is not None:
11951 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11952 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11953 
      for iter201 in self.success:
11954 
        iter201.write(oprot)
6849 kshitij.so 11955 
      oprot.writeListEnd()
11956 
      oprot.writeFieldEnd()
11957 
    oprot.writeFieldStop()
11958 
    oprot.writeStructEnd()
11959 
 
11960 
  def validate(self):
11961 
    return
11962 
 
11963 
 
11964 
  def __repr__(self):
11965 
    L = ['%s=%r' % (key, value)
11966 
      for key, value in self.__dict__.iteritems()]
11967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11968 
 
11969 
  def __eq__(self, other):
11970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11971 
 
11972 
  def __ne__(self, other):
11973 
    return not (self == other)
11974 
 
5944 mandeep.dh 11975 
class deleteSimilarItem_args:
11976 
  """
11977 
  Attributes:
11978 
   - itemId
11979 
   - catalogItemId
11980 
  """
11981 
 
11982 
  thrift_spec = (
11983 
    None, # 0
11984 
    (1, TType.I64, 'itemId', None, None, ), # 1
11985 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11986 
  )
11987 
 
11988 
  def __init__(self, itemId=None, catalogItemId=None,):
11989 
    self.itemId = itemId
11990 
    self.catalogItemId = catalogItemId
11991 
 
11992 
  def read(self, iprot):
11993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11995 
      return
11996 
    iprot.readStructBegin()
11997 
    while True:
11998 
      (fname, ftype, fid) = iprot.readFieldBegin()
11999 
      if ftype == TType.STOP:
12000 
        break
12001 
      if fid == 1:
12002 
        if ftype == TType.I64:
12003 
          self.itemId = iprot.readI64();
12004 
        else:
12005 
          iprot.skip(ftype)
12006 
      elif fid == 2:
12007 
        if ftype == TType.I64:
12008 
          self.catalogItemId = iprot.readI64();
12009 
        else:
12010 
          iprot.skip(ftype)
12011 
      else:
12012 
        iprot.skip(ftype)
12013 
      iprot.readFieldEnd()
12014 
    iprot.readStructEnd()
12015 
 
12016 
  def write(self, oprot):
12017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12019 
      return
12020 
    oprot.writeStructBegin('deleteSimilarItem_args')
12021 
    if self.itemId is not None:
12022 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12023 
      oprot.writeI64(self.itemId)
12024 
      oprot.writeFieldEnd()
12025 
    if self.catalogItemId is not None:
12026 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
12027 
      oprot.writeI64(self.catalogItemId)
12028 
      oprot.writeFieldEnd()
12029 
    oprot.writeFieldStop()
12030 
    oprot.writeStructEnd()
12031 
 
12032 
  def validate(self):
12033 
    return
12034 
 
12035 
 
12036 
  def __repr__(self):
12037 
    L = ['%s=%r' % (key, value)
12038 
      for key, value in self.__dict__.iteritems()]
12039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12040 
 
12041 
  def __eq__(self, other):
12042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12043 
 
12044 
  def __ne__(self, other):
12045 
    return not (self == other)
12046 
 
12047 
class deleteSimilarItem_result:
12048 
  """
12049 
  Attributes:
12050 
   - success
12051 
   - cex
12052 
  """
12053 
 
12054 
  thrift_spec = (
12055 
    (0, TType.BOOL, 'success', None, None, ), # 0
12056 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12057 
  )
12058 
 
12059 
  def __init__(self, success=None, cex=None,):
12060 
    self.success = success
12061 
    self.cex = cex
12062 
 
12063 
  def read(self, iprot):
12064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12066 
      return
12067 
    iprot.readStructBegin()
12068 
    while True:
12069 
      (fname, ftype, fid) = iprot.readFieldBegin()
12070 
      if ftype == TType.STOP:
12071 
        break
12072 
      if fid == 0:
12073 
        if ftype == TType.BOOL:
12074 
          self.success = iprot.readBool();
12075 
        else:
12076 
          iprot.skip(ftype)
12077 
      elif fid == 1:
12078 
        if ftype == TType.STRUCT:
12079 
          self.cex = CatalogServiceException()
12080 
          self.cex.read(iprot)
12081 
        else:
12082 
          iprot.skip(ftype)
12083 
      else:
12084 
        iprot.skip(ftype)
12085 
      iprot.readFieldEnd()
12086 
    iprot.readStructEnd()
12087 
 
12088 
  def write(self, oprot):
12089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12091 
      return
12092 
    oprot.writeStructBegin('deleteSimilarItem_result')
12093 
    if self.success is not None:
12094 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12095 
      oprot.writeBool(self.success)
12096 
      oprot.writeFieldEnd()
12097 
    if self.cex is not None:
12098 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12099 
      self.cex.write(oprot)
12100 
      oprot.writeFieldEnd()
12101 
    oprot.writeFieldStop()
12102 
    oprot.writeStructEnd()
12103 
 
12104 
  def validate(self):
12105 
    return
12106 
 
12107 
 
12108 
  def __repr__(self):
12109 
    L = ['%s=%r' % (key, value)
12110 
      for key, value in self.__dict__.iteritems()]
12111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12112 
 
12113 
  def __eq__(self, other):
12114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12115 
 
12116 
  def __ne__(self, other):
12117 
    return not (self == other)
12118 
 
12119 
class checkSimilarItem_args:
12120 
  """
12121 
  Attributes:
12122 
   - brand
12123 
   - modelNumber
12124 
   - modelName
12125 
   - color
12126 
  """
12127 
 
12128 
  thrift_spec = (
12129 
    None, # 0
12130 
    (1, TType.STRING, 'brand', None, None, ), # 1
12131 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
12132 
    (3, TType.STRING, 'modelName', None, None, ), # 3
12133 
    (4, TType.STRING, 'color', None, None, ), # 4
12134 
  )
12135 
 
12136 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
12137 
    self.brand = brand
12138 
    self.modelNumber = modelNumber
12139 
    self.modelName = modelName
12140 
    self.color = color
12141 
 
12142 
  def read(self, iprot):
12143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12145 
      return
12146 
    iprot.readStructBegin()
12147 
    while True:
12148 
      (fname, ftype, fid) = iprot.readFieldBegin()
12149 
      if ftype == TType.STOP:
12150 
        break
12151 
      if fid == 1:
12152 
        if ftype == TType.STRING:
12153 
          self.brand = iprot.readString();
12154 
        else:
12155 
          iprot.skip(ftype)
12156 
      elif fid == 2:
12157 
        if ftype == TType.STRING:
12158 
          self.modelNumber = iprot.readString();
12159 
        else:
12160 
          iprot.skip(ftype)
12161 
      elif fid == 3:
12162 
        if ftype == TType.STRING:
12163 
          self.modelName = iprot.readString();
12164 
        else:
12165 
          iprot.skip(ftype)
12166 
      elif fid == 4:
12167 
        if ftype == TType.STRING:
12168 
          self.color = iprot.readString();
12169 
        else:
12170 
          iprot.skip(ftype)
12171 
      else:
12172 
        iprot.skip(ftype)
12173 
      iprot.readFieldEnd()
12174 
    iprot.readStructEnd()
12175 
 
12176 
  def write(self, oprot):
12177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12179 
      return
12180 
    oprot.writeStructBegin('checkSimilarItem_args')
12181 
    if self.brand is not None:
12182 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
12183 
      oprot.writeString(self.brand)
12184 
      oprot.writeFieldEnd()
12185 
    if self.modelNumber is not None:
12186 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
12187 
      oprot.writeString(self.modelNumber)
12188 
      oprot.writeFieldEnd()
12189 
    if self.modelName is not None:
12190 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
12191 
      oprot.writeString(self.modelName)
12192 
      oprot.writeFieldEnd()
12193 
    if self.color is not None:
12194 
      oprot.writeFieldBegin('color', TType.STRING, 4)
12195 
      oprot.writeString(self.color)
12196 
      oprot.writeFieldEnd()
12197 
    oprot.writeFieldStop()
12198 
    oprot.writeStructEnd()
12199 
 
12200 
  def validate(self):
12201 
    return
12202 
 
12203 
 
12204 
  def __repr__(self):
12205 
    L = ['%s=%r' % (key, value)
12206 
      for key, value in self.__dict__.iteritems()]
12207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12208 
 
12209 
  def __eq__(self, other):
12210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12211 
 
12212 
  def __ne__(self, other):
12213 
    return not (self == other)
12214 
 
12215 
class checkSimilarItem_result:
12216 
  """
12217 
  Attributes:
12218 
   - success
12219 
  """
12220 
 
12221 
  thrift_spec = (
12222 
    (0, TType.I64, 'success', None, None, ), # 0
12223 
  )
12224 
 
12225 
  def __init__(self, success=None,):
12226 
    self.success = success
12227 
 
12228 
  def read(self, iprot):
12229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12231 
      return
12232 
    iprot.readStructBegin()
12233 
    while True:
12234 
      (fname, ftype, fid) = iprot.readFieldBegin()
12235 
      if ftype == TType.STOP:
12236 
        break
12237 
      if fid == 0:
12238 
        if ftype == TType.I64:
12239 
          self.success = iprot.readI64();
12240 
        else:
12241 
          iprot.skip(ftype)
12242 
      else:
12243 
        iprot.skip(ftype)
12244 
      iprot.readFieldEnd()
12245 
    iprot.readStructEnd()
12246 
 
12247 
  def write(self, oprot):
12248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12250 
      return
12251 
    oprot.writeStructBegin('checkSimilarItem_result')
12252 
    if self.success is not None:
12253 
      oprot.writeFieldBegin('success', TType.I64, 0)
12254 
      oprot.writeI64(self.success)
12255 
      oprot.writeFieldEnd()
12256 
    oprot.writeFieldStop()
12257 
    oprot.writeStructEnd()
12258 
 
12259 
  def validate(self):
12260 
    return
12261 
 
12262 
 
12263 
  def __repr__(self):
12264 
    L = ['%s=%r' % (key, value)
12265 
      for key, value in self.__dict__.iteritems()]
12266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12267 
 
12268 
  def __eq__(self, other):
12269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12270 
 
12271 
  def __ne__(self, other):
12272 
    return not (self == other)
12273 
 
12274 
class validateRiskyStatus_args:
12275 
  """
12276 
  Attributes:
12277 
   - itemId
12278 
  """
12279 
 
12280 
  thrift_spec = (
12281 
    None, # 0
12282 
    (1, TType.I64, 'itemId', None, None, ), # 1
12283 
  )
12284 
 
12285 
  def __init__(self, itemId=None,):
12286 
    self.itemId = itemId
12287 
 
12288 
  def read(self, iprot):
12289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12291 
      return
12292 
    iprot.readStructBegin()
12293 
    while True:
12294 
      (fname, ftype, fid) = iprot.readFieldBegin()
12295 
      if ftype == TType.STOP:
12296 
        break
12297 
      if fid == 1:
12298 
        if ftype == TType.I64:
12299 
          self.itemId = iprot.readI64();
12300 
        else:
12301 
          iprot.skip(ftype)
12302 
      else:
12303 
        iprot.skip(ftype)
12304 
      iprot.readFieldEnd()
12305 
    iprot.readStructEnd()
12306 
 
12307 
  def write(self, oprot):
12308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12310 
      return
12311 
    oprot.writeStructBegin('validateRiskyStatus_args')
12312 
    if self.itemId is not None:
12313 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12314 
      oprot.writeI64(self.itemId)
12315 
      oprot.writeFieldEnd()
12316 
    oprot.writeFieldStop()
12317 
    oprot.writeStructEnd()
12318 
 
12319 
  def validate(self):
12320 
    return
12321 
 
12322 
 
12323 
  def __repr__(self):
12324 
    L = ['%s=%r' % (key, value)
12325 
      for key, value in self.__dict__.iteritems()]
12326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12327 
 
12328 
  def __eq__(self, other):
12329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12330 
 
12331 
  def __ne__(self, other):
12332 
    return not (self == other)
12333 
 
12334 
class validateRiskyStatus_result:
12335 
 
12336 
  thrift_spec = (
12337 
  )
12338 
 
12339 
  def read(self, iprot):
12340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12342 
      return
12343 
    iprot.readStructBegin()
12344 
    while True:
12345 
      (fname, ftype, fid) = iprot.readFieldBegin()
12346 
      if ftype == TType.STOP:
12347 
        break
12348 
      else:
12349 
        iprot.skip(ftype)
12350 
      iprot.readFieldEnd()
12351 
    iprot.readStructEnd()
12352 
 
12353 
  def write(self, oprot):
12354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12356 
      return
12357 
    oprot.writeStructBegin('validateRiskyStatus_result')
12358 
    oprot.writeFieldStop()
12359 
    oprot.writeStructEnd()
12360 
 
12361 
  def validate(self):
12362 
    return
12363 
 
12364 
 
12365 
  def __repr__(self):
12366 
    L = ['%s=%r' % (key, value)
12367 
      for key, value in self.__dict__.iteritems()]
12368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12369 
 
12370 
  def __eq__(self, other):
12371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12372 
 
12373 
  def __ne__(self, other):
12374 
    return not (self == other)
12375 
 
12376 
class changeItemRiskyFlag_args:
12377 
  """
12378 
  Attributes:
12379 
   - itemId
12380 
   - risky
12381 
  """
12382 
 
12383 
  thrift_spec = (
12384 
    None, # 0
12385 
    (1, TType.I64, 'itemId', None, None, ), # 1
12386 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12387 
  )
12388 
 
12389 
  def __init__(self, itemId=None, risky=None,):
12390 
    self.itemId = itemId
12391 
    self.risky = risky
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.I64:
12404 
          self.itemId = iprot.readI64();
12405 
        else:
12406 
          iprot.skip(ftype)
12407 
      elif fid == 2:
12408 
        if ftype == TType.BOOL:
12409 
          self.risky = iprot.readBool();
12410 
        else:
12411 
          iprot.skip(ftype)
12412 
      else:
12413 
        iprot.skip(ftype)
12414 
      iprot.readFieldEnd()
12415 
    iprot.readStructEnd()
12416 
 
12417 
  def write(self, oprot):
12418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12420 
      return
12421 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12422 
    if self.itemId is not None:
12423 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12424 
      oprot.writeI64(self.itemId)
12425 
      oprot.writeFieldEnd()
12426 
    if self.risky is not None:
12427 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12428 
      oprot.writeBool(self.risky)
12429 
      oprot.writeFieldEnd()
12430 
    oprot.writeFieldStop()
12431 
    oprot.writeStructEnd()
12432 
 
12433 
  def validate(self):
12434 
    return
12435 
 
12436 
 
12437 
  def __repr__(self):
12438 
    L = ['%s=%r' % (key, value)
12439 
      for key, value in self.__dict__.iteritems()]
12440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12441 
 
12442 
  def __eq__(self, other):
12443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12444 
 
12445 
  def __ne__(self, other):
12446 
    return not (self == other)
12447 
 
12448 
class changeItemRiskyFlag_result:
12449 
 
12450 
  thrift_spec = (
12451 
  )
12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      else:
12463 
        iprot.skip(ftype)
12464 
      iprot.readFieldEnd()
12465 
    iprot.readStructEnd()
12466 
 
12467 
  def write(self, oprot):
12468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12470 
      return
12471 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12472 
    oprot.writeFieldStop()
12473 
    oprot.writeStructEnd()
12474 
 
12475 
  def validate(self):
12476 
    return
12477 
 
12478 
 
12479 
  def __repr__(self):
12480 
    L = ['%s=%r' % (key, value)
12481 
      for key, value in self.__dict__.iteritems()]
12482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12483 
 
12484 
  def __eq__(self, other):
12485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12486 
 
12487 
  def __ne__(self, other):
12488 
    return not (self == other)
12489 
 
12490 
class getItemsByRiskyFlag_args:
12491 
 
12492 
  thrift_spec = (
12493 
  )
12494 
 
12495 
  def read(self, iprot):
12496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12498 
      return
12499 
    iprot.readStructBegin()
12500 
    while True:
12501 
      (fname, ftype, fid) = iprot.readFieldBegin()
12502 
      if ftype == TType.STOP:
12503 
        break
12504 
      else:
12505 
        iprot.skip(ftype)
12506 
      iprot.readFieldEnd()
12507 
    iprot.readStructEnd()
12508 
 
12509 
  def write(self, oprot):
12510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12512 
      return
12513 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12514 
    oprot.writeFieldStop()
12515 
    oprot.writeStructEnd()
12516 
 
12517 
  def validate(self):
12518 
    return
12519 
 
12520 
 
12521 
  def __repr__(self):
12522 
    L = ['%s=%r' % (key, value)
12523 
      for key, value in self.__dict__.iteritems()]
12524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12525 
 
12526 
  def __eq__(self, other):
12527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12528 
 
12529 
  def __ne__(self, other):
12530 
    return not (self == other)
12531 
 
12532 
class getItemsByRiskyFlag_result:
12533 
  """
12534 
  Attributes:
12535 
   - success
12536 
  """
12537 
 
12538 
  thrift_spec = (
12539 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12540 
  )
12541 
 
12542 
  def __init__(self, success=None,):
12543 
    self.success = success
12544 
 
12545 
  def read(self, iprot):
12546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12548 
      return
12549 
    iprot.readStructBegin()
12550 
    while True:
12551 
      (fname, ftype, fid) = iprot.readFieldBegin()
12552 
      if ftype == TType.STOP:
12553 
        break
12554 
      if fid == 0:
12555 
        if ftype == TType.LIST:
12556 
          self.success = []
7438 amit.gupta 12557 
          (_etype205, _size202) = iprot.readListBegin()
12558 
          for _i206 in xrange(_size202):
12559 
            _elem207 = Item()
12560 
            _elem207.read(iprot)
12561 
            self.success.append(_elem207)
5944 mandeep.dh 12562 
          iprot.readListEnd()
12563 
        else:
12564 
          iprot.skip(ftype)
12565 
      else:
12566 
        iprot.skip(ftype)
12567 
      iprot.readFieldEnd()
12568 
    iprot.readStructEnd()
12569 
 
12570 
  def write(self, oprot):
12571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12573 
      return
12574 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12575 
    if self.success is not None:
12576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12577 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12578 
      for iter208 in self.success:
12579 
        iter208.write(oprot)
5944 mandeep.dh 12580 
      oprot.writeListEnd()
12581 
      oprot.writeFieldEnd()
12582 
    oprot.writeFieldStop()
12583 
    oprot.writeStructEnd()
12584 
 
12585 
  def validate(self):
12586 
    return
12587 
 
12588 
 
12589 
  def __repr__(self):
12590 
    L = ['%s=%r' % (key, value)
12591 
      for key, value in self.__dict__.iteritems()]
12592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12593 
 
12594 
  def __eq__(self, other):
12595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12596 
 
12597 
  def __ne__(self, other):
12598 
    return not (self == other)
12599 
 
12600 
class getItemsForMasterSheet_args:
12601 
  """
12602 
  Attributes:
12603 
   - category
12604 
   - brand
12605 
  """
12606 
 
12607 
  thrift_spec = (
12608 
    None, # 0
12609 
    (1, TType.STRING, 'category', None, None, ), # 1
12610 
    (2, TType.STRING, 'brand', None, None, ), # 2
12611 
  )
12612 
 
12613 
  def __init__(self, category=None, brand=None,):
12614 
    self.category = category
12615 
    self.brand = brand
12616 
 
12617 
  def read(self, iprot):
12618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12620 
      return
12621 
    iprot.readStructBegin()
12622 
    while True:
12623 
      (fname, ftype, fid) = iprot.readFieldBegin()
12624 
      if ftype == TType.STOP:
12625 
        break
12626 
      if fid == 1:
12627 
        if ftype == TType.STRING:
12628 
          self.category = iprot.readString();
12629 
        else:
12630 
          iprot.skip(ftype)
12631 
      elif fid == 2:
12632 
        if ftype == TType.STRING:
12633 
          self.brand = iprot.readString();
12634 
        else:
12635 
          iprot.skip(ftype)
12636 
      else:
12637 
        iprot.skip(ftype)
12638 
      iprot.readFieldEnd()
12639 
    iprot.readStructEnd()
12640 
 
12641 
  def write(self, oprot):
12642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12644 
      return
12645 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12646 
    if self.category is not None:
12647 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12648 
      oprot.writeString(self.category)
12649 
      oprot.writeFieldEnd()
12650 
    if self.brand is not None:
12651 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12652 
      oprot.writeString(self.brand)
12653 
      oprot.writeFieldEnd()
12654 
    oprot.writeFieldStop()
12655 
    oprot.writeStructEnd()
12656 
 
12657 
  def validate(self):
12658 
    return
12659 
 
12660 
 
12661 
  def __repr__(self):
12662 
    L = ['%s=%r' % (key, value)
12663 
      for key, value in self.__dict__.iteritems()]
12664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12665 
 
12666 
  def __eq__(self, other):
12667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12668 
 
12669 
  def __ne__(self, other):
12670 
    return not (self == other)
12671 
 
12672 
class getItemsForMasterSheet_result:
12673 
  """
12674 
  Attributes:
12675 
   - success
12676 
  """
12677 
 
12678 
  thrift_spec = (
12679 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12680 
  )
12681 
 
12682 
  def __init__(self, success=None,):
12683 
    self.success = success
12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 0:
12695 
        if ftype == TType.LIST:
12696 
          self.success = []
7438 amit.gupta 12697 
          (_etype212, _size209) = iprot.readListBegin()
12698 
          for _i213 in xrange(_size209):
12699 
            _elem214 = Item()
12700 
            _elem214.read(iprot)
12701 
            self.success.append(_elem214)
5944 mandeep.dh 12702 
          iprot.readListEnd()
12703 
        else:
12704 
          iprot.skip(ftype)
12705 
      else:
12706 
        iprot.skip(ftype)
12707 
      iprot.readFieldEnd()
12708 
    iprot.readStructEnd()
12709 
 
12710 
  def write(self, oprot):
12711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12713 
      return
12714 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12715 
    if self.success is not None:
12716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12718 
      for iter215 in self.success:
12719 
        iter215.write(oprot)
5944 mandeep.dh 12720 
      oprot.writeListEnd()
12721 
      oprot.writeFieldEnd()
12722 
    oprot.writeFieldStop()
12723 
    oprot.writeStructEnd()
12724 
 
12725 
  def validate(self):
12726 
    return
12727 
 
12728 
 
12729 
  def __repr__(self):
12730 
    L = ['%s=%r' % (key, value)
12731 
      for key, value in self.__dict__.iteritems()]
12732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12733 
 
12734 
  def __eq__(self, other):
12735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12736 
 
12737 
  def __ne__(self, other):
12738 
    return not (self == other)
12739 
 
12740 
class getSimilarItemsCatalogIds_args:
12741 
  """
12742 
  Attributes:
12743 
   - beginIndex
12744 
   - totalItems
12745 
   - itemId
12746 
  """
12747 
 
12748 
  thrift_spec = (
12749 
    None, # 0
12750 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12751 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12752 
    (3, TType.I64, 'itemId', None, None, ), # 3
12753 
  )
12754 
 
12755 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12756 
    self.beginIndex = beginIndex
12757 
    self.totalItems = totalItems
12758 
    self.itemId = itemId
12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
12769 
      if fid == 1:
12770 
        if ftype == TType.I64:
12771 
          self.beginIndex = iprot.readI64();
12772 
        else:
12773 
          iprot.skip(ftype)
12774 
      elif fid == 2:
12775 
        if ftype == TType.I64:
12776 
          self.totalItems = iprot.readI64();
12777 
        else:
12778 
          iprot.skip(ftype)
12779 
      elif fid == 3:
12780 
        if ftype == TType.I64:
12781 
          self.itemId = iprot.readI64();
12782 
        else:
12783 
          iprot.skip(ftype)
12784 
      else:
12785 
        iprot.skip(ftype)
12786 
      iprot.readFieldEnd()
12787 
    iprot.readStructEnd()
12788 
 
12789 
  def write(self, oprot):
12790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12792 
      return
12793 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12794 
    if self.beginIndex is not None:
12795 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12796 
      oprot.writeI64(self.beginIndex)
12797 
      oprot.writeFieldEnd()
12798 
    if self.totalItems is not None:
12799 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12800 
      oprot.writeI64(self.totalItems)
12801 
      oprot.writeFieldEnd()
12802 
    if self.itemId is not None:
12803 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12804 
      oprot.writeI64(self.itemId)
12805 
      oprot.writeFieldEnd()
12806 
    oprot.writeFieldStop()
12807 
    oprot.writeStructEnd()
12808 
 
12809 
  def validate(self):
12810 
    return
12811 
 
12812 
 
12813 
  def __repr__(self):
12814 
    L = ['%s=%r' % (key, value)
12815 
      for key, value in self.__dict__.iteritems()]
12816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12817 
 
12818 
  def __eq__(self, other):
12819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12820 
 
12821 
  def __ne__(self, other):
12822 
    return not (self == other)
12823 
 
12824 
class getSimilarItemsCatalogIds_result:
12825 
  """
12826 
  Attributes:
12827 
   - success
12828 
  """
12829 
 
12830 
  thrift_spec = (
12831 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12832 
  )
12833 
 
12834 
  def __init__(self, success=None,):
12835 
    self.success = success
12836 
 
12837 
  def read(self, iprot):
12838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12840 
      return
12841 
    iprot.readStructBegin()
12842 
    while True:
12843 
      (fname, ftype, fid) = iprot.readFieldBegin()
12844 
      if ftype == TType.STOP:
12845 
        break
12846 
      if fid == 0:
12847 
        if ftype == TType.LIST:
12848 
          self.success = []
7438 amit.gupta 12849 
          (_etype219, _size216) = iprot.readListBegin()
12850 
          for _i220 in xrange(_size216):
12851 
            _elem221 = iprot.readI64();
12852 
            self.success.append(_elem221)
5944 mandeep.dh 12853 
          iprot.readListEnd()
12854 
        else:
12855 
          iprot.skip(ftype)
12856 
      else:
12857 
        iprot.skip(ftype)
12858 
      iprot.readFieldEnd()
12859 
    iprot.readStructEnd()
12860 
 
12861 
  def write(self, oprot):
12862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12864 
      return
12865 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12866 
    if self.success is not None:
12867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12868 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 12869 
      for iter222 in self.success:
12870 
        oprot.writeI64(iter222)
5944 mandeep.dh 12871 
      oprot.writeListEnd()
12872 
      oprot.writeFieldEnd()
12873 
    oprot.writeFieldStop()
12874 
    oprot.writeStructEnd()
12875 
 
12876 
  def validate(self):
12877 
    return
12878 
 
12879 
 
12880 
  def __repr__(self):
12881 
    L = ['%s=%r' % (key, value)
12882 
      for key, value in self.__dict__.iteritems()]
12883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12884 
 
12885 
  def __eq__(self, other):
12886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12887 
 
12888 
  def __ne__(self, other):
12889 
    return not (self == other)
12890 
 
12891 
class addProductNotification_args:
12892 
  """
12893 
  Attributes:
12894 
   - itemId
12895 
   - email
12896 
  """
12897 
 
12898 
  thrift_spec = None
12899 
  def __init__(self, itemId=None, email=None,):
12900 
    self.itemId = itemId
12901 
    self.email = email
12902 
 
12903 
  def read(self, iprot):
12904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12906 
      return
12907 
    iprot.readStructBegin()
12908 
    while True:
12909 
      (fname, ftype, fid) = iprot.readFieldBegin()
12910 
      if ftype == TType.STOP:
12911 
        break
12912 
      if fid == -1:
12913 
        if ftype == TType.I64:
12914 
          self.itemId = iprot.readI64();
12915 
        else:
12916 
          iprot.skip(ftype)
12917 
      elif fid == -2:
12918 
        if ftype == TType.STRING:
12919 
          self.email = iprot.readString();
12920 
        else:
12921 
          iprot.skip(ftype)
12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
12931 
    oprot.writeStructBegin('addProductNotification_args')
12932 
    if self.email is not None:
12933 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12934 
      oprot.writeString(self.email)
12935 
      oprot.writeFieldEnd()
12936 
    if self.itemId is not None:
12937 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12938 
      oprot.writeI64(self.itemId)
12939 
      oprot.writeFieldEnd()
12940 
    oprot.writeFieldStop()
12941 
    oprot.writeStructEnd()
12942 
 
12943 
  def validate(self):
12944 
    return
12945 
 
12946 
 
12947 
  def __repr__(self):
12948 
    L = ['%s=%r' % (key, value)
12949 
      for key, value in self.__dict__.iteritems()]
12950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12951 
 
12952 
  def __eq__(self, other):
12953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12954 
 
12955 
  def __ne__(self, other):
12956 
    return not (self == other)
12957 
 
12958 
class addProductNotification_result:
12959 
  """
12960 
  Attributes:
12961 
   - success
12962 
  """
12963 
 
12964 
  thrift_spec = (
12965 
    (0, TType.BOOL, 'success', None, None, ), # 0
12966 
  )
12967 
 
12968 
  def __init__(self, success=None,):
12969 
    self.success = success
12970 
 
12971 
  def read(self, iprot):
12972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12974 
      return
12975 
    iprot.readStructBegin()
12976 
    while True:
12977 
      (fname, ftype, fid) = iprot.readFieldBegin()
12978 
      if ftype == TType.STOP:
12979 
        break
12980 
      if fid == 0:
12981 
        if ftype == TType.BOOL:
12982 
          self.success = iprot.readBool();
12983 
        else:
12984 
          iprot.skip(ftype)
12985 
      else:
12986 
        iprot.skip(ftype)
12987 
      iprot.readFieldEnd()
12988 
    iprot.readStructEnd()
12989 
 
12990 
  def write(self, oprot):
12991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12993 
      return
12994 
    oprot.writeStructBegin('addProductNotification_result')
12995 
    if self.success is not None:
12996 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12997 
      oprot.writeBool(self.success)
12998 
      oprot.writeFieldEnd()
12999 
    oprot.writeFieldStop()
13000 
    oprot.writeStructEnd()
13001 
 
13002 
  def validate(self):
13003 
    return
13004 
 
13005 
 
13006 
  def __repr__(self):
13007 
    L = ['%s=%r' % (key, value)
13008 
      for key, value in self.__dict__.iteritems()]
13009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13010 
 
13011 
  def __eq__(self, other):
13012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13013 
 
13014 
  def __ne__(self, other):
13015 
    return not (self == other)
13016 
 
13017 
class sendProductNotifications_args:
13018 
 
13019 
  thrift_spec = (
13020 
  )
13021 
 
13022 
  def read(self, iprot):
13023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13025 
      return
13026 
    iprot.readStructBegin()
13027 
    while True:
13028 
      (fname, ftype, fid) = iprot.readFieldBegin()
13029 
      if ftype == TType.STOP:
13030 
        break
13031 
      else:
13032 
        iprot.skip(ftype)
13033 
      iprot.readFieldEnd()
13034 
    iprot.readStructEnd()
13035 
 
13036 
  def write(self, oprot):
13037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13039 
      return
13040 
    oprot.writeStructBegin('sendProductNotifications_args')
13041 
    oprot.writeFieldStop()
13042 
    oprot.writeStructEnd()
13043 
 
13044 
  def validate(self):
13045 
    return
13046 
 
13047 
 
13048 
  def __repr__(self):
13049 
    L = ['%s=%r' % (key, value)
13050 
      for key, value in self.__dict__.iteritems()]
13051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13052 
 
13053 
  def __eq__(self, other):
13054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13055 
 
13056 
  def __ne__(self, other):
13057 
    return not (self == other)
13058 
 
13059 
class sendProductNotifications_result:
13060 
  """
13061 
  Attributes:
13062 
   - success
13063 
  """
13064 
 
13065 
  thrift_spec = (
13066 
    (0, TType.BOOL, 'success', None, None, ), # 0
13067 
  )
13068 
 
13069 
  def __init__(self, success=None,):
13070 
    self.success = success
13071 
 
13072 
  def read(self, iprot):
13073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13075 
      return
13076 
    iprot.readStructBegin()
13077 
    while True:
13078 
      (fname, ftype, fid) = iprot.readFieldBegin()
13079 
      if ftype == TType.STOP:
13080 
        break
13081 
      if fid == 0:
13082 
        if ftype == TType.BOOL:
13083 
          self.success = iprot.readBool();
13084 
        else:
13085 
          iprot.skip(ftype)
13086 
      else:
13087 
        iprot.skip(ftype)
13088 
      iprot.readFieldEnd()
13089 
    iprot.readStructEnd()
13090 
 
13091 
  def write(self, oprot):
13092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13094 
      return
13095 
    oprot.writeStructBegin('sendProductNotifications_result')
13096 
    if self.success is not None:
13097 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13098 
      oprot.writeBool(self.success)
13099 
      oprot.writeFieldEnd()
13100 
    oprot.writeFieldStop()
13101 
    oprot.writeStructEnd()
13102 
 
13103 
  def validate(self):
13104 
    return
13105 
 
13106 
 
13107 
  def __repr__(self):
13108 
    L = ['%s=%r' % (key, value)
13109 
      for key, value in self.__dict__.iteritems()]
13110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13111 
 
13112 
  def __eq__(self, other):
13113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13114 
 
13115 
  def __ne__(self, other):
13116 
    return not (self == other)
13117 
 
13118 
class getAllBrandsByCategory_args:
13119 
  """
13120 
  Attributes:
13121 
   - categoryId
13122 
  """
13123 
 
13124 
  thrift_spec = (
13125 
    None, # 0
13126 
    (1, TType.I64, 'categoryId', None, None, ), # 1
13127 
  )
13128 
 
13129 
  def __init__(self, categoryId=None,):
13130 
    self.categoryId = categoryId
13131 
 
13132 
  def read(self, iprot):
13133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13135 
      return
13136 
    iprot.readStructBegin()
13137 
    while True:
13138 
      (fname, ftype, fid) = iprot.readFieldBegin()
13139 
      if ftype == TType.STOP:
13140 
        break
13141 
      if fid == 1:
13142 
        if ftype == TType.I64:
13143 
          self.categoryId = iprot.readI64();
13144 
        else:
13145 
          iprot.skip(ftype)
13146 
      else:
13147 
        iprot.skip(ftype)
13148 
      iprot.readFieldEnd()
13149 
    iprot.readStructEnd()
13150 
 
13151 
  def write(self, oprot):
13152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13154 
      return
13155 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
13156 
    if self.categoryId is not None:
13157 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
13158 
      oprot.writeI64(self.categoryId)
13159 
      oprot.writeFieldEnd()
13160 
    oprot.writeFieldStop()
13161 
    oprot.writeStructEnd()
13162 
 
13163 
  def validate(self):
13164 
    return
13165 
 
13166 
 
13167 
  def __repr__(self):
13168 
    L = ['%s=%r' % (key, value)
13169 
      for key, value in self.__dict__.iteritems()]
13170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13171 
 
13172 
  def __eq__(self, other):
13173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13174 
 
13175 
  def __ne__(self, other):
13176 
    return not (self == other)
13177 
 
13178 
class getAllBrandsByCategory_result:
13179 
  """
13180 
  Attributes:
13181 
   - success
13182 
  """
13183 
 
13184 
  thrift_spec = (
13185 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13186 
  )
13187 
 
13188 
  def __init__(self, success=None,):
13189 
    self.success = success
13190 
 
13191 
  def read(self, iprot):
13192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13194 
      return
13195 
    iprot.readStructBegin()
13196 
    while True:
13197 
      (fname, ftype, fid) = iprot.readFieldBegin()
13198 
      if ftype == TType.STOP:
13199 
        break
13200 
      if fid == 0:
13201 
        if ftype == TType.LIST:
13202 
          self.success = []
7438 amit.gupta 13203 
          (_etype226, _size223) = iprot.readListBegin()
13204 
          for _i227 in xrange(_size223):
13205 
            _elem228 = iprot.readString();
13206 
            self.success.append(_elem228)
5944 mandeep.dh 13207 
          iprot.readListEnd()
13208 
        else:
13209 
          iprot.skip(ftype)
13210 
      else:
13211 
        iprot.skip(ftype)
13212 
      iprot.readFieldEnd()
13213 
    iprot.readStructEnd()
13214 
 
13215 
  def write(self, oprot):
13216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13218 
      return
13219 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
13220 
    if self.success is not None:
13221 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13222 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13223 
      for iter229 in self.success:
13224 
        oprot.writeString(iter229)
5944 mandeep.dh 13225 
      oprot.writeListEnd()
13226 
      oprot.writeFieldEnd()
13227 
    oprot.writeFieldStop()
13228 
    oprot.writeStructEnd()
13229 
 
13230 
  def validate(self):
13231 
    return
13232 
 
13233 
 
13234 
  def __repr__(self):
13235 
    L = ['%s=%r' % (key, value)
13236 
      for key, value in self.__dict__.iteritems()]
13237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13238 
 
13239 
  def __eq__(self, other):
13240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13241 
 
13242 
  def __ne__(self, other):
13243 
    return not (self == other)
13244 
 
13245 
class getAllBrands_args:
13246 
 
13247 
  thrift_spec = (
13248 
  )
13249 
 
13250 
  def read(self, iprot):
13251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13253 
      return
13254 
    iprot.readStructBegin()
13255 
    while True:
13256 
      (fname, ftype, fid) = iprot.readFieldBegin()
13257 
      if ftype == TType.STOP:
13258 
        break
13259 
      else:
13260 
        iprot.skip(ftype)
13261 
      iprot.readFieldEnd()
13262 
    iprot.readStructEnd()
13263 
 
13264 
  def write(self, oprot):
13265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13267 
      return
13268 
    oprot.writeStructBegin('getAllBrands_args')
13269 
    oprot.writeFieldStop()
13270 
    oprot.writeStructEnd()
13271 
 
13272 
  def validate(self):
13273 
    return
13274 
 
13275 
 
13276 
  def __repr__(self):
13277 
    L = ['%s=%r' % (key, value)
13278 
      for key, value in self.__dict__.iteritems()]
13279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13280 
 
13281 
  def __eq__(self, other):
13282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13283 
 
13284 
  def __ne__(self, other):
13285 
    return not (self == other)
13286 
 
13287 
class getAllBrands_result:
13288 
  """
13289 
  Attributes:
13290 
   - success
13291 
  """
13292 
 
13293 
  thrift_spec = (
13294 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13295 
  )
13296 
 
13297 
  def __init__(self, success=None,):
13298 
    self.success = success
13299 
 
13300 
  def read(self, iprot):
13301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13303 
      return
13304 
    iprot.readStructBegin()
13305 
    while True:
13306 
      (fname, ftype, fid) = iprot.readFieldBegin()
13307 
      if ftype == TType.STOP:
13308 
        break
13309 
      if fid == 0:
13310 
        if ftype == TType.LIST:
13311 
          self.success = []
7438 amit.gupta 13312 
          (_etype233, _size230) = iprot.readListBegin()
13313 
          for _i234 in xrange(_size230):
13314 
            _elem235 = iprot.readString();
13315 
            self.success.append(_elem235)
5944 mandeep.dh 13316 
          iprot.readListEnd()
13317 
        else:
13318 
          iprot.skip(ftype)
13319 
      else:
13320 
        iprot.skip(ftype)
13321 
      iprot.readFieldEnd()
13322 
    iprot.readStructEnd()
13323 
 
13324 
  def write(self, oprot):
13325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13327 
      return
13328 
    oprot.writeStructBegin('getAllBrands_result')
13329 
    if self.success is not None:
13330 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13331 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13332 
      for iter236 in self.success:
13333 
        oprot.writeString(iter236)
5944 mandeep.dh 13334 
      oprot.writeListEnd()
13335 
      oprot.writeFieldEnd()
13336 
    oprot.writeFieldStop()
13337 
    oprot.writeStructEnd()
13338 
 
13339 
  def validate(self):
13340 
    return
13341 
 
13342 
 
13343 
  def __repr__(self):
13344 
    L = ['%s=%r' % (key, value)
13345 
      for key, value in self.__dict__.iteritems()]
13346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13347 
 
13348 
  def __eq__(self, other):
13349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13350 
 
13351 
  def __ne__(self, other):
13352 
    return not (self == other)
13353 
 
13354 
class getAllSources_args:
13355 
 
13356 
  thrift_spec = (
13357 
  )
13358 
 
13359 
  def read(self, iprot):
13360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13362 
      return
13363 
    iprot.readStructBegin()
13364 
    while True:
13365 
      (fname, ftype, fid) = iprot.readFieldBegin()
13366 
      if ftype == TType.STOP:
13367 
        break
13368 
      else:
13369 
        iprot.skip(ftype)
13370 
      iprot.readFieldEnd()
13371 
    iprot.readStructEnd()
13372 
 
13373 
  def write(self, oprot):
13374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13376 
      return
13377 
    oprot.writeStructBegin('getAllSources_args')
13378 
    oprot.writeFieldStop()
13379 
    oprot.writeStructEnd()
13380 
 
13381 
  def validate(self):
13382 
    return
13383 
 
13384 
 
13385 
  def __repr__(self):
13386 
    L = ['%s=%r' % (key, value)
13387 
      for key, value in self.__dict__.iteritems()]
13388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13389 
 
13390 
  def __eq__(self, other):
13391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13392 
 
13393 
  def __ne__(self, other):
13394 
    return not (self == other)
13395 
 
13396 
class getAllSources_result:
13397 
  """
13398 
  Attributes:
13399 
   - success
13400 
  """
13401 
 
13402 
  thrift_spec = (
13403 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13404 
  )
13405 
 
13406 
  def __init__(self, success=None,):
13407 
    self.success = success
13408 
 
13409 
  def read(self, iprot):
13410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13412 
      return
13413 
    iprot.readStructBegin()
13414 
    while True:
13415 
      (fname, ftype, fid) = iprot.readFieldBegin()
13416 
      if ftype == TType.STOP:
13417 
        break
13418 
      if fid == 0:
13419 
        if ftype == TType.LIST:
13420 
          self.success = []
7438 amit.gupta 13421 
          (_etype240, _size237) = iprot.readListBegin()
13422 
          for _i241 in xrange(_size237):
13423 
            _elem242 = Source()
13424 
            _elem242.read(iprot)
13425 
            self.success.append(_elem242)
5944 mandeep.dh 13426 
          iprot.readListEnd()
13427 
        else:
13428 
          iprot.skip(ftype)
13429 
      else:
13430 
        iprot.skip(ftype)
13431 
      iprot.readFieldEnd()
13432 
    iprot.readStructEnd()
13433 
 
13434 
  def write(self, oprot):
13435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13437 
      return
13438 
    oprot.writeStructBegin('getAllSources_result')
13439 
    if self.success is not None:
13440 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13441 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13442 
      for iter243 in self.success:
13443 
        iter243.write(oprot)
5944 mandeep.dh 13444 
      oprot.writeListEnd()
13445 
      oprot.writeFieldEnd()
13446 
    oprot.writeFieldStop()
13447 
    oprot.writeStructEnd()
13448 
 
13449 
  def validate(self):
13450 
    return
13451 
 
13452 
 
13453 
  def __repr__(self):
13454 
    L = ['%s=%r' % (key, value)
13455 
      for key, value in self.__dict__.iteritems()]
13456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13457 
 
13458 
  def __eq__(self, other):
13459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13460 
 
13461 
  def __ne__(self, other):
13462 
    return not (self == other)
13463 
 
13464 
class getItemPricingBySource_args:
13465 
  """
13466 
  Attributes:
13467 
   - itemId
13468 
   - sourceId
13469 
  """
13470 
 
13471 
  thrift_spec = (
13472 
    None, # 0
13473 
    (1, TType.I64, 'itemId', None, None, ), # 1
13474 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13475 
  )
13476 
 
13477 
  def __init__(self, itemId=None, sourceId=None,):
13478 
    self.itemId = itemId
13479 
    self.sourceId = sourceId
13480 
 
13481 
  def read(self, iprot):
13482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13484 
      return
13485 
    iprot.readStructBegin()
13486 
    while True:
13487 
      (fname, ftype, fid) = iprot.readFieldBegin()
13488 
      if ftype == TType.STOP:
13489 
        break
13490 
      if fid == 1:
13491 
        if ftype == TType.I64:
13492 
          self.itemId = iprot.readI64();
13493 
        else:
13494 
          iprot.skip(ftype)
13495 
      elif fid == 2:
13496 
        if ftype == TType.I64:
13497 
          self.sourceId = iprot.readI64();
13498 
        else:
13499 
          iprot.skip(ftype)
13500 
      else:
13501 
        iprot.skip(ftype)
13502 
      iprot.readFieldEnd()
13503 
    iprot.readStructEnd()
13504 
 
13505 
  def write(self, oprot):
13506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13508 
      return
13509 
    oprot.writeStructBegin('getItemPricingBySource_args')
13510 
    if self.itemId is not None:
13511 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13512 
      oprot.writeI64(self.itemId)
13513 
      oprot.writeFieldEnd()
13514 
    if self.sourceId is not None:
13515 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13516 
      oprot.writeI64(self.sourceId)
13517 
      oprot.writeFieldEnd()
13518 
    oprot.writeFieldStop()
13519 
    oprot.writeStructEnd()
13520 
 
13521 
  def validate(self):
13522 
    return
13523 
 
13524 
 
13525 
  def __repr__(self):
13526 
    L = ['%s=%r' % (key, value)
13527 
      for key, value in self.__dict__.iteritems()]
13528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13529 
 
13530 
  def __eq__(self, other):
13531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13532 
 
13533 
  def __ne__(self, other):
13534 
    return not (self == other)
13535 
 
13536 
class getItemPricingBySource_result:
13537 
  """
13538 
  Attributes:
13539 
   - success
13540 
   - cex
13541 
  """
13542 
 
13543 
  thrift_spec = (
13544 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13545 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13546 
  )
13547 
 
13548 
  def __init__(self, success=None, cex=None,):
13549 
    self.success = success
13550 
    self.cex = cex
13551 
 
13552 
  def read(self, iprot):
13553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13555 
      return
13556 
    iprot.readStructBegin()
13557 
    while True:
13558 
      (fname, ftype, fid) = iprot.readFieldBegin()
13559 
      if ftype == TType.STOP:
13560 
        break
13561 
      if fid == 0:
13562 
        if ftype == TType.STRUCT:
13563 
          self.success = SourceItemPricing()
13564 
          self.success.read(iprot)
13565 
        else:
13566 
          iprot.skip(ftype)
13567 
      elif fid == 1:
13568 
        if ftype == TType.STRUCT:
13569 
          self.cex = CatalogServiceException()
13570 
          self.cex.read(iprot)
13571 
        else:
13572 
          iprot.skip(ftype)
13573 
      else:
13574 
        iprot.skip(ftype)
13575 
      iprot.readFieldEnd()
13576 
    iprot.readStructEnd()
13577 
 
13578 
  def write(self, oprot):
13579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13581 
      return
13582 
    oprot.writeStructBegin('getItemPricingBySource_result')
13583 
    if self.success is not None:
13584 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13585 
      self.success.write(oprot)
13586 
      oprot.writeFieldEnd()
13587 
    if self.cex is not None:
13588 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13589 
      self.cex.write(oprot)
13590 
      oprot.writeFieldEnd()
13591 
    oprot.writeFieldStop()
13592 
    oprot.writeStructEnd()
13593 
 
13594 
  def validate(self):
13595 
    return
13596 
 
13597 
 
13598 
  def __repr__(self):
13599 
    L = ['%s=%r' % (key, value)
13600 
      for key, value in self.__dict__.iteritems()]
13601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13602 
 
13603 
  def __eq__(self, other):
13604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13605 
 
13606 
  def __ne__(self, other):
13607 
    return not (self == other)
13608 
 
13609 
class addSourceItemPricing_args:
13610 
  """
13611 
  Attributes:
13612 
   - sourceItemPricing
13613 
  """
13614 
 
13615 
  thrift_spec = (
13616 
    None, # 0
13617 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13618 
  )
13619 
 
13620 
  def __init__(self, sourceItemPricing=None,):
13621 
    self.sourceItemPricing = sourceItemPricing
13622 
 
13623 
  def read(self, iprot):
13624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13626 
      return
13627 
    iprot.readStructBegin()
13628 
    while True:
13629 
      (fname, ftype, fid) = iprot.readFieldBegin()
13630 
      if ftype == TType.STOP:
13631 
        break
13632 
      if fid == 1:
13633 
        if ftype == TType.STRUCT:
13634 
          self.sourceItemPricing = SourceItemPricing()
13635 
          self.sourceItemPricing.read(iprot)
13636 
        else:
13637 
          iprot.skip(ftype)
13638 
      else:
13639 
        iprot.skip(ftype)
13640 
      iprot.readFieldEnd()
13641 
    iprot.readStructEnd()
13642 
 
13643 
  def write(self, oprot):
13644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13646 
      return
13647 
    oprot.writeStructBegin('addSourceItemPricing_args')
13648 
    if self.sourceItemPricing is not None:
13649 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13650 
      self.sourceItemPricing.write(oprot)
13651 
      oprot.writeFieldEnd()
13652 
    oprot.writeFieldStop()
13653 
    oprot.writeStructEnd()
13654 
 
13655 
  def validate(self):
13656 
    return
13657 
 
13658 
 
13659 
  def __repr__(self):
13660 
    L = ['%s=%r' % (key, value)
13661 
      for key, value in self.__dict__.iteritems()]
13662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13663 
 
13664 
  def __eq__(self, other):
13665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13666 
 
13667 
  def __ne__(self, other):
13668 
    return not (self == other)
13669 
 
13670 
class addSourceItemPricing_result:
13671 
  """
13672 
  Attributes:
13673 
   - cex
13674 
  """
13675 
 
13676 
  thrift_spec = (
13677 
    None, # 0
13678 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13679 
  )
13680 
 
13681 
  def __init__(self, cex=None,):
13682 
    self.cex = cex
13683 
 
13684 
  def read(self, iprot):
13685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13687 
      return
13688 
    iprot.readStructBegin()
13689 
    while True:
13690 
      (fname, ftype, fid) = iprot.readFieldBegin()
13691 
      if ftype == TType.STOP:
13692 
        break
13693 
      if fid == 1:
13694 
        if ftype == TType.STRUCT:
13695 
          self.cex = CatalogServiceException()
13696 
          self.cex.read(iprot)
13697 
        else:
13698 
          iprot.skip(ftype)
13699 
      else:
13700 
        iprot.skip(ftype)
13701 
      iprot.readFieldEnd()
13702 
    iprot.readStructEnd()
13703 
 
13704 
  def write(self, oprot):
13705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13707 
      return
13708 
    oprot.writeStructBegin('addSourceItemPricing_result')
13709 
    if self.cex is not None:
13710 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13711 
      self.cex.write(oprot)
13712 
      oprot.writeFieldEnd()
13713 
    oprot.writeFieldStop()
13714 
    oprot.writeStructEnd()
13715 
 
13716 
  def validate(self):
13717 
    return
13718 
 
13719 
 
13720 
  def __repr__(self):
13721 
    L = ['%s=%r' % (key, value)
13722 
      for key, value in self.__dict__.iteritems()]
13723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13724 
 
13725 
  def __eq__(self, other):
13726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13727 
 
13728 
  def __ne__(self, other):
13729 
    return not (self == other)
13730 
 
13731 
class getAllSourcePricing_args:
13732 
  """
13733 
  Attributes:
13734 
   - itemId
13735 
  """
13736 
 
13737 
  thrift_spec = (
13738 
    None, # 0
13739 
    (1, TType.I64, 'itemId', None, None, ), # 1
13740 
  )
13741 
 
13742 
  def __init__(self, itemId=None,):
13743 
    self.itemId = itemId
13744 
 
13745 
  def read(self, iprot):
13746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13748 
      return
13749 
    iprot.readStructBegin()
13750 
    while True:
13751 
      (fname, ftype, fid) = iprot.readFieldBegin()
13752 
      if ftype == TType.STOP:
13753 
        break
13754 
      if fid == 1:
13755 
        if ftype == TType.I64:
13756 
          self.itemId = iprot.readI64();
13757 
        else:
13758 
          iprot.skip(ftype)
13759 
      else:
13760 
        iprot.skip(ftype)
13761 
      iprot.readFieldEnd()
13762 
    iprot.readStructEnd()
13763 
 
13764 
  def write(self, oprot):
13765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13767 
      return
13768 
    oprot.writeStructBegin('getAllSourcePricing_args')
13769 
    if self.itemId is not None:
13770 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13771 
      oprot.writeI64(self.itemId)
13772 
      oprot.writeFieldEnd()
13773 
    oprot.writeFieldStop()
13774 
    oprot.writeStructEnd()
13775 
 
13776 
  def validate(self):
13777 
    return
13778 
 
13779 
 
13780 
  def __repr__(self):
13781 
    L = ['%s=%r' % (key, value)
13782 
      for key, value in self.__dict__.iteritems()]
13783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13784 
 
13785 
  def __eq__(self, other):
13786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13787 
 
13788 
  def __ne__(self, other):
13789 
    return not (self == other)
13790 
 
13791 
class getAllSourcePricing_result:
13792 
  """
13793 
  Attributes:
13794 
   - success
13795 
   - cex
13796 
  """
13797 
 
13798 
  thrift_spec = (
13799 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13800 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13801 
  )
13802 
 
13803 
  def __init__(self, success=None, cex=None,):
13804 
    self.success = success
13805 
    self.cex = cex
13806 
 
13807 
  def read(self, iprot):
13808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13810 
      return
13811 
    iprot.readStructBegin()
13812 
    while True:
13813 
      (fname, ftype, fid) = iprot.readFieldBegin()
13814 
      if ftype == TType.STOP:
13815 
        break
13816 
      if fid == 0:
13817 
        if ftype == TType.LIST:
13818 
          self.success = []
7438 amit.gupta 13819 
          (_etype247, _size244) = iprot.readListBegin()
13820 
          for _i248 in xrange(_size244):
13821 
            _elem249 = SourceItemPricing()
13822 
            _elem249.read(iprot)
13823 
            self.success.append(_elem249)
5944 mandeep.dh 13824 
          iprot.readListEnd()
13825 
        else:
13826 
          iprot.skip(ftype)
13827 
      elif fid == 1:
13828 
        if ftype == TType.STRUCT:
13829 
          self.cex = CatalogServiceException()
13830 
          self.cex.read(iprot)
13831 
        else:
13832 
          iprot.skip(ftype)
13833 
      else:
13834 
        iprot.skip(ftype)
13835 
      iprot.readFieldEnd()
13836 
    iprot.readStructEnd()
13837 
 
13838 
  def write(self, oprot):
13839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13841 
      return
13842 
    oprot.writeStructBegin('getAllSourcePricing_result')
13843 
    if self.success is not None:
13844 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13845 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13846 
      for iter250 in self.success:
13847 
        iter250.write(oprot)
5944 mandeep.dh 13848 
      oprot.writeListEnd()
13849 
      oprot.writeFieldEnd()
13850 
    if self.cex is not None:
13851 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13852 
      self.cex.write(oprot)
13853 
      oprot.writeFieldEnd()
13854 
    oprot.writeFieldStop()
13855 
    oprot.writeStructEnd()
13856 
 
13857 
  def validate(self):
13858 
    return
13859 
 
13860 
 
13861 
  def __repr__(self):
13862 
    L = ['%s=%r' % (key, value)
13863 
      for key, value in self.__dict__.iteritems()]
13864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13865 
 
13866 
  def __eq__(self, other):
13867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13868 
 
13869 
  def __ne__(self, other):
13870 
    return not (self == other)
13871 
 
13872 
class getItemForSource_args:
13873 
  """
13874 
  Attributes:
13875 
   - item_id
13876 
   - sourceId
13877 
  """
13878 
 
13879 
  thrift_spec = (
13880 
    None, # 0
13881 
    (1, TType.I64, 'item_id', None, None, ), # 1
13882 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13883 
  )
13884 
 
13885 
  def __init__(self, item_id=None, sourceId=None,):
13886 
    self.item_id = item_id
13887 
    self.sourceId = sourceId
13888 
 
13889 
  def read(self, iprot):
13890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13892 
      return
13893 
    iprot.readStructBegin()
13894 
    while True:
13895 
      (fname, ftype, fid) = iprot.readFieldBegin()
13896 
      if ftype == TType.STOP:
13897 
        break
13898 
      if fid == 1:
13899 
        if ftype == TType.I64:
13900 
          self.item_id = iprot.readI64();
13901 
        else:
13902 
          iprot.skip(ftype)
13903 
      elif fid == 2:
13904 
        if ftype == TType.I64:
13905 
          self.sourceId = iprot.readI64();
13906 
        else:
13907 
          iprot.skip(ftype)
13908 
      else:
13909 
        iprot.skip(ftype)
13910 
      iprot.readFieldEnd()
13911 
    iprot.readStructEnd()
13912 
 
13913 
  def write(self, oprot):
13914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13916 
      return
13917 
    oprot.writeStructBegin('getItemForSource_args')
13918 
    if self.item_id is not None:
13919 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13920 
      oprot.writeI64(self.item_id)
13921 
      oprot.writeFieldEnd()
13922 
    if self.sourceId is not None:
13923 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13924 
      oprot.writeI64(self.sourceId)
13925 
      oprot.writeFieldEnd()
13926 
    oprot.writeFieldStop()
13927 
    oprot.writeStructEnd()
13928 
 
13929 
  def validate(self):
13930 
    return
13931 
 
13932 
 
13933 
  def __repr__(self):
13934 
    L = ['%s=%r' % (key, value)
13935 
      for key, value in self.__dict__.iteritems()]
13936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13937 
 
13938 
  def __eq__(self, other):
13939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13940 
 
13941 
  def __ne__(self, other):
13942 
    return not (self == other)
13943 
 
13944 
class getItemForSource_result:
13945 
  """
13946 
  Attributes:
13947 
   - success
13948 
   - cex
13949 
  """
13950 
 
13951 
  thrift_spec = (
13952 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13953 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13954 
  )
13955 
 
13956 
  def __init__(self, success=None, cex=None,):
13957 
    self.success = success
13958 
    self.cex = cex
13959 
 
13960 
  def read(self, iprot):
13961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13963 
      return
13964 
    iprot.readStructBegin()
13965 
    while True:
13966 
      (fname, ftype, fid) = iprot.readFieldBegin()
13967 
      if ftype == TType.STOP:
13968 
        break
13969 
      if fid == 0:
13970 
        if ftype == TType.STRUCT:
13971 
          self.success = Item()
13972 
          self.success.read(iprot)
13973 
        else:
13974 
          iprot.skip(ftype)
13975 
      elif fid == 1:
13976 
        if ftype == TType.STRUCT:
13977 
          self.cex = CatalogServiceException()
13978 
          self.cex.read(iprot)
13979 
        else:
13980 
          iprot.skip(ftype)
13981 
      else:
13982 
        iprot.skip(ftype)
13983 
      iprot.readFieldEnd()
13984 
    iprot.readStructEnd()
13985 
 
13986 
  def write(self, oprot):
13987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13989 
      return
13990 
    oprot.writeStructBegin('getItemForSource_result')
13991 
    if self.success is not None:
13992 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13993 
      self.success.write(oprot)
13994 
      oprot.writeFieldEnd()
13995 
    if self.cex is not None:
13996 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13997 
      self.cex.write(oprot)
13998 
      oprot.writeFieldEnd()
13999 
    oprot.writeFieldStop()
14000 
    oprot.writeStructEnd()
14001 
 
14002 
  def validate(self):
14003 
    return
14004 
 
14005 
 
14006 
  def __repr__(self):
14007 
    L = ['%s=%r' % (key, value)
14008 
      for key, value in self.__dict__.iteritems()]
14009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14010 
 
14011 
  def __eq__(self, other):
14012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14013 
 
14014 
  def __ne__(self, other):
14015 
    return not (self == other)
14016 
 
14017 
class searchItemsInRange_args:
14018 
  """
14019 
  Attributes:
14020 
   - searchTerms
14021 
   - offset
14022 
   - limit
14023 
  """
14024 
 
14025 
  thrift_spec = (
14026 
    None, # 0
14027 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14028 
    (2, TType.I64, 'offset', None, None, ), # 2
14029 
    (3, TType.I64, 'limit', None, None, ), # 3
14030 
  )
14031 
 
14032 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
14033 
    self.searchTerms = searchTerms
14034 
    self.offset = offset
14035 
    self.limit = limit
14036 
 
14037 
  def read(self, iprot):
14038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14040 
      return
14041 
    iprot.readStructBegin()
14042 
    while True:
14043 
      (fname, ftype, fid) = iprot.readFieldBegin()
14044 
      if ftype == TType.STOP:
14045 
        break
14046 
      if fid == 1:
14047 
        if ftype == TType.LIST:
14048 
          self.searchTerms = []
7438 amit.gupta 14049 
          (_etype254, _size251) = iprot.readListBegin()
14050 
          for _i255 in xrange(_size251):
14051 
            _elem256 = iprot.readString();
14052 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 14053 
          iprot.readListEnd()
14054 
        else:
14055 
          iprot.skip(ftype)
14056 
      elif fid == 2:
14057 
        if ftype == TType.I64:
14058 
          self.offset = iprot.readI64();
14059 
        else:
14060 
          iprot.skip(ftype)
14061 
      elif fid == 3:
14062 
        if ftype == TType.I64:
14063 
          self.limit = iprot.readI64();
14064 
        else:
14065 
          iprot.skip(ftype)
14066 
      else:
14067 
        iprot.skip(ftype)
14068 
      iprot.readFieldEnd()
14069 
    iprot.readStructEnd()
14070 
 
14071 
  def write(self, oprot):
14072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14074 
      return
14075 
    oprot.writeStructBegin('searchItemsInRange_args')
14076 
    if self.searchTerms is not None:
14077 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14078 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14079 
      for iter257 in self.searchTerms:
14080 
        oprot.writeString(iter257)
5944 mandeep.dh 14081 
      oprot.writeListEnd()
14082 
      oprot.writeFieldEnd()
14083 
    if self.offset is not None:
14084 
      oprot.writeFieldBegin('offset', TType.I64, 2)
14085 
      oprot.writeI64(self.offset)
14086 
      oprot.writeFieldEnd()
14087 
    if self.limit is not None:
14088 
      oprot.writeFieldBegin('limit', TType.I64, 3)
14089 
      oprot.writeI64(self.limit)
14090 
      oprot.writeFieldEnd()
14091 
    oprot.writeFieldStop()
14092 
    oprot.writeStructEnd()
14093 
 
14094 
  def validate(self):
14095 
    return
14096 
 
14097 
 
14098 
  def __repr__(self):
14099 
    L = ['%s=%r' % (key, value)
14100 
      for key, value in self.__dict__.iteritems()]
14101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14102 
 
14103 
  def __eq__(self, other):
14104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14105 
 
14106 
  def __ne__(self, other):
14107 
    return not (self == other)
14108 
 
14109 
class searchItemsInRange_result:
14110 
  """
14111 
  Attributes:
14112 
   - success
14113 
  """
14114 
 
14115 
  thrift_spec = (
14116 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14117 
  )
14118 
 
14119 
  def __init__(self, success=None,):
14120 
    self.success = success
14121 
 
14122 
  def read(self, iprot):
14123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14125 
      return
14126 
    iprot.readStructBegin()
14127 
    while True:
14128 
      (fname, ftype, fid) = iprot.readFieldBegin()
14129 
      if ftype == TType.STOP:
14130 
        break
14131 
      if fid == 0:
14132 
        if ftype == TType.LIST:
14133 
          self.success = []
7438 amit.gupta 14134 
          (_etype261, _size258) = iprot.readListBegin()
14135 
          for _i262 in xrange(_size258):
14136 
            _elem263 = Item()
14137 
            _elem263.read(iprot)
14138 
            self.success.append(_elem263)
5944 mandeep.dh 14139 
          iprot.readListEnd()
14140 
        else:
14141 
          iprot.skip(ftype)
14142 
      else:
14143 
        iprot.skip(ftype)
14144 
      iprot.readFieldEnd()
14145 
    iprot.readStructEnd()
14146 
 
14147 
  def write(self, oprot):
14148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14150 
      return
14151 
    oprot.writeStructBegin('searchItemsInRange_result')
14152 
    if self.success is not None:
14153 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14154 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14155 
      for iter264 in self.success:
14156 
        iter264.write(oprot)
5944 mandeep.dh 14157 
      oprot.writeListEnd()
14158 
      oprot.writeFieldEnd()
14159 
    oprot.writeFieldStop()
14160 
    oprot.writeStructEnd()
14161 
 
14162 
  def validate(self):
14163 
    return
14164 
 
14165 
 
14166 
  def __repr__(self):
14167 
    L = ['%s=%r' % (key, value)
14168 
      for key, value in self.__dict__.iteritems()]
14169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14170 
 
14171 
  def __eq__(self, other):
14172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14173 
 
14174 
  def __ne__(self, other):
14175 
    return not (self == other)
14176 
 
14177 
class getSearchResultCount_args:
14178 
  """
14179 
  Attributes:
14180 
   - searchTerms
14181 
  """
14182 
 
14183 
  thrift_spec = (
14184 
    None, # 0
14185 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
14186 
  )
14187 
 
14188 
  def __init__(self, searchTerms=None,):
14189 
    self.searchTerms = searchTerms
14190 
 
14191 
  def read(self, iprot):
14192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14194 
      return
14195 
    iprot.readStructBegin()
14196 
    while True:
14197 
      (fname, ftype, fid) = iprot.readFieldBegin()
14198 
      if ftype == TType.STOP:
14199 
        break
14200 
      if fid == 1:
14201 
        if ftype == TType.LIST:
14202 
          self.searchTerms = []
7438 amit.gupta 14203 
          (_etype268, _size265) = iprot.readListBegin()
14204 
          for _i269 in xrange(_size265):
14205 
            _elem270 = iprot.readString();
14206 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 14207 
          iprot.readListEnd()
14208 
        else:
14209 
          iprot.skip(ftype)
14210 
      else:
14211 
        iprot.skip(ftype)
14212 
      iprot.readFieldEnd()
14213 
    iprot.readStructEnd()
14214 
 
14215 
  def write(self, oprot):
14216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14218 
      return
14219 
    oprot.writeStructBegin('getSearchResultCount_args')
14220 
    if self.searchTerms is not None:
14221 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
14222 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 14223 
      for iter271 in self.searchTerms:
14224 
        oprot.writeString(iter271)
5944 mandeep.dh 14225 
      oprot.writeListEnd()
14226 
      oprot.writeFieldEnd()
14227 
    oprot.writeFieldStop()
14228 
    oprot.writeStructEnd()
14229 
 
14230 
  def validate(self):
14231 
    return
14232 
 
14233 
 
14234 
  def __repr__(self):
14235 
    L = ['%s=%r' % (key, value)
14236 
      for key, value in self.__dict__.iteritems()]
14237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14238 
 
14239 
  def __eq__(self, other):
14240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14241 
 
14242 
  def __ne__(self, other):
14243 
    return not (self == other)
14244 
 
14245 
class getSearchResultCount_result:
14246 
  """
14247 
  Attributes:
14248 
   - success
14249 
  """
14250 
 
14251 
  thrift_spec = (
14252 
    (0, TType.I32, 'success', None, None, ), # 0
14253 
  )
14254 
 
14255 
  def __init__(self, success=None,):
14256 
    self.success = success
14257 
 
14258 
  def read(self, iprot):
14259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14261 
      return
14262 
    iprot.readStructBegin()
14263 
    while True:
14264 
      (fname, ftype, fid) = iprot.readFieldBegin()
14265 
      if ftype == TType.STOP:
14266 
        break
14267 
      if fid == 0:
14268 
        if ftype == TType.I32:
14269 
          self.success = iprot.readI32();
14270 
        else:
14271 
          iprot.skip(ftype)
14272 
      else:
14273 
        iprot.skip(ftype)
14274 
      iprot.readFieldEnd()
14275 
    iprot.readStructEnd()
14276 
 
14277 
  def write(self, oprot):
14278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14280 
      return
14281 
    oprot.writeStructBegin('getSearchResultCount_result')
14282 
    if self.success is not None:
14283 
      oprot.writeFieldBegin('success', TType.I32, 0)
14284 
      oprot.writeI32(self.success)
14285 
      oprot.writeFieldEnd()
14286 
    oprot.writeFieldStop()
14287 
    oprot.writeStructEnd()
14288 
 
14289 
  def validate(self):
14290 
    return
14291 
 
14292 
 
14293 
  def __repr__(self):
14294 
    L = ['%s=%r' % (key, value)
14295 
      for key, value in self.__dict__.iteritems()]
14296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14297 
 
14298 
  def __eq__(self, other):
14299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14300 
 
14301 
  def __ne__(self, other):
14302 
    return not (self == other)
14303 
 
14304 
class getProductNotifications_args:
14305 
  """
14306 
  Attributes:
14307 
   - startDateTime
14308 
  """
14309 
 
14310 
  thrift_spec = (
14311 
    None, # 0
14312 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14313 
  )
14314 
 
14315 
  def __init__(self, startDateTime=None,):
14316 
    self.startDateTime = startDateTime
14317 
 
14318 
  def read(self, iprot):
14319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14321 
      return
14322 
    iprot.readStructBegin()
14323 
    while True:
14324 
      (fname, ftype, fid) = iprot.readFieldBegin()
14325 
      if ftype == TType.STOP:
14326 
        break
14327 
      if fid == 1:
14328 
        if ftype == TType.I64:
14329 
          self.startDateTime = iprot.readI64();
14330 
        else:
14331 
          iprot.skip(ftype)
14332 
      else:
14333 
        iprot.skip(ftype)
14334 
      iprot.readFieldEnd()
14335 
    iprot.readStructEnd()
14336 
 
14337 
  def write(self, oprot):
14338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14340 
      return
14341 
    oprot.writeStructBegin('getProductNotifications_args')
14342 
    if self.startDateTime is not None:
14343 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14344 
      oprot.writeI64(self.startDateTime)
14345 
      oprot.writeFieldEnd()
14346 
    oprot.writeFieldStop()
14347 
    oprot.writeStructEnd()
14348 
 
14349 
  def validate(self):
14350 
    return
14351 
 
14352 
 
14353 
  def __repr__(self):
14354 
    L = ['%s=%r' % (key, value)
14355 
      for key, value in self.__dict__.iteritems()]
14356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14357 
 
14358 
  def __eq__(self, other):
14359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14360 
 
14361 
  def __ne__(self, other):
14362 
    return not (self == other)
14363 
 
14364 
class getProductNotifications_result:
14365 
  """
14366 
  Attributes:
14367 
   - success
14368 
  """
14369 
 
14370 
  thrift_spec = (
14371 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14372 
  )
14373 
 
14374 
  def __init__(self, success=None,):
14375 
    self.success = success
14376 
 
14377 
  def read(self, iprot):
14378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14380 
      return
14381 
    iprot.readStructBegin()
14382 
    while True:
14383 
      (fname, ftype, fid) = iprot.readFieldBegin()
14384 
      if ftype == TType.STOP:
14385 
        break
14386 
      if fid == 0:
14387 
        if ftype == TType.LIST:
14388 
          self.success = []
7438 amit.gupta 14389 
          (_etype275, _size272) = iprot.readListBegin()
14390 
          for _i276 in xrange(_size272):
14391 
            _elem277 = ProductNotificationRequest()
14392 
            _elem277.read(iprot)
14393 
            self.success.append(_elem277)
5944 mandeep.dh 14394 
          iprot.readListEnd()
14395 
        else:
14396 
          iprot.skip(ftype)
14397 
      else:
14398 
        iprot.skip(ftype)
14399 
      iprot.readFieldEnd()
14400 
    iprot.readStructEnd()
14401 
 
14402 
  def write(self, oprot):
14403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14405 
      return
14406 
    oprot.writeStructBegin('getProductNotifications_result')
14407 
    if self.success is not None:
14408 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14409 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14410 
      for iter278 in self.success:
14411 
        iter278.write(oprot)
5944 mandeep.dh 14412 
      oprot.writeListEnd()
14413 
      oprot.writeFieldEnd()
14414 
    oprot.writeFieldStop()
14415 
    oprot.writeStructEnd()
14416 
 
14417 
  def validate(self):
14418 
    return
14419 
 
14420 
 
14421 
  def __repr__(self):
14422 
    L = ['%s=%r' % (key, value)
14423 
      for key, value in self.__dict__.iteritems()]
14424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14425 
 
14426 
  def __eq__(self, other):
14427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14428 
 
14429 
  def __ne__(self, other):
14430 
    return not (self == other)
14431 
 
14432 
class getProductNotificationRequestCount_args:
14433 
  """
14434 
  Attributes:
14435 
   - startDateTime
7897 amar.kumar 14436 
   - categoryId
5944 mandeep.dh 14437 
  """
14438 
 
14439 
  thrift_spec = (
14440 
    None, # 0
14441 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 14442 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 14443 
  )
14444 
 
7897 amar.kumar 14445 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 14446 
    self.startDateTime = startDateTime
7897 amar.kumar 14447 
    self.categoryId = categoryId
5944 mandeep.dh 14448 
 
14449 
  def read(self, iprot):
14450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14452 
      return
14453 
    iprot.readStructBegin()
14454 
    while True:
14455 
      (fname, ftype, fid) = iprot.readFieldBegin()
14456 
      if ftype == TType.STOP:
14457 
        break
14458 
      if fid == 1:
14459 
        if ftype == TType.I64:
14460 
          self.startDateTime = iprot.readI64();
14461 
        else:
14462 
          iprot.skip(ftype)
7897 amar.kumar 14463 
      elif fid == 2:
14464 
        if ftype == TType.I64:
14465 
          self.categoryId = iprot.readI64();
14466 
        else:
14467 
          iprot.skip(ftype)
5944 mandeep.dh 14468 
      else:
14469 
        iprot.skip(ftype)
14470 
      iprot.readFieldEnd()
14471 
    iprot.readStructEnd()
14472 
 
14473 
  def write(self, oprot):
14474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14476 
      return
14477 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14478 
    if self.startDateTime is not None:
14479 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14480 
      oprot.writeI64(self.startDateTime)
14481 
      oprot.writeFieldEnd()
7897 amar.kumar 14482 
    if self.categoryId is not None:
14483 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
14484 
      oprot.writeI64(self.categoryId)
14485 
      oprot.writeFieldEnd()
5944 mandeep.dh 14486 
    oprot.writeFieldStop()
14487 
    oprot.writeStructEnd()
14488 
 
14489 
  def validate(self):
14490 
    return
14491 
 
14492 
 
14493 
  def __repr__(self):
14494 
    L = ['%s=%r' % (key, value)
14495 
      for key, value in self.__dict__.iteritems()]
14496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14497 
 
14498 
  def __eq__(self, other):
14499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14500 
 
14501 
  def __ne__(self, other):
14502 
    return not (self == other)
14503 
 
14504 
class getProductNotificationRequestCount_result:
14505 
  """
14506 
  Attributes:
14507 
   - success
14508 
  """
14509 
 
14510 
  thrift_spec = (
14511 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14512 
  )
14513 
 
14514 
  def __init__(self, success=None,):
14515 
    self.success = success
14516 
 
14517 
  def read(self, iprot):
14518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14520 
      return
14521 
    iprot.readStructBegin()
14522 
    while True:
14523 
      (fname, ftype, fid) = iprot.readFieldBegin()
14524 
      if ftype == TType.STOP:
14525 
        break
14526 
      if fid == 0:
14527 
        if ftype == TType.LIST:
14528 
          self.success = []
7438 amit.gupta 14529 
          (_etype282, _size279) = iprot.readListBegin()
14530 
          for _i283 in xrange(_size279):
14531 
            _elem284 = ProductNotificationRequestCount()
14532 
            _elem284.read(iprot)
14533 
            self.success.append(_elem284)
5944 mandeep.dh 14534 
          iprot.readListEnd()
14535 
        else:
14536 
          iprot.skip(ftype)
14537 
      else:
14538 
        iprot.skip(ftype)
14539 
      iprot.readFieldEnd()
14540 
    iprot.readStructEnd()
14541 
 
14542 
  def write(self, oprot):
14543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14545 
      return
14546 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14547 
    if self.success is not None:
14548 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14549 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14550 
      for iter285 in self.success:
14551 
        iter285.write(oprot)
5944 mandeep.dh 14552 
      oprot.writeListEnd()
14553 
      oprot.writeFieldEnd()
14554 
    oprot.writeFieldStop()
14555 
    oprot.writeStructEnd()
14556 
 
14557 
  def validate(self):
14558 
    return
14559 
 
14560 
 
14561 
  def __repr__(self):
14562 
    L = ['%s=%r' % (key, value)
14563 
      for key, value in self.__dict__.iteritems()]
14564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14565 
 
14566 
  def __eq__(self, other):
14567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14568 
 
14569 
  def __ne__(self, other):
14570 
    return not (self == other)
14571 
 
14572 
class addAuthorizationLog_args:
14573 
  """
14574 
  Attributes:
14575 
   - itemId
14576 
   - username
14577 
   - reason
14578 
  """
14579 
 
14580 
  thrift_spec = (
14581 
    None, # 0
14582 
    (1, TType.I64, 'itemId', None, None, ), # 1
14583 
    (2, TType.STRING, 'username', None, None, ), # 2
14584 
    (3, TType.STRING, 'reason', None, None, ), # 3
14585 
  )
14586 
 
14587 
  def __init__(self, itemId=None, username=None, reason=None,):
14588 
    self.itemId = itemId
14589 
    self.username = username
14590 
    self.reason = reason
14591 
 
14592 
  def read(self, iprot):
14593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14595 
      return
14596 
    iprot.readStructBegin()
14597 
    while True:
14598 
      (fname, ftype, fid) = iprot.readFieldBegin()
14599 
      if ftype == TType.STOP:
14600 
        break
14601 
      if fid == 1:
14602 
        if ftype == TType.I64:
14603 
          self.itemId = iprot.readI64();
14604 
        else:
14605 
          iprot.skip(ftype)
14606 
      elif fid == 2:
14607 
        if ftype == TType.STRING:
14608 
          self.username = iprot.readString();
14609 
        else:
14610 
          iprot.skip(ftype)
14611 
      elif fid == 3:
14612 
        if ftype == TType.STRING:
14613 
          self.reason = iprot.readString();
14614 
        else:
14615 
          iprot.skip(ftype)
14616 
      else:
14617 
        iprot.skip(ftype)
14618 
      iprot.readFieldEnd()
14619 
    iprot.readStructEnd()
14620 
 
14621 
  def write(self, oprot):
14622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14624 
      return
14625 
    oprot.writeStructBegin('addAuthorizationLog_args')
14626 
    if self.itemId is not None:
14627 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14628 
      oprot.writeI64(self.itemId)
14629 
      oprot.writeFieldEnd()
14630 
    if self.username is not None:
14631 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14632 
      oprot.writeString(self.username)
14633 
      oprot.writeFieldEnd()
14634 
    if self.reason is not None:
14635 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14636 
      oprot.writeString(self.reason)
14637 
      oprot.writeFieldEnd()
14638 
    oprot.writeFieldStop()
14639 
    oprot.writeStructEnd()
14640 
 
14641 
  def validate(self):
14642 
    return
14643 
 
14644 
 
14645 
  def __repr__(self):
14646 
    L = ['%s=%r' % (key, value)
14647 
      for key, value in self.__dict__.iteritems()]
14648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14649 
 
14650 
  def __eq__(self, other):
14651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14652 
 
14653 
  def __ne__(self, other):
14654 
    return not (self == other)
14655 
 
14656 
class addAuthorizationLog_result:
14657 
  """
14658 
  Attributes:
14659 
   - success
14660 
   - cex
14661 
  """
14662 
 
14663 
  thrift_spec = (
14664 
    (0, TType.BOOL, 'success', None, None, ), # 0
14665 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14666 
  )
14667 
 
14668 
  def __init__(self, success=None, cex=None,):
14669 
    self.success = success
14670 
    self.cex = cex
14671 
 
14672 
  def read(self, iprot):
14673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14675 
      return
14676 
    iprot.readStructBegin()
14677 
    while True:
14678 
      (fname, ftype, fid) = iprot.readFieldBegin()
14679 
      if ftype == TType.STOP:
14680 
        break
14681 
      if fid == 0:
14682 
        if ftype == TType.BOOL:
14683 
          self.success = iprot.readBool();
14684 
        else:
14685 
          iprot.skip(ftype)
14686 
      elif fid == 1:
14687 
        if ftype == TType.STRUCT:
14688 
          self.cex = CatalogServiceException()
14689 
          self.cex.read(iprot)
14690 
        else:
14691 
          iprot.skip(ftype)
14692 
      else:
14693 
        iprot.skip(ftype)
14694 
      iprot.readFieldEnd()
14695 
    iprot.readStructEnd()
14696 
 
14697 
  def write(self, oprot):
14698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14700 
      return
14701 
    oprot.writeStructBegin('addAuthorizationLog_result')
14702 
    if self.success is not None:
14703 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14704 
      oprot.writeBool(self.success)
14705 
      oprot.writeFieldEnd()
14706 
    if self.cex is not None:
14707 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14708 
      self.cex.write(oprot)
14709 
      oprot.writeFieldEnd()
14710 
    oprot.writeFieldStop()
14711 
    oprot.writeStructEnd()
14712 
 
14713 
  def validate(self):
14714 
    return
14715 
 
14716 
 
14717 
  def __repr__(self):
14718 
    L = ['%s=%r' % (key, value)
14719 
      for key, value in self.__dict__.iteritems()]
14720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14721 
 
14722 
  def __eq__(self, other):
14723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14724 
 
14725 
  def __ne__(self, other):
14726 
    return not (self == other)
14727 
 
14728 
class addupdateVoucherForItem_args:
14729 
  """
14730 
  Attributes:
14731 
   - catalog_item_id
14732 
   - voucherType
14733 
   - voucherAmount
14734 
  """
14735 
 
14736 
  thrift_spec = (
14737 
    None, # 0
14738 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14739 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14740 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14741 
  )
14742 
 
14743 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14744 
    self.catalog_item_id = catalog_item_id
14745 
    self.voucherType = voucherType
14746 
    self.voucherAmount = voucherAmount
14747 
 
14748 
  def read(self, iprot):
14749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14751 
      return
14752 
    iprot.readStructBegin()
14753 
    while True:
14754 
      (fname, ftype, fid) = iprot.readFieldBegin()
14755 
      if ftype == TType.STOP:
14756 
        break
14757 
      if fid == 1:
14758 
        if ftype == TType.I64:
14759 
          self.catalog_item_id = iprot.readI64();
14760 
        else:
14761 
          iprot.skip(ftype)
14762 
      elif fid == 2:
14763 
        if ftype == TType.I64:
14764 
          self.voucherType = iprot.readI64();
14765 
        else:
14766 
          iprot.skip(ftype)
14767 
      elif fid == 3:
14768 
        if ftype == TType.I64:
14769 
          self.voucherAmount = iprot.readI64();
14770 
        else:
14771 
          iprot.skip(ftype)
14772 
      else:
14773 
        iprot.skip(ftype)
14774 
      iprot.readFieldEnd()
14775 
    iprot.readStructEnd()
14776 
 
14777 
  def write(self, oprot):
14778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14780 
      return
14781 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14782 
    if self.catalog_item_id is not None:
14783 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14784 
      oprot.writeI64(self.catalog_item_id)
14785 
      oprot.writeFieldEnd()
14786 
    if self.voucherType is not None:
14787 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14788 
      oprot.writeI64(self.voucherType)
14789 
      oprot.writeFieldEnd()
14790 
    if self.voucherAmount is not None:
14791 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14792 
      oprot.writeI64(self.voucherAmount)
14793 
      oprot.writeFieldEnd()
14794 
    oprot.writeFieldStop()
14795 
    oprot.writeStructEnd()
14796 
 
14797 
  def validate(self):
14798 
    return
14799 
 
14800 
 
14801 
  def __repr__(self):
14802 
    L = ['%s=%r' % (key, value)
14803 
      for key, value in self.__dict__.iteritems()]
14804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14805 
 
14806 
  def __eq__(self, other):
14807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14808 
 
14809 
  def __ne__(self, other):
14810 
    return not (self == other)
14811 
 
14812 
class addupdateVoucherForItem_result:
14813 
  """
14814 
  Attributes:
14815 
   - success
14816 
   - cex
14817 
  """
14818 
 
14819 
  thrift_spec = (
14820 
    (0, TType.BOOL, 'success', None, None, ), # 0
14821 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14822 
  )
14823 
 
14824 
  def __init__(self, success=None, cex=None,):
14825 
    self.success = success
14826 
    self.cex = cex
14827 
 
14828 
  def read(self, iprot):
14829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14831 
      return
14832 
    iprot.readStructBegin()
14833 
    while True:
14834 
      (fname, ftype, fid) = iprot.readFieldBegin()
14835 
      if ftype == TType.STOP:
14836 
        break
14837 
      if fid == 0:
14838 
        if ftype == TType.BOOL:
14839 
          self.success = iprot.readBool();
14840 
        else:
14841 
          iprot.skip(ftype)
14842 
      elif fid == 1:
14843 
        if ftype == TType.STRUCT:
14844 
          self.cex = CatalogServiceException()
14845 
          self.cex.read(iprot)
14846 
        else:
14847 
          iprot.skip(ftype)
14848 
      else:
14849 
        iprot.skip(ftype)
14850 
      iprot.readFieldEnd()
14851 
    iprot.readStructEnd()
14852 
 
14853 
  def write(self, oprot):
14854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14856 
      return
14857 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14858 
    if self.success is not None:
14859 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14860 
      oprot.writeBool(self.success)
14861 
      oprot.writeFieldEnd()
14862 
    if self.cex is not None:
14863 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14864 
      self.cex.write(oprot)
14865 
      oprot.writeFieldEnd()
14866 
    oprot.writeFieldStop()
14867 
    oprot.writeStructEnd()
14868 
 
14869 
  def validate(self):
14870 
    return
14871 
 
14872 
 
14873 
  def __repr__(self):
14874 
    L = ['%s=%r' % (key, value)
14875 
      for key, value in self.__dict__.iteritems()]
14876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14877 
 
14878 
  def __eq__(self, other):
14879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14880 
 
14881 
  def __ne__(self, other):
14882 
    return not (self == other)
14883 
 
14884 
class deleteVoucherForItem_args:
14885 
  """
14886 
  Attributes:
14887 
   - catalog_item_id
14888 
   - voucherType
14889 
  """
14890 
 
14891 
  thrift_spec = (
14892 
    None, # 0
14893 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14894 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14895 
  )
14896 
 
14897 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14898 
    self.catalog_item_id = catalog_item_id
14899 
    self.voucherType = voucherType
14900 
 
14901 
  def read(self, iprot):
14902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14904 
      return
14905 
    iprot.readStructBegin()
14906 
    while True:
14907 
      (fname, ftype, fid) = iprot.readFieldBegin()
14908 
      if ftype == TType.STOP:
14909 
        break
14910 
      if fid == 1:
14911 
        if ftype == TType.I64:
14912 
          self.catalog_item_id = iprot.readI64();
14913 
        else:
14914 
          iprot.skip(ftype)
14915 
      elif fid == 2:
14916 
        if ftype == TType.I64:
14917 
          self.voucherType = iprot.readI64();
14918 
        else:
14919 
          iprot.skip(ftype)
14920 
      else:
14921 
        iprot.skip(ftype)
14922 
      iprot.readFieldEnd()
14923 
    iprot.readStructEnd()
14924 
 
14925 
  def write(self, oprot):
14926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14928 
      return
14929 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14930 
    if self.catalog_item_id is not None:
14931 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14932 
      oprot.writeI64(self.catalog_item_id)
14933 
      oprot.writeFieldEnd()
14934 
    if self.voucherType is not None:
14935 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14936 
      oprot.writeI64(self.voucherType)
14937 
      oprot.writeFieldEnd()
14938 
    oprot.writeFieldStop()
14939 
    oprot.writeStructEnd()
14940 
 
14941 
  def validate(self):
14942 
    return
14943 
 
14944 
 
14945 
  def __repr__(self):
14946 
    L = ['%s=%r' % (key, value)
14947 
      for key, value in self.__dict__.iteritems()]
14948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14949 
 
14950 
  def __eq__(self, other):
14951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14952 
 
14953 
  def __ne__(self, other):
14954 
    return not (self == other)
14955 
 
14956 
class deleteVoucherForItem_result:
14957 
  """
14958 
  Attributes:
14959 
   - success
14960 
   - cex
14961 
  """
14962 
 
14963 
  thrift_spec = (
14964 
    (0, TType.BOOL, 'success', None, None, ), # 0
14965 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14966 
  )
14967 
 
14968 
  def __init__(self, success=None, cex=None,):
14969 
    self.success = success
14970 
    self.cex = cex
14971 
 
14972 
  def read(self, iprot):
14973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14975 
      return
14976 
    iprot.readStructBegin()
14977 
    while True:
14978 
      (fname, ftype, fid) = iprot.readFieldBegin()
14979 
      if ftype == TType.STOP:
14980 
        break
14981 
      if fid == 0:
14982 
        if ftype == TType.BOOL:
14983 
          self.success = iprot.readBool();
14984 
        else:
14985 
          iprot.skip(ftype)
14986 
      elif fid == 1:
14987 
        if ftype == TType.STRUCT:
14988 
          self.cex = CatalogServiceException()
14989 
          self.cex.read(iprot)
14990 
        else:
14991 
          iprot.skip(ftype)
14992 
      else:
14993 
        iprot.skip(ftype)
14994 
      iprot.readFieldEnd()
14995 
    iprot.readStructEnd()
14996 
 
14997 
  def write(self, oprot):
14998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15000 
      return
15001 
    oprot.writeStructBegin('deleteVoucherForItem_result')
15002 
    if self.success is not None:
15003 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15004 
      oprot.writeBool(self.success)
15005 
      oprot.writeFieldEnd()
15006 
    if self.cex is not None:
15007 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15008 
      self.cex.write(oprot)
15009 
      oprot.writeFieldEnd()
15010 
    oprot.writeFieldStop()
15011 
    oprot.writeStructEnd()
15012 
 
15013 
  def validate(self):
15014 
    return
15015 
 
15016 
 
15017 
  def __repr__(self):
15018 
    L = ['%s=%r' % (key, value)
15019 
      for key, value in self.__dict__.iteritems()]
15020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15021 
 
15022 
  def __eq__(self, other):
15023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15024 
 
15025 
  def __ne__(self, other):
15026 
    return not (self == other)
15027 
 
15028 
class getVoucherAmount_args:
15029 
  """
15030 
  Attributes:
15031 
   - itemId
15032 
   - voucherType
15033 
  """
15034 
 
15035 
  thrift_spec = (
15036 
    None, # 0
15037 
    (1, TType.I64, 'itemId', None, None, ), # 1
15038 
    (2, TType.I64, 'voucherType', None, None, ), # 2
15039 
  )
15040 
 
15041 
  def __init__(self, itemId=None, voucherType=None,):
15042 
    self.itemId = itemId
15043 
    self.voucherType = voucherType
15044 
 
15045 
  def read(self, iprot):
15046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15048 
      return
15049 
    iprot.readStructBegin()
15050 
    while True:
15051 
      (fname, ftype, fid) = iprot.readFieldBegin()
15052 
      if ftype == TType.STOP:
15053 
        break
15054 
      if fid == 1:
15055 
        if ftype == TType.I64:
15056 
          self.itemId = iprot.readI64();
15057 
        else:
15058 
          iprot.skip(ftype)
15059 
      elif fid == 2:
15060 
        if ftype == TType.I64:
15061 
          self.voucherType = iprot.readI64();
15062 
        else:
15063 
          iprot.skip(ftype)
15064 
      else:
15065 
        iprot.skip(ftype)
15066 
      iprot.readFieldEnd()
15067 
    iprot.readStructEnd()
15068 
 
15069 
  def write(self, oprot):
15070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15072 
      return
15073 
    oprot.writeStructBegin('getVoucherAmount_args')
15074 
    if self.itemId is not None:
15075 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15076 
      oprot.writeI64(self.itemId)
15077 
      oprot.writeFieldEnd()
15078 
    if self.voucherType is not None:
15079 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
15080 
      oprot.writeI64(self.voucherType)
15081 
      oprot.writeFieldEnd()
15082 
    oprot.writeFieldStop()
15083 
    oprot.writeStructEnd()
15084 
 
15085 
  def validate(self):
15086 
    return
15087 
 
15088 
 
15089 
  def __repr__(self):
15090 
    L = ['%s=%r' % (key, value)
15091 
      for key, value in self.__dict__.iteritems()]
15092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15093 
 
15094 
  def __eq__(self, other):
15095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15096 
 
15097 
  def __ne__(self, other):
15098 
    return not (self == other)
15099 
 
15100 
class getVoucherAmount_result:
15101 
  """
15102 
  Attributes:
15103 
   - success
15104 
  """
15105 
 
15106 
  thrift_spec = (
15107 
    (0, TType.I64, 'success', None, None, ), # 0
15108 
  )
15109 
 
15110 
  def __init__(self, success=None,):
15111 
    self.success = success
15112 
 
15113 
  def read(self, iprot):
15114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15116 
      return
15117 
    iprot.readStructBegin()
15118 
    while True:
15119 
      (fname, ftype, fid) = iprot.readFieldBegin()
15120 
      if ftype == TType.STOP:
15121 
        break
15122 
      if fid == 0:
15123 
        if ftype == TType.I64:
15124 
          self.success = iprot.readI64();
15125 
        else:
15126 
          iprot.skip(ftype)
15127 
      else:
15128 
        iprot.skip(ftype)
15129 
      iprot.readFieldEnd()
15130 
    iprot.readStructEnd()
15131 
 
15132 
  def write(self, oprot):
15133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15135 
      return
15136 
    oprot.writeStructBegin('getVoucherAmount_result')
15137 
    if self.success is not None:
15138 
      oprot.writeFieldBegin('success', TType.I64, 0)
15139 
      oprot.writeI64(self.success)
15140 
      oprot.writeFieldEnd()
15141 
    oprot.writeFieldStop()
15142 
    oprot.writeStructEnd()
15143 
 
15144 
  def validate(self):
15145 
    return
15146 
 
15147 
 
15148 
  def __repr__(self):
15149 
    L = ['%s=%r' % (key, value)
15150 
      for key, value in self.__dict__.iteritems()]
15151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15152 
 
15153 
  def __eq__(self, other):
15154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15155 
 
15156 
  def __ne__(self, other):
15157 
    return not (self == other)
15158 
 
15159 
class getAllItemVouchers_args:
15160 
  """
15161 
  Attributes:
15162 
   - itemId
15163 
  """
15164 
 
15165 
  thrift_spec = (
15166 
    None, # 0
15167 
    (1, TType.I64, 'itemId', None, None, ), # 1
15168 
  )
15169 
 
15170 
  def __init__(self, itemId=None,):
15171 
    self.itemId = itemId
15172 
 
15173 
  def read(self, iprot):
15174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15176 
      return
15177 
    iprot.readStructBegin()
15178 
    while True:
15179 
      (fname, ftype, fid) = iprot.readFieldBegin()
15180 
      if ftype == TType.STOP:
15181 
        break
15182 
      if fid == 1:
15183 
        if ftype == TType.I64:
15184 
          self.itemId = iprot.readI64();
15185 
        else:
15186 
          iprot.skip(ftype)
15187 
      else:
15188 
        iprot.skip(ftype)
15189 
      iprot.readFieldEnd()
15190 
    iprot.readStructEnd()
15191 
 
15192 
  def write(self, oprot):
15193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15195 
      return
15196 
    oprot.writeStructBegin('getAllItemVouchers_args')
15197 
    if self.itemId is not None:
15198 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15199 
      oprot.writeI64(self.itemId)
15200 
      oprot.writeFieldEnd()
15201 
    oprot.writeFieldStop()
15202 
    oprot.writeStructEnd()
15203 
 
15204 
  def validate(self):
15205 
    return
15206 
 
15207 
 
15208 
  def __repr__(self):
15209 
    L = ['%s=%r' % (key, value)
15210 
      for key, value in self.__dict__.iteritems()]
15211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15212 
 
15213 
  def __eq__(self, other):
15214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15215 
 
15216 
  def __ne__(self, other):
15217 
    return not (self == other)
15218 
 
15219 
class getAllItemVouchers_result:
15220 
  """
15221 
  Attributes:
15222 
   - success
15223 
  """
15224 
 
15225 
  thrift_spec = (
15226 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
15227 
  )
15228 
 
15229 
  def __init__(self, success=None,):
15230 
    self.success = success
15231 
 
15232 
  def read(self, iprot):
15233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15235 
      return
15236 
    iprot.readStructBegin()
15237 
    while True:
15238 
      (fname, ftype, fid) = iprot.readFieldBegin()
15239 
      if ftype == TType.STOP:
15240 
        break
15241 
      if fid == 0:
15242 
        if ftype == TType.LIST:
15243 
          self.success = []
7438 amit.gupta 15244 
          (_etype289, _size286) = iprot.readListBegin()
15245 
          for _i290 in xrange(_size286):
15246 
            _elem291 = VoucherItemMapping()
15247 
            _elem291.read(iprot)
15248 
            self.success.append(_elem291)
5944 mandeep.dh 15249 
          iprot.readListEnd()
15250 
        else:
15251 
          iprot.skip(ftype)
15252 
      else:
15253 
        iprot.skip(ftype)
15254 
      iprot.readFieldEnd()
15255 
    iprot.readStructEnd()
15256 
 
15257 
  def write(self, oprot):
15258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15260 
      return
15261 
    oprot.writeStructBegin('getAllItemVouchers_result')
15262 
    if self.success is not None:
15263 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15264 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15265 
      for iter292 in self.success:
15266 
        iter292.write(oprot)
5944 mandeep.dh 15267 
      oprot.writeListEnd()
15268 
      oprot.writeFieldEnd()
15269 
    oprot.writeFieldStop()
15270 
    oprot.writeStructEnd()
15271 
 
15272 
  def validate(self):
15273 
    return
15274 
 
15275 
 
15276 
  def __repr__(self):
15277 
    L = ['%s=%r' % (key, value)
15278 
      for key, value in self.__dict__.iteritems()]
15279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15280 
 
15281 
  def __eq__(self, other):
15282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15283 
 
15284 
  def __ne__(self, other):
15285 
    return not (self == other)
15286 
 
15287 
class isValidCatalogItemId_args:
15288 
  """
15289 
  Attributes:
15290 
   - catalog_item_id
15291 
  """
15292 
 
15293 
  thrift_spec = (
15294 
    None, # 0
15295 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15296 
  )
15297 
 
15298 
  def __init__(self, catalog_item_id=None,):
15299 
    self.catalog_item_id = catalog_item_id
15300 
 
15301 
  def read(self, iprot):
15302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15304 
      return
15305 
    iprot.readStructBegin()
15306 
    while True:
15307 
      (fname, ftype, fid) = iprot.readFieldBegin()
15308 
      if ftype == TType.STOP:
15309 
        break
15310 
      if fid == 1:
15311 
        if ftype == TType.I64:
15312 
          self.catalog_item_id = 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('isValidCatalogItemId_args')
15325 
    if self.catalog_item_id is not None:
15326 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15327 
      oprot.writeI64(self.catalog_item_id)
15328 
      oprot.writeFieldEnd()
15329 
    oprot.writeFieldStop()
15330 
    oprot.writeStructEnd()
15331 
 
15332 
  def validate(self):
15333 
    return
15334 
 
15335 
 
15336 
  def __repr__(self):
15337 
    L = ['%s=%r' % (key, value)
15338 
      for key, value in self.__dict__.iteritems()]
15339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15340 
 
15341 
  def __eq__(self, other):
15342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15343 
 
15344 
  def __ne__(self, other):
15345 
    return not (self == other)
15346 
 
15347 
class isValidCatalogItemId_result:
15348 
  """
15349 
  Attributes:
15350 
   - success
15351 
  """
15352 
 
15353 
  thrift_spec = (
15354 
    (0, TType.BOOL, 'success', None, None, ), # 0
15355 
  )
15356 
 
15357 
  def __init__(self, success=None,):
15358 
    self.success = success
15359 
 
15360 
  def read(self, iprot):
15361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15363 
      return
15364 
    iprot.readStructBegin()
15365 
    while True:
15366 
      (fname, ftype, fid) = iprot.readFieldBegin()
15367 
      if ftype == TType.STOP:
15368 
        break
15369 
      if fid == 0:
15370 
        if ftype == TType.BOOL:
15371 
          self.success = iprot.readBool();
15372 
        else:
15373 
          iprot.skip(ftype)
15374 
      else:
15375 
        iprot.skip(ftype)
15376 
      iprot.readFieldEnd()
15377 
    iprot.readStructEnd()
15378 
 
15379 
  def write(self, oprot):
15380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15382 
      return
15383 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15384 
    if self.success is not None:
15385 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15386 
      oprot.writeBool(self.success)
15387 
      oprot.writeFieldEnd()
15388 
    oprot.writeFieldStop()
15389 
    oprot.writeStructEnd()
15390 
 
15391 
  def validate(self):
15392 
    return
15393 
 
15394 
 
15395 
  def __repr__(self):
15396 
    L = ['%s=%r' % (key, value)
15397 
      for key, value in self.__dict__.iteritems()]
15398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15399 
 
15400 
  def __eq__(self, other):
15401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15402 
 
15403 
  def __ne__(self, other):
15404 
    return not (self == other)
6039 amit.gupta 15405 
 
15406 
class getVatPercentageForItem_args:
15407 
  """
15408 
  Attributes:
15409 
   - itemId
7330 amit.gupta 15410 
   - stateId
6039 amit.gupta 15411 
   - price
15412 
  """
15413 
 
15414 
  thrift_spec = (
15415 
    None, # 0
15416 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15417 
    (2, TType.I64, 'stateId', None, None, ), # 2
15418 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15419 
  )
15420 
 
7330 amit.gupta 15421 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15422 
    self.itemId = itemId
7330 amit.gupta 15423 
    self.stateId = stateId
6039 amit.gupta 15424 
    self.price = price
15425 
 
15426 
  def read(self, iprot):
15427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15429 
      return
15430 
    iprot.readStructBegin()
15431 
    while True:
15432 
      (fname, ftype, fid) = iprot.readFieldBegin()
15433 
      if ftype == TType.STOP:
15434 
        break
15435 
      if fid == 1:
15436 
        if ftype == TType.I64:
15437 
          self.itemId = iprot.readI64();
15438 
        else:
15439 
          iprot.skip(ftype)
15440 
      elif fid == 2:
7330 amit.gupta 15441 
        if ftype == TType.I64:
15442 
          self.stateId = iprot.readI64();
15443 
        else:
15444 
          iprot.skip(ftype)
15445 
      elif fid == 3:
6039 amit.gupta 15446 
        if ftype == TType.DOUBLE:
15447 
          self.price = iprot.readDouble();
15448 
        else:
15449 
          iprot.skip(ftype)
15450 
      else:
15451 
        iprot.skip(ftype)
15452 
      iprot.readFieldEnd()
15453 
    iprot.readStructEnd()
15454 
 
15455 
  def write(self, oprot):
15456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15458 
      return
15459 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15460 
    if self.itemId is not None:
15461 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15462 
      oprot.writeI64(self.itemId)
15463 
      oprot.writeFieldEnd()
7330 amit.gupta 15464 
    if self.stateId is not None:
15465 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15466 
      oprot.writeI64(self.stateId)
15467 
      oprot.writeFieldEnd()
6039 amit.gupta 15468 
    if self.price is not None:
7330 amit.gupta 15469 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15470 
      oprot.writeDouble(self.price)
15471 
      oprot.writeFieldEnd()
15472 
    oprot.writeFieldStop()
15473 
    oprot.writeStructEnd()
15474 
 
15475 
  def validate(self):
15476 
    return
15477 
 
15478 
 
15479 
  def __repr__(self):
15480 
    L = ['%s=%r' % (key, value)
15481 
      for key, value in self.__dict__.iteritems()]
15482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15483 
 
15484 
  def __eq__(self, other):
15485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15486 
 
15487 
  def __ne__(self, other):
15488 
    return not (self == other)
15489 
 
15490 
class getVatPercentageForItem_result:
15491 
  """
15492 
  Attributes:
15493 
   - success
7340 amit.gupta 15494 
   - cex
6039 amit.gupta 15495 
  """
15496 
 
15497 
  thrift_spec = (
15498 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15499 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15500 
  )
15501 
 
7340 amit.gupta 15502 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15503 
    self.success = success
7340 amit.gupta 15504 
    self.cex = cex
6039 amit.gupta 15505 
 
15506 
  def read(self, iprot):
15507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15509 
      return
15510 
    iprot.readStructBegin()
15511 
    while True:
15512 
      (fname, ftype, fid) = iprot.readFieldBegin()
15513 
      if ftype == TType.STOP:
15514 
        break
15515 
      if fid == 0:
15516 
        if ftype == TType.DOUBLE:
15517 
          self.success = iprot.readDouble();
15518 
        else:
15519 
          iprot.skip(ftype)
7340 amit.gupta 15520 
      elif fid == 1:
15521 
        if ftype == TType.STRUCT:
15522 
          self.cex = CatalogServiceException()
15523 
          self.cex.read(iprot)
15524 
        else:
15525 
          iprot.skip(ftype)
6039 amit.gupta 15526 
      else:
15527 
        iprot.skip(ftype)
15528 
      iprot.readFieldEnd()
15529 
    iprot.readStructEnd()
15530 
 
15531 
  def write(self, oprot):
15532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15534 
      return
15535 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15536 
    if self.success is not None:
15537 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15538 
      oprot.writeDouble(self.success)
15539 
      oprot.writeFieldEnd()
7340 amit.gupta 15540 
    if self.cex is not None:
15541 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15542 
      self.cex.write(oprot)
15543 
      oprot.writeFieldEnd()
6039 amit.gupta 15544 
    oprot.writeFieldStop()
15545 
    oprot.writeStructEnd()
15546 
 
15547 
  def validate(self):
15548 
    return
15549 
 
15550 
 
15551 
  def __repr__(self):
15552 
    L = ['%s=%r' % (key, value)
15553 
      for key, value in self.__dict__.iteritems()]
15554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15555 
 
15556 
  def __eq__(self, other):
15557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15558 
 
15559 
  def __ne__(self, other):
15560 
    return not (self == other)
15561 
 
15562 
class getVatAmountForItem_args:
15563 
  """
15564 
  Attributes:
15565 
   - itemId
15566 
   - price
15567 
  """
15568 
 
15569 
  thrift_spec = (
15570 
    None, # 0
15571 
    (1, TType.I64, 'itemId', None, None, ), # 1
15572 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15573 
  )
15574 
 
15575 
  def __init__(self, itemId=None, price=None,):
15576 
    self.itemId = itemId
15577 
    self.price = price
15578 
 
15579 
  def read(self, iprot):
15580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15582 
      return
15583 
    iprot.readStructBegin()
15584 
    while True:
15585 
      (fname, ftype, fid) = iprot.readFieldBegin()
15586 
      if ftype == TType.STOP:
15587 
        break
15588 
      if fid == 1:
15589 
        if ftype == TType.I64:
15590 
          self.itemId = iprot.readI64();
15591 
        else:
15592 
          iprot.skip(ftype)
15593 
      elif fid == 2:
15594 
        if ftype == TType.DOUBLE:
15595 
          self.price = iprot.readDouble();
15596 
        else:
15597 
          iprot.skip(ftype)
15598 
      else:
15599 
        iprot.skip(ftype)
15600 
      iprot.readFieldEnd()
15601 
    iprot.readStructEnd()
15602 
 
15603 
  def write(self, oprot):
15604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15606 
      return
15607 
    oprot.writeStructBegin('getVatAmountForItem_args')
15608 
    if self.itemId is not None:
15609 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15610 
      oprot.writeI64(self.itemId)
15611 
      oprot.writeFieldEnd()
15612 
    if self.price is not None:
15613 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15614 
      oprot.writeDouble(self.price)
15615 
      oprot.writeFieldEnd()
15616 
    oprot.writeFieldStop()
15617 
    oprot.writeStructEnd()
15618 
 
15619 
  def validate(self):
15620 
    return
15621 
 
15622 
 
15623 
  def __repr__(self):
15624 
    L = ['%s=%r' % (key, value)
15625 
      for key, value in self.__dict__.iteritems()]
15626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15627 
 
15628 
  def __eq__(self, other):
15629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15630 
 
15631 
  def __ne__(self, other):
15632 
    return not (self == other)
15633 
 
15634 
class getVatAmountForItem_result:
15635 
  """
15636 
  Attributes:
15637 
   - success
15638 
  """
15639 
 
15640 
  thrift_spec = (
15641 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15642 
  )
15643 
 
15644 
  def __init__(self, success=None,):
15645 
    self.success = success
15646 
 
15647 
  def read(self, iprot):
15648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15650 
      return
15651 
    iprot.readStructBegin()
15652 
    while True:
15653 
      (fname, ftype, fid) = iprot.readFieldBegin()
15654 
      if ftype == TType.STOP:
15655 
        break
15656 
      if fid == 0:
15657 
        if ftype == TType.DOUBLE:
15658 
          self.success = iprot.readDouble();
15659 
        else:
15660 
          iprot.skip(ftype)
15661 
      else:
15662 
        iprot.skip(ftype)
15663 
      iprot.readFieldEnd()
15664 
    iprot.readStructEnd()
15665 
 
15666 
  def write(self, oprot):
15667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15669 
      return
15670 
    oprot.writeStructBegin('getVatAmountForItem_result')
15671 
    if self.success is not None:
15672 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15673 
      oprot.writeDouble(self.success)
15674 
      oprot.writeFieldEnd()
15675 
    oprot.writeFieldStop()
15676 
    oprot.writeStructEnd()
15677 
 
15678 
  def validate(self):
15679 
    return
15680 
 
15681 
 
15682 
  def __repr__(self):
15683 
    L = ['%s=%r' % (key, value)
15684 
      for key, value in self.__dict__.iteritems()]
15685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15686 
 
15687 
  def __eq__(self, other):
15688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15689 
 
15690 
  def __ne__(self, other):
15691 
    return not (self == other)
6531 vikram.rag 15692 
 
15693 
class getAllIgnoredInventoryUpdateItemsList_args:
15694 
  """
15695 
  Attributes:
15696 
   - offset
15697 
   - limit
15698 
  """
15699 
 
15700 
  thrift_spec = (
15701 
    None, # 0
15702 
    (1, TType.I32, 'offset', None, None, ), # 1
15703 
    (2, TType.I32, 'limit', None, None, ), # 2
15704 
  )
15705 
 
15706 
  def __init__(self, offset=None, limit=None,):
15707 
    self.offset = offset
15708 
    self.limit = limit
15709 
 
15710 
  def read(self, iprot):
15711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15713 
      return
15714 
    iprot.readStructBegin()
15715 
    while True:
15716 
      (fname, ftype, fid) = iprot.readFieldBegin()
15717 
      if ftype == TType.STOP:
15718 
        break
15719 
      if fid == 1:
15720 
        if ftype == TType.I32:
15721 
          self.offset = iprot.readI32();
15722 
        else:
15723 
          iprot.skip(ftype)
15724 
      elif fid == 2:
15725 
        if ftype == TType.I32:
15726 
          self.limit = iprot.readI32();
15727 
        else:
15728 
          iprot.skip(ftype)
15729 
      else:
15730 
        iprot.skip(ftype)
15731 
      iprot.readFieldEnd()
15732 
    iprot.readStructEnd()
15733 
 
15734 
  def write(self, oprot):
15735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15737 
      return
15738 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15739 
    if self.offset is not None:
15740 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15741 
      oprot.writeI32(self.offset)
15742 
      oprot.writeFieldEnd()
15743 
    if self.limit is not None:
15744 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15745 
      oprot.writeI32(self.limit)
15746 
      oprot.writeFieldEnd()
15747 
    oprot.writeFieldStop()
15748 
    oprot.writeStructEnd()
15749 
 
15750 
  def validate(self):
15751 
    return
15752 
 
15753 
 
15754 
  def __repr__(self):
15755 
    L = ['%s=%r' % (key, value)
15756 
      for key, value in self.__dict__.iteritems()]
15757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15758 
 
15759 
  def __eq__(self, other):
15760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15761 
 
15762 
  def __ne__(self, other):
15763 
    return not (self == other)
15764 
 
15765 
class getAllIgnoredInventoryUpdateItemsList_result:
15766 
  """
15767 
  Attributes:
15768 
   - success
15769 
  """
15770 
 
15771 
  thrift_spec = (
15772 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15773 
  )
15774 
 
15775 
  def __init__(self, success=None,):
15776 
    self.success = success
15777 
 
15778 
  def read(self, iprot):
15779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15781 
      return
15782 
    iprot.readStructBegin()
15783 
    while True:
15784 
      (fname, ftype, fid) = iprot.readFieldBegin()
15785 
      if ftype == TType.STOP:
15786 
        break
15787 
      if fid == 0:
15788 
        if ftype == TType.LIST:
15789 
          self.success = []
7438 amit.gupta 15790 
          (_etype296, _size293) = iprot.readListBegin()
15791 
          for _i297 in xrange(_size293):
15792 
            _elem298 = Item()
15793 
            _elem298.read(iprot)
15794 
            self.success.append(_elem298)
6531 vikram.rag 15795 
          iprot.readListEnd()
15796 
        else:
15797 
          iprot.skip(ftype)
15798 
      else:
15799 
        iprot.skip(ftype)
15800 
      iprot.readFieldEnd()
15801 
    iprot.readStructEnd()
15802 
 
15803 
  def write(self, oprot):
15804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15806 
      return
15807 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15808 
    if self.success is not None:
15809 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15810 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15811 
      for iter299 in self.success:
15812 
        iter299.write(oprot)
6531 vikram.rag 15813 
      oprot.writeListEnd()
15814 
      oprot.writeFieldEnd()
15815 
    oprot.writeFieldStop()
15816 
    oprot.writeStructEnd()
15817 
 
15818 
  def validate(self):
15819 
    return
15820 
 
15821 
 
15822 
  def __repr__(self):
15823 
    L = ['%s=%r' % (key, value)
15824 
      for key, value in self.__dict__.iteritems()]
15825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15826 
 
15827 
  def __eq__(self, other):
15828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15829 
 
15830 
  def __ne__(self, other):
15831 
    return not (self == other)
6805 anupam.sin 15832 
 
6821 amar.kumar 15833 
class getAllAliveItems_args:
15834 
 
15835 
  thrift_spec = (
15836 
  )
15837 
 
15838 
  def read(self, iprot):
15839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15841 
      return
15842 
    iprot.readStructBegin()
15843 
    while True:
15844 
      (fname, ftype, fid) = iprot.readFieldBegin()
15845 
      if ftype == TType.STOP:
15846 
        break
15847 
      else:
15848 
        iprot.skip(ftype)
15849 
      iprot.readFieldEnd()
15850 
    iprot.readStructEnd()
15851 
 
15852 
  def write(self, oprot):
15853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15855 
      return
15856 
    oprot.writeStructBegin('getAllAliveItems_args')
15857 
    oprot.writeFieldStop()
15858 
    oprot.writeStructEnd()
15859 
 
15860 
  def validate(self):
15861 
    return
15862 
 
15863 
 
15864 
  def __repr__(self):
15865 
    L = ['%s=%r' % (key, value)
15866 
      for key, value in self.__dict__.iteritems()]
15867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15868 
 
15869 
  def __eq__(self, other):
15870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15871 
 
15872 
  def __ne__(self, other):
15873 
    return not (self == other)
15874 
 
15875 
class getAllAliveItems_result:
15876 
  """
15877 
  Attributes:
15878 
   - success
15879 
  """
15880 
 
15881 
  thrift_spec = (
15882 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15883 
  )
15884 
 
15885 
  def __init__(self, success=None,):
15886 
    self.success = success
15887 
 
15888 
  def read(self, iprot):
15889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15891 
      return
15892 
    iprot.readStructBegin()
15893 
    while True:
15894 
      (fname, ftype, fid) = iprot.readFieldBegin()
15895 
      if ftype == TType.STOP:
15896 
        break
15897 
      if fid == 0:
15898 
        if ftype == TType.LIST:
15899 
          self.success = []
7438 amit.gupta 15900 
          (_etype303, _size300) = iprot.readListBegin()
15901 
          for _i304 in xrange(_size300):
15902 
            _elem305 = Item()
15903 
            _elem305.read(iprot)
15904 
            self.success.append(_elem305)
6821 amar.kumar 15905 
          iprot.readListEnd()
15906 
        else:
15907 
          iprot.skip(ftype)
15908 
      else:
15909 
        iprot.skip(ftype)
15910 
      iprot.readFieldEnd()
15911 
    iprot.readStructEnd()
15912 
 
15913 
  def write(self, oprot):
15914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15916 
      return
15917 
    oprot.writeStructBegin('getAllAliveItems_result')
15918 
    if self.success is not None:
15919 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15920 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15921 
      for iter306 in self.success:
15922 
        iter306.write(oprot)
6821 amar.kumar 15923 
      oprot.writeListEnd()
15924 
      oprot.writeFieldEnd()
15925 
    oprot.writeFieldStop()
15926 
    oprot.writeStructEnd()
15927 
 
15928 
  def validate(self):
15929 
    return
15930 
 
15931 
 
15932 
  def __repr__(self):
15933 
    L = ['%s=%r' % (key, value)
15934 
      for key, value in self.__dict__.iteritems()]
15935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15936 
 
15937 
  def __eq__(self, other):
15938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15939 
 
15940 
  def __ne__(self, other):
15941 
    return not (self == other)
15942 
 
6805 anupam.sin 15943 
class getInsuranceAmount_args:
15944 
  """
15945 
  Attributes:
15946 
   - itemId
6921 anupam.sin 15947 
   - price
6805 anupam.sin 15948 
   - insurerId
15949 
   - quantity
15950 
  """
15951 
 
15952 
  thrift_spec = (
15953 
    None, # 0
15954 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15955 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15956 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15957 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15958 
  )
15959 
 
6921 anupam.sin 15960 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15961 
    self.itemId = itemId
6921 anupam.sin 15962 
    self.price = price
6805 anupam.sin 15963 
    self.insurerId = insurerId
15964 
    self.quantity = quantity
15965 
 
15966 
  def read(self, iprot):
15967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15969 
      return
15970 
    iprot.readStructBegin()
15971 
    while True:
15972 
      (fname, ftype, fid) = iprot.readFieldBegin()
15973 
      if ftype == TType.STOP:
15974 
        break
15975 
      if fid == 1:
15976 
        if ftype == TType.I64:
15977 
          self.itemId = iprot.readI64();
15978 
        else:
15979 
          iprot.skip(ftype)
15980 
      elif fid == 2:
6921 anupam.sin 15981 
        if ftype == TType.DOUBLE:
15982 
          self.price = iprot.readDouble();
15983 
        else:
15984 
          iprot.skip(ftype)
15985 
      elif fid == 3:
6805 anupam.sin 15986 
        if ftype == TType.I64:
15987 
          self.insurerId = iprot.readI64();
15988 
        else:
15989 
          iprot.skip(ftype)
6921 anupam.sin 15990 
      elif fid == 4:
6805 anupam.sin 15991 
        if ftype == TType.I64:
15992 
          self.quantity = iprot.readI64();
15993 
        else:
15994 
          iprot.skip(ftype)
15995 
      else:
15996 
        iprot.skip(ftype)
15997 
      iprot.readFieldEnd()
15998 
    iprot.readStructEnd()
15999 
 
16000 
  def write(self, oprot):
16001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16003 
      return
16004 
    oprot.writeStructBegin('getInsuranceAmount_args')
16005 
    if self.itemId is not None:
16006 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16007 
      oprot.writeI64(self.itemId)
16008 
      oprot.writeFieldEnd()
6921 anupam.sin 16009 
    if self.price is not None:
16010 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
16011 
      oprot.writeDouble(self.price)
16012 
      oprot.writeFieldEnd()
6805 anupam.sin 16013 
    if self.insurerId is not None:
6921 anupam.sin 16014 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 16015 
      oprot.writeI64(self.insurerId)
16016 
      oprot.writeFieldEnd()
16017 
    if self.quantity is not None:
6921 anupam.sin 16018 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 16019 
      oprot.writeI64(self.quantity)
16020 
      oprot.writeFieldEnd()
16021 
    oprot.writeFieldStop()
16022 
    oprot.writeStructEnd()
16023 
 
16024 
  def validate(self):
16025 
    return
16026 
 
16027 
 
16028 
  def __repr__(self):
16029 
    L = ['%s=%r' % (key, value)
16030 
      for key, value in self.__dict__.iteritems()]
16031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16032 
 
16033 
  def __eq__(self, other):
16034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16035 
 
16036 
  def __ne__(self, other):
16037 
    return not (self == other)
16038 
 
16039 
class getInsuranceAmount_result:
16040 
  """
16041 
  Attributes:
16042 
   - success
16043 
  """
16044 
 
16045 
  thrift_spec = (
16046 
    (0, TType.I64, 'success', None, None, ), # 0
16047 
  )
16048 
 
16049 
  def __init__(self, success=None,):
16050 
    self.success = success
16051 
 
16052 
  def read(self, iprot):
16053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16055 
      return
16056 
    iprot.readStructBegin()
16057 
    while True:
16058 
      (fname, ftype, fid) = iprot.readFieldBegin()
16059 
      if ftype == TType.STOP:
16060 
        break
16061 
      if fid == 0:
16062 
        if ftype == TType.I64:
16063 
          self.success = iprot.readI64();
16064 
        else:
16065 
          iprot.skip(ftype)
16066 
      else:
16067 
        iprot.skip(ftype)
16068 
      iprot.readFieldEnd()
16069 
    iprot.readStructEnd()
16070 
 
16071 
  def write(self, oprot):
16072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16074 
      return
16075 
    oprot.writeStructBegin('getInsuranceAmount_result')
16076 
    if self.success is not None:
16077 
      oprot.writeFieldBegin('success', TType.I64, 0)
16078 
      oprot.writeI64(self.success)
16079 
      oprot.writeFieldEnd()
16080 
    oprot.writeFieldStop()
16081 
    oprot.writeStructEnd()
16082 
 
16083 
  def validate(self):
16084 
    return
16085 
 
16086 
 
16087 
  def __repr__(self):
16088 
    L = ['%s=%r' % (key, value)
16089 
      for key, value in self.__dict__.iteritems()]
16090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16091 
 
16092 
  def __eq__(self, other):
16093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16094 
 
16095 
  def __ne__(self, other):
16096 
    return not (self == other)
16097 
 
16098 
class getInsurer_args:
16099 
  """
16100 
  Attributes:
16101 
   - insurerId
16102 
  """
16103 
 
16104 
  thrift_spec = (
16105 
    None, # 0
16106 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16107 
  )
16108 
 
16109 
  def __init__(self, insurerId=None,):
16110 
    self.insurerId = insurerId
16111 
 
16112 
  def read(self, iprot):
16113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16115 
      return
16116 
    iprot.readStructBegin()
16117 
    while True:
16118 
      (fname, ftype, fid) = iprot.readFieldBegin()
16119 
      if ftype == TType.STOP:
16120 
        break
16121 
      if fid == 1:
16122 
        if ftype == TType.I64:
16123 
          self.insurerId = iprot.readI64();
16124 
        else:
16125 
          iprot.skip(ftype)
16126 
      else:
16127 
        iprot.skip(ftype)
16128 
      iprot.readFieldEnd()
16129 
    iprot.readStructEnd()
16130 
 
16131 
  def write(self, oprot):
16132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16134 
      return
16135 
    oprot.writeStructBegin('getInsurer_args')
16136 
    if self.insurerId is not None:
16137 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16138 
      oprot.writeI64(self.insurerId)
16139 
      oprot.writeFieldEnd()
16140 
    oprot.writeFieldStop()
16141 
    oprot.writeStructEnd()
16142 
 
16143 
  def validate(self):
16144 
    return
16145 
 
16146 
 
16147 
  def __repr__(self):
16148 
    L = ['%s=%r' % (key, value)
16149 
      for key, value in self.__dict__.iteritems()]
16150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16151 
 
16152 
  def __eq__(self, other):
16153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16154 
 
16155 
  def __ne__(self, other):
16156 
    return not (self == other)
16157 
 
16158 
class getInsurer_result:
16159 
  """
16160 
  Attributes:
16161 
   - success
16162 
  """
16163 
 
16164 
  thrift_spec = (
16165 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
16166 
  )
16167 
 
16168 
  def __init__(self, success=None,):
16169 
    self.success = success
16170 
 
16171 
  def read(self, iprot):
16172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16174 
      return
16175 
    iprot.readStructBegin()
16176 
    while True:
16177 
      (fname, ftype, fid) = iprot.readFieldBegin()
16178 
      if ftype == TType.STOP:
16179 
        break
16180 
      if fid == 0:
16181 
        if ftype == TType.STRUCT:
16182 
          self.success = Insurer()
16183 
          self.success.read(iprot)
16184 
        else:
16185 
          iprot.skip(ftype)
16186 
      else:
16187 
        iprot.skip(ftype)
16188 
      iprot.readFieldEnd()
16189 
    iprot.readStructEnd()
16190 
 
16191 
  def write(self, oprot):
16192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16194 
      return
16195 
    oprot.writeStructBegin('getInsurer_result')
16196 
    if self.success is not None:
16197 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16198 
      self.success.write(oprot)
16199 
      oprot.writeFieldEnd()
16200 
    oprot.writeFieldStop()
16201 
    oprot.writeStructEnd()
16202 
 
16203 
  def validate(self):
16204 
    return
16205 
 
16206 
 
16207 
  def __repr__(self):
16208 
    L = ['%s=%r' % (key, value)
16209 
      for key, value in self.__dict__.iteritems()]
16210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16211 
 
16212 
  def __eq__(self, other):
16213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16214 
 
16215 
  def __ne__(self, other):
16216 
    return not (self == other)
6838 vikram.rag 16217 
 
16218 
class getAllInsurers_args:
16219 
 
16220 
  thrift_spec = (
16221 
  )
16222 
 
16223 
  def read(self, iprot):
16224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16226 
      return
16227 
    iprot.readStructBegin()
16228 
    while True:
16229 
      (fname, ftype, fid) = iprot.readFieldBegin()
16230 
      if ftype == TType.STOP:
16231 
        break
16232 
      else:
16233 
        iprot.skip(ftype)
16234 
      iprot.readFieldEnd()
16235 
    iprot.readStructEnd()
16236 
 
16237 
  def write(self, oprot):
16238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16240 
      return
16241 
    oprot.writeStructBegin('getAllInsurers_args')
16242 
    oprot.writeFieldStop()
16243 
    oprot.writeStructEnd()
16244 
 
16245 
  def validate(self):
16246 
    return
16247 
 
16248 
 
16249 
  def __repr__(self):
16250 
    L = ['%s=%r' % (key, value)
16251 
      for key, value in self.__dict__.iteritems()]
16252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16253 
 
16254 
  def __eq__(self, other):
16255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16256 
 
16257 
  def __ne__(self, other):
16258 
    return not (self == other)
16259 
 
16260 
class getAllInsurers_result:
16261 
  """
16262 
  Attributes:
16263 
   - success
16264 
  """
16265 
 
16266 
  thrift_spec = (
16267 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16268 
  )
16269 
 
16270 
  def __init__(self, success=None,):
16271 
    self.success = success
16272 
 
16273 
  def read(self, iprot):
16274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16276 
      return
16277 
    iprot.readStructBegin()
16278 
    while True:
16279 
      (fname, ftype, fid) = iprot.readFieldBegin()
16280 
      if ftype == TType.STOP:
16281 
        break
16282 
      if fid == 0:
16283 
        if ftype == TType.LIST:
16284 
          self.success = []
7438 amit.gupta 16285 
          (_etype310, _size307) = iprot.readListBegin()
16286 
          for _i311 in xrange(_size307):
16287 
            _elem312 = Insurer()
16288 
            _elem312.read(iprot)
16289 
            self.success.append(_elem312)
6838 vikram.rag 16290 
          iprot.readListEnd()
16291 
        else:
16292 
          iprot.skip(ftype)
16293 
      else:
16294 
        iprot.skip(ftype)
16295 
      iprot.readFieldEnd()
16296 
    iprot.readStructEnd()
16297 
 
16298 
  def write(self, oprot):
16299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16301 
      return
16302 
    oprot.writeStructBegin('getAllInsurers_result')
16303 
    if self.success is not None:
16304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16306 
      for iter313 in self.success:
16307 
        iter313.write(oprot)
6838 vikram.rag 16308 
      oprot.writeListEnd()
16309 
      oprot.writeFieldEnd()
16310 
    oprot.writeFieldStop()
16311 
    oprot.writeStructEnd()
16312 
 
16313 
  def validate(self):
16314 
    return
16315 
 
16316 
 
16317 
  def __repr__(self):
16318 
    L = ['%s=%r' % (key, value)
16319 
      for key, value in self.__dict__.iteritems()]
16320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16321 
 
16322 
  def __eq__(self, other):
16323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16324 
 
16325 
  def __ne__(self, other):
16326 
    return not (self == other)
6962 rajveer 16327 
 
16328 
class updateInsuranceDeclaredAmount_args:
16329 
  """
16330 
  Attributes:
16331 
   - insurerId
16332 
   - amount
16333 
  """
16334 
 
16335 
  thrift_spec = (
16336 
    None, # 0
16337 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16338 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16339 
  )
16340 
 
16341 
  def __init__(self, insurerId=None, amount=None,):
16342 
    self.insurerId = insurerId
16343 
    self.amount = amount
16344 
 
16345 
  def read(self, iprot):
16346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16348 
      return
16349 
    iprot.readStructBegin()
16350 
    while True:
16351 
      (fname, ftype, fid) = iprot.readFieldBegin()
16352 
      if ftype == TType.STOP:
16353 
        break
16354 
      if fid == 1:
16355 
        if ftype == TType.I64:
16356 
          self.insurerId = iprot.readI64();
16357 
        else:
16358 
          iprot.skip(ftype)
16359 
      elif fid == 2:
16360 
        if ftype == TType.DOUBLE:
16361 
          self.amount = iprot.readDouble();
16362 
        else:
16363 
          iprot.skip(ftype)
16364 
      else:
16365 
        iprot.skip(ftype)
16366 
      iprot.readFieldEnd()
16367 
    iprot.readStructEnd()
16368 
 
16369 
  def write(self, oprot):
16370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16372 
      return
16373 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16374 
    if self.insurerId is not None:
16375 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16376 
      oprot.writeI64(self.insurerId)
16377 
      oprot.writeFieldEnd()
16378 
    if self.amount is not None:
16379 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16380 
      oprot.writeDouble(self.amount)
16381 
      oprot.writeFieldEnd()
16382 
    oprot.writeFieldStop()
16383 
    oprot.writeStructEnd()
16384 
 
16385 
  def validate(self):
16386 
    return
16387 
 
16388 
 
16389 
  def __repr__(self):
16390 
    L = ['%s=%r' % (key, value)
16391 
      for key, value in self.__dict__.iteritems()]
16392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16393 
 
16394 
  def __eq__(self, other):
16395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16396 
 
16397 
  def __ne__(self, other):
16398 
    return not (self == other)
16399 
 
16400 
class updateInsuranceDeclaredAmount_result:
16401 
 
16402 
  thrift_spec = (
16403 
  )
16404 
 
16405 
  def read(self, iprot):
16406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16408 
      return
16409 
    iprot.readStructBegin()
16410 
    while True:
16411 
      (fname, ftype, fid) = iprot.readFieldBegin()
16412 
      if ftype == TType.STOP:
16413 
        break
16414 
      else:
16415 
        iprot.skip(ftype)
16416 
      iprot.readFieldEnd()
16417 
    iprot.readStructEnd()
16418 
 
16419 
  def write(self, oprot):
16420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16422 
      return
16423 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16424 
    oprot.writeFieldStop()
16425 
    oprot.writeStructEnd()
16426 
 
16427 
  def validate(self):
16428 
    return
16429 
 
16430 
 
16431 
  def __repr__(self):
16432 
    L = ['%s=%r' % (key, value)
16433 
      for key, value in self.__dict__.iteritems()]
16434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16435 
 
16436 
  def __eq__(self, other):
16437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16438 
 
16439 
  def __ne__(self, other):
16440 
    return not (self == other)
7190 amar.kumar 16441 
 
16442 
class getFreebieForItem_args:
16443 
  """
16444 
  Attributes:
16445 
   - itemId
16446 
  """
16447 
 
16448 
  thrift_spec = (
16449 
    None, # 0
16450 
    (1, TType.I64, 'itemId', None, None, ), # 1
16451 
  )
16452 
 
16453 
  def __init__(self, itemId=None,):
16454 
    self.itemId = itemId
16455 
 
16456 
  def read(self, iprot):
16457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16459 
      return
16460 
    iprot.readStructBegin()
16461 
    while True:
16462 
      (fname, ftype, fid) = iprot.readFieldBegin()
16463 
      if ftype == TType.STOP:
16464 
        break
16465 
      if fid == 1:
16466 
        if ftype == TType.I64:
16467 
          self.itemId = iprot.readI64();
16468 
        else:
16469 
          iprot.skip(ftype)
16470 
      else:
16471 
        iprot.skip(ftype)
16472 
      iprot.readFieldEnd()
16473 
    iprot.readStructEnd()
16474 
 
16475 
  def write(self, oprot):
16476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16478 
      return
16479 
    oprot.writeStructBegin('getFreebieForItem_args')
16480 
    if self.itemId is not None:
16481 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16482 
      oprot.writeI64(self.itemId)
16483 
      oprot.writeFieldEnd()
16484 
    oprot.writeFieldStop()
16485 
    oprot.writeStructEnd()
16486 
 
16487 
  def validate(self):
16488 
    return
16489 
 
16490 
 
16491 
  def __repr__(self):
16492 
    L = ['%s=%r' % (key, value)
16493 
      for key, value in self.__dict__.iteritems()]
16494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16495 
 
16496 
  def __eq__(self, other):
16497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16498 
 
16499 
  def __ne__(self, other):
16500 
    return not (self == other)
16501 
 
16502 
class getFreebieForItem_result:
16503 
  """
16504 
  Attributes:
16505 
   - success
16506 
  """
16507 
 
16508 
  thrift_spec = (
16509 
    (0, TType.I64, 'success', None, None, ), # 0
16510 
  )
16511 
 
16512 
  def __init__(self, success=None,):
16513 
    self.success = success
16514 
 
16515 
  def read(self, iprot):
16516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16518 
      return
16519 
    iprot.readStructBegin()
16520 
    while True:
16521 
      (fname, ftype, fid) = iprot.readFieldBegin()
16522 
      if ftype == TType.STOP:
16523 
        break
16524 
      if fid == 0:
16525 
        if ftype == TType.I64:
16526 
          self.success = iprot.readI64();
16527 
        else:
16528 
          iprot.skip(ftype)
16529 
      else:
16530 
        iprot.skip(ftype)
16531 
      iprot.readFieldEnd()
16532 
    iprot.readStructEnd()
16533 
 
16534 
  def write(self, oprot):
16535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16537 
      return
16538 
    oprot.writeStructBegin('getFreebieForItem_result')
16539 
    if self.success is not None:
16540 
      oprot.writeFieldBegin('success', TType.I64, 0)
16541 
      oprot.writeI64(self.success)
16542 
      oprot.writeFieldEnd()
16543 
    oprot.writeFieldStop()
16544 
    oprot.writeStructEnd()
16545 
 
16546 
  def validate(self):
16547 
    return
16548 
 
16549 
 
16550 
  def __repr__(self):
16551 
    L = ['%s=%r' % (key, value)
16552 
      for key, value in self.__dict__.iteritems()]
16553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16554 
 
16555 
  def __eq__(self, other):
16556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16557 
 
16558 
  def __ne__(self, other):
16559 
    return not (self == other)
16560 
 
16561 
class addOrUpdateFreebieForItem_args:
16562 
  """
16563 
  Attributes:
16564 
   - freebieItem
16565 
  """
16566 
 
16567 
  thrift_spec = (
16568 
    None, # 0
16569 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16570 
  )
16571 
 
16572 
  def __init__(self, freebieItem=None,):
16573 
    self.freebieItem = freebieItem
16574 
 
16575 
  def read(self, iprot):
16576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16578 
      return
16579 
    iprot.readStructBegin()
16580 
    while True:
16581 
      (fname, ftype, fid) = iprot.readFieldBegin()
16582 
      if ftype == TType.STOP:
16583 
        break
16584 
      if fid == 1:
16585 
        if ftype == TType.STRUCT:
16586 
          self.freebieItem = FreebieItem()
16587 
          self.freebieItem.read(iprot)
16588 
        else:
16589 
          iprot.skip(ftype)
16590 
      else:
16591 
        iprot.skip(ftype)
16592 
      iprot.readFieldEnd()
16593 
    iprot.readStructEnd()
16594 
 
16595 
  def write(self, oprot):
16596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16598 
      return
16599 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16600 
    if self.freebieItem is not None:
16601 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16602 
      self.freebieItem.write(oprot)
16603 
      oprot.writeFieldEnd()
16604 
    oprot.writeFieldStop()
16605 
    oprot.writeStructEnd()
16606 
 
16607 
  def validate(self):
16608 
    return
16609 
 
16610 
 
16611 
  def __repr__(self):
16612 
    L = ['%s=%r' % (key, value)
16613 
      for key, value in self.__dict__.iteritems()]
16614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16615 
 
16616 
  def __eq__(self, other):
16617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16618 
 
16619 
  def __ne__(self, other):
16620 
    return not (self == other)
16621 
 
16622 
class addOrUpdateFreebieForItem_result:
16623 
 
16624 
  thrift_spec = (
16625 
  )
16626 
 
16627 
  def read(self, iprot):
16628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16630 
      return
16631 
    iprot.readStructBegin()
16632 
    while True:
16633 
      (fname, ftype, fid) = iprot.readFieldBegin()
16634 
      if ftype == TType.STOP:
16635 
        break
16636 
      else:
16637 
        iprot.skip(ftype)
16638 
      iprot.readFieldEnd()
16639 
    iprot.readStructEnd()
16640 
 
16641 
  def write(self, oprot):
16642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16644 
      return
16645 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16646 
    oprot.writeFieldStop()
16647 
    oprot.writeStructEnd()
16648 
 
16649 
  def validate(self):
16650 
    return
16651 
 
16652 
 
16653 
  def __repr__(self):
16654 
    L = ['%s=%r' % (key, value)
16655 
      for key, value in self.__dict__.iteritems()]
16656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16657 
 
16658 
  def __eq__(self, other):
16659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16660 
 
16661 
  def __ne__(self, other):
16662 
    return not (self == other)
7256 rajveer 16663 
 
7272 amit.gupta 16664 
class addOrUpdateBrandInfo_args:
16665 
  """
16666 
  Attributes:
16667 
   - brandInfo
16668 
  """
16669 
 
16670 
  thrift_spec = (
16671 
    None, # 0
16672 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16673 
  )
16674 
 
16675 
  def __init__(self, brandInfo=None,):
16676 
    self.brandInfo = brandInfo
16677 
 
16678 
  def read(self, iprot):
16679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16681 
      return
16682 
    iprot.readStructBegin()
16683 
    while True:
16684 
      (fname, ftype, fid) = iprot.readFieldBegin()
16685 
      if ftype == TType.STOP:
16686 
        break
16687 
      if fid == 1:
16688 
        if ftype == TType.STRUCT:
16689 
          self.brandInfo = BrandInfo()
16690 
          self.brandInfo.read(iprot)
16691 
        else:
16692 
          iprot.skip(ftype)
16693 
      else:
16694 
        iprot.skip(ftype)
16695 
      iprot.readFieldEnd()
16696 
    iprot.readStructEnd()
16697 
 
16698 
  def write(self, oprot):
16699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16701 
      return
16702 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16703 
    if self.brandInfo is not None:
16704 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16705 
      self.brandInfo.write(oprot)
16706 
      oprot.writeFieldEnd()
16707 
    oprot.writeFieldStop()
16708 
    oprot.writeStructEnd()
16709 
 
16710 
  def validate(self):
16711 
    return
16712 
 
16713 
 
16714 
  def __repr__(self):
16715 
    L = ['%s=%r' % (key, value)
16716 
      for key, value in self.__dict__.iteritems()]
16717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16718 
 
16719 
  def __eq__(self, other):
16720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16721 
 
16722 
  def __ne__(self, other):
16723 
    return not (self == other)
16724 
 
16725 
class addOrUpdateBrandInfo_result:
16726 
 
16727 
  thrift_spec = (
16728 
  )
16729 
 
16730 
  def read(self, iprot):
16731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16733 
      return
16734 
    iprot.readStructBegin()
16735 
    while True:
16736 
      (fname, ftype, fid) = iprot.readFieldBegin()
16737 
      if ftype == TType.STOP:
16738 
        break
16739 
      else:
16740 
        iprot.skip(ftype)
16741 
      iprot.readFieldEnd()
16742 
    iprot.readStructEnd()
16743 
 
16744 
  def write(self, oprot):
16745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16747 
      return
16748 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16749 
    oprot.writeFieldStop()
16750 
    oprot.writeStructEnd()
16751 
 
16752 
  def validate(self):
16753 
    return
16754 
 
16755 
 
16756 
  def __repr__(self):
16757 
    L = ['%s=%r' % (key, value)
16758 
      for key, value in self.__dict__.iteritems()]
16759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16760 
 
16761 
  def __eq__(self, other):
16762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16763 
 
16764 
  def __ne__(self, other):
16765 
    return not (self == other)
16766 
 
16767 
class getBrandInfo_args:
16768 
 
16769 
  thrift_spec = (
16770 
  )
16771 
 
16772 
  def read(self, iprot):
16773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16775 
      return
16776 
    iprot.readStructBegin()
16777 
    while True:
16778 
      (fname, ftype, fid) = iprot.readFieldBegin()
16779 
      if ftype == TType.STOP:
16780 
        break
16781 
      else:
16782 
        iprot.skip(ftype)
16783 
      iprot.readFieldEnd()
16784 
    iprot.readStructEnd()
16785 
 
16786 
  def write(self, oprot):
16787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16789 
      return
16790 
    oprot.writeStructBegin('getBrandInfo_args')
16791 
    oprot.writeFieldStop()
16792 
    oprot.writeStructEnd()
16793 
 
16794 
  def validate(self):
16795 
    return
16796 
 
16797 
 
16798 
  def __repr__(self):
16799 
    L = ['%s=%r' % (key, value)
16800 
      for key, value in self.__dict__.iteritems()]
16801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16802 
 
16803 
  def __eq__(self, other):
16804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16805 
 
16806 
  def __ne__(self, other):
16807 
    return not (self == other)
16808 
 
16809 
class getBrandInfo_result:
16810 
  """
16811 
  Attributes:
16812 
   - success
16813 
  """
16814 
 
16815 
  thrift_spec = (
16816 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16817 
  )
16818 
 
16819 
  def __init__(self, success=None,):
16820 
    self.success = success
16821 
 
16822 
  def read(self, iprot):
16823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16825 
      return
16826 
    iprot.readStructBegin()
16827 
    while True:
16828 
      (fname, ftype, fid) = iprot.readFieldBegin()
16829 
      if ftype == TType.STOP:
16830 
        break
16831 
      if fid == 0:
16832 
        if ftype == TType.MAP:
16833 
          self.success = {}
7438 amit.gupta 16834 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
16835 
          for _i318 in xrange(_size314):
16836 
            _key319 = iprot.readString();
16837 
            _val320 = BrandInfo()
16838 
            _val320.read(iprot)
16839 
            self.success[_key319] = _val320
7272 amit.gupta 16840 
          iprot.readMapEnd()
16841 
        else:
16842 
          iprot.skip(ftype)
16843 
      else:
16844 
        iprot.skip(ftype)
16845 
      iprot.readFieldEnd()
16846 
    iprot.readStructEnd()
16847 
 
16848 
  def write(self, oprot):
16849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16851 
      return
16852 
    oprot.writeStructBegin('getBrandInfo_result')
16853 
    if self.success is not None:
16854 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16855 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 16856 
      for kiter321,viter322 in self.success.items():
16857 
        oprot.writeString(kiter321)
16858 
        viter322.write(oprot)
7272 amit.gupta 16859 
      oprot.writeMapEnd()
16860 
      oprot.writeFieldEnd()
16861 
    oprot.writeFieldStop()
16862 
    oprot.writeStructEnd()
16863 
 
16864 
  def validate(self):
16865 
    return
16866 
 
16867 
 
16868 
  def __repr__(self):
16869 
    L = ['%s=%r' % (key, value)
16870 
      for key, value in self.__dict__.iteritems()]
16871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16872 
 
16873 
  def __eq__(self, other):
16874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16875 
 
16876 
  def __ne__(self, other):
16877 
    return not (self == other)
16878 
 
7256 rajveer 16879 
class getStorePricing_args:
16880 
  """
16881 
  Attributes:
16882 
   - itemId
16883 
  """
16884 
 
16885 
  thrift_spec = (
16886 
    None, # 0
16887 
    (1, TType.I64, 'itemId', None, None, ), # 1
16888 
  )
16889 
 
16890 
  def __init__(self, itemId=None,):
16891 
    self.itemId = itemId
16892 
 
16893 
  def read(self, iprot):
16894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16896 
      return
16897 
    iprot.readStructBegin()
16898 
    while True:
16899 
      (fname, ftype, fid) = iprot.readFieldBegin()
16900 
      if ftype == TType.STOP:
16901 
        break
16902 
      if fid == 1:
16903 
        if ftype == TType.I64:
16904 
          self.itemId = iprot.readI64();
16905 
        else:
16906 
          iprot.skip(ftype)
16907 
      else:
16908 
        iprot.skip(ftype)
16909 
      iprot.readFieldEnd()
16910 
    iprot.readStructEnd()
16911 
 
16912 
  def write(self, oprot):
16913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16915 
      return
16916 
    oprot.writeStructBegin('getStorePricing_args')
16917 
    if self.itemId is not None:
16918 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16919 
      oprot.writeI64(self.itemId)
16920 
      oprot.writeFieldEnd()
16921 
    oprot.writeFieldStop()
16922 
    oprot.writeStructEnd()
16923 
 
16924 
  def validate(self):
16925 
    return
16926 
 
16927 
 
16928 
  def __repr__(self):
16929 
    L = ['%s=%r' % (key, value)
16930 
      for key, value in self.__dict__.iteritems()]
16931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16932 
 
16933 
  def __eq__(self, other):
16934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16935 
 
16936 
  def __ne__(self, other):
16937 
    return not (self == other)
16938 
 
16939 
class getStorePricing_result:
16940 
  """
16941 
  Attributes:
16942 
   - success
16943 
  """
16944 
 
16945 
  thrift_spec = (
16946 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16947 
  )
16948 
 
16949 
  def __init__(self, success=None,):
16950 
    self.success = success
16951 
 
16952 
  def read(self, iprot):
16953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16955 
      return
16956 
    iprot.readStructBegin()
16957 
    while True:
16958 
      (fname, ftype, fid) = iprot.readFieldBegin()
16959 
      if ftype == TType.STOP:
16960 
        break
16961 
      if fid == 0:
16962 
        if ftype == TType.STRUCT:
16963 
          self.success = StorePricing()
16964 
          self.success.read(iprot)
16965 
        else:
16966 
          iprot.skip(ftype)
16967 
      else:
16968 
        iprot.skip(ftype)
16969 
      iprot.readFieldEnd()
16970 
    iprot.readStructEnd()
16971 
 
16972 
  def write(self, oprot):
16973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16975 
      return
16976 
    oprot.writeStructBegin('getStorePricing_result')
16977 
    if self.success is not None:
16978 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16979 
      self.success.write(oprot)
16980 
      oprot.writeFieldEnd()
16981 
    oprot.writeFieldStop()
16982 
    oprot.writeStructEnd()
16983 
 
16984 
  def validate(self):
16985 
    return
16986 
 
16987 
 
16988 
  def __repr__(self):
16989 
    L = ['%s=%r' % (key, value)
16990 
      for key, value in self.__dict__.iteritems()]
16991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16992 
 
16993 
  def __eq__(self, other):
16994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16995 
 
16996 
  def __ne__(self, other):
16997 
    return not (self == other)
7265 rajveer 16998 
 
7306 rajveer 16999 
class getStorePricings_args:
17000 
  """
17001 
  Attributes:
17002 
   - itemIds
17003 
  """
17004 
 
17005 
  thrift_spec = (
17006 
    None, # 0
17007 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
17008 
  )
17009 
 
17010 
  def __init__(self, itemIds=None,):
17011 
    self.itemIds = itemIds
17012 
 
17013 
  def read(self, iprot):
17014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17016 
      return
17017 
    iprot.readStructBegin()
17018 
    while True:
17019 
      (fname, ftype, fid) = iprot.readFieldBegin()
17020 
      if ftype == TType.STOP:
17021 
        break
17022 
      if fid == 1:
17023 
        if ftype == TType.LIST:
17024 
          self.itemIds = []
7438 amit.gupta 17025 
          (_etype326, _size323) = iprot.readListBegin()
17026 
          for _i327 in xrange(_size323):
17027 
            _elem328 = iprot.readI64();
17028 
            self.itemIds.append(_elem328)
7306 rajveer 17029 
          iprot.readListEnd()
17030 
        else:
17031 
          iprot.skip(ftype)
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('getStorePricings_args')
17042 
    if self.itemIds is not None:
17043 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
17044 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 17045 
      for iter329 in self.itemIds:
17046 
        oprot.writeI64(iter329)
7306 rajveer 17047 
      oprot.writeListEnd()
17048 
      oprot.writeFieldEnd()
17049 
    oprot.writeFieldStop()
17050 
    oprot.writeStructEnd()
17051 
 
17052 
  def validate(self):
17053 
    return
17054 
 
17055 
 
17056 
  def __repr__(self):
17057 
    L = ['%s=%r' % (key, value)
17058 
      for key, value in self.__dict__.iteritems()]
17059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17060 
 
17061 
  def __eq__(self, other):
17062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17063 
 
17064 
  def __ne__(self, other):
17065 
    return not (self == other)
17066 
 
17067 
class getStorePricings_result:
17068 
  """
17069 
  Attributes:
17070 
   - success
17071 
  """
17072 
 
17073 
  thrift_spec = (
17074 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
17075 
  )
17076 
 
17077 
  def __init__(self, success=None,):
17078 
    self.success = success
17079 
 
17080 
  def read(self, iprot):
17081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17083 
      return
17084 
    iprot.readStructBegin()
17085 
    while True:
17086 
      (fname, ftype, fid) = iprot.readFieldBegin()
17087 
      if ftype == TType.STOP:
17088 
        break
17089 
      if fid == 0:
17090 
        if ftype == TType.LIST:
17091 
          self.success = []
7438 amit.gupta 17092 
          (_etype333, _size330) = iprot.readListBegin()
17093 
          for _i334 in xrange(_size330):
17094 
            _elem335 = StorePricing()
17095 
            _elem335.read(iprot)
17096 
            self.success.append(_elem335)
7306 rajveer 17097 
          iprot.readListEnd()
17098 
        else:
17099 
          iprot.skip(ftype)
17100 
      else:
17101 
        iprot.skip(ftype)
17102 
      iprot.readFieldEnd()
17103 
    iprot.readStructEnd()
17104 
 
17105 
  def write(self, oprot):
17106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17108 
      return
17109 
    oprot.writeStructBegin('getStorePricings_result')
17110 
    if self.success is not None:
17111 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17112 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17113 
      for iter336 in self.success:
17114 
        iter336.write(oprot)
7306 rajveer 17115 
      oprot.writeListEnd()
17116 
      oprot.writeFieldEnd()
17117 
    oprot.writeFieldStop()
17118 
    oprot.writeStructEnd()
17119 
 
17120 
  def validate(self):
17121 
    return
17122 
 
17123 
 
17124 
  def __repr__(self):
17125 
    L = ['%s=%r' % (key, value)
17126 
      for key, value in self.__dict__.iteritems()]
17127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17128 
 
17129 
  def __eq__(self, other):
17130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17131 
 
17132 
  def __ne__(self, other):
17133 
    return not (self == other)
17134 
 
7265 rajveer 17135 
class updateStorePricing_args:
17136 
  """
17137 
  Attributes:
17138 
   - sp
7382 rajveer 17139 
   - allColors
7265 rajveer 17140 
  """
17141 
 
17142 
  thrift_spec = (
17143 
    None, # 0
17144 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 17145 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 17146 
  )
17147 
 
7382 rajveer 17148 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 17149 
    self.sp = sp
7382 rajveer 17150 
    self.allColors = allColors
7265 rajveer 17151 
 
17152 
  def read(self, iprot):
17153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17155 
      return
17156 
    iprot.readStructBegin()
17157 
    while True:
17158 
      (fname, ftype, fid) = iprot.readFieldBegin()
17159 
      if ftype == TType.STOP:
17160 
        break
17161 
      if fid == 1:
17162 
        if ftype == TType.STRUCT:
17163 
          self.sp = StorePricing()
17164 
          self.sp.read(iprot)
17165 
        else:
17166 
          iprot.skip(ftype)
7382 rajveer 17167 
      elif fid == 2:
17168 
        if ftype == TType.BOOL:
17169 
          self.allColors = iprot.readBool();
17170 
        else:
17171 
          iprot.skip(ftype)
7265 rajveer 17172 
      else:
17173 
        iprot.skip(ftype)
17174 
      iprot.readFieldEnd()
17175 
    iprot.readStructEnd()
17176 
 
17177 
  def write(self, oprot):
17178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17180 
      return
17181 
    oprot.writeStructBegin('updateStorePricing_args')
17182 
    if self.sp is not None:
17183 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
17184 
      self.sp.write(oprot)
17185 
      oprot.writeFieldEnd()
7382 rajveer 17186 
    if self.allColors is not None:
17187 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
17188 
      oprot.writeBool(self.allColors)
17189 
      oprot.writeFieldEnd()
7265 rajveer 17190 
    oprot.writeFieldStop()
17191 
    oprot.writeStructEnd()
17192 
 
17193 
  def validate(self):
17194 
    return
17195 
 
17196 
 
17197 
  def __repr__(self):
17198 
    L = ['%s=%r' % (key, value)
17199 
      for key, value in self.__dict__.iteritems()]
17200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17201 
 
17202 
  def __eq__(self, other):
17203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17204 
 
17205 
  def __ne__(self, other):
17206 
    return not (self == other)
17207 
 
17208 
class updateStorePricing_result:
17209 
 
17210 
  thrift_spec = (
17211 
  )
17212 
 
17213 
  def read(self, iprot):
17214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17216 
      return
17217 
    iprot.readStructBegin()
17218 
    while True:
17219 
      (fname, ftype, fid) = iprot.readFieldBegin()
17220 
      if ftype == TType.STOP:
17221 
        break
17222 
      else:
17223 
        iprot.skip(ftype)
17224 
      iprot.readFieldEnd()
17225 
    iprot.readStructEnd()
17226 
 
17227 
  def write(self, oprot):
17228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17230 
      return
17231 
    oprot.writeStructBegin('updateStorePricing_result')
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)
7281 kshitij.so 17249 
 
17250 
class getAllAmazonListedItems_args:
17251 
 
17252 
  thrift_spec = (
17253 
  )
17254 
 
17255 
  def read(self, iprot):
17256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17258 
      return
17259 
    iprot.readStructBegin()
17260 
    while True:
17261 
      (fname, ftype, fid) = iprot.readFieldBegin()
17262 
      if ftype == TType.STOP:
17263 
        break
17264 
      else:
17265 
        iprot.skip(ftype)
17266 
      iprot.readFieldEnd()
17267 
    iprot.readStructEnd()
17268 
 
17269 
  def write(self, oprot):
17270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17272 
      return
17273 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17274 
    oprot.writeFieldStop()
17275 
    oprot.writeStructEnd()
17276 
 
17277 
  def validate(self):
17278 
    return
17279 
 
17280 
 
17281 
  def __repr__(self):
17282 
    L = ['%s=%r' % (key, value)
17283 
      for key, value in self.__dict__.iteritems()]
17284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17285 
 
17286 
  def __eq__(self, other):
17287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17288 
 
17289 
  def __ne__(self, other):
17290 
    return not (self == other)
17291 
 
17292 
class getAllAmazonListedItems_result:
17293 
  """
17294 
  Attributes:
17295 
   - success
17296 
  """
17297 
 
17298 
  thrift_spec = (
17299 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17300 
  )
17301 
 
17302 
  def __init__(self, success=None,):
17303 
    self.success = success
17304 
 
17305 
  def read(self, iprot):
17306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17308 
      return
17309 
    iprot.readStructBegin()
17310 
    while True:
17311 
      (fname, ftype, fid) = iprot.readFieldBegin()
17312 
      if ftype == TType.STOP:
17313 
        break
17314 
      if fid == 0:
17315 
        if ftype == TType.LIST:
17316 
          self.success = []
7438 amit.gupta 17317 
          (_etype340, _size337) = iprot.readListBegin()
17318 
          for _i341 in xrange(_size337):
17319 
            _elem342 = Amazonlisted()
17320 
            _elem342.read(iprot)
17321 
            self.success.append(_elem342)
7281 kshitij.so 17322 
          iprot.readListEnd()
17323 
        else:
17324 
          iprot.skip(ftype)
17325 
      else:
17326 
        iprot.skip(ftype)
17327 
      iprot.readFieldEnd()
17328 
    iprot.readStructEnd()
17329 
 
17330 
  def write(self, oprot):
17331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17333 
      return
17334 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17335 
    if self.success is not None:
17336 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17337 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17338 
      for iter343 in self.success:
17339 
        iter343.write(oprot)
7281 kshitij.so 17340 
      oprot.writeListEnd()
17341 
      oprot.writeFieldEnd()
17342 
    oprot.writeFieldStop()
17343 
    oprot.writeStructEnd()
17344 
 
17345 
  def validate(self):
17346 
    return
17347 
 
17348 
 
17349 
  def __repr__(self):
17350 
    L = ['%s=%r' % (key, value)
17351 
      for key, value in self.__dict__.iteritems()]
17352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17353 
 
17354 
  def __eq__(self, other):
17355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17356 
 
17357 
  def __ne__(self, other):
17358 
    return not (self == other)
17359 
 
17360 
class getAmazonItemDetails_args:
17361 
  """
17362 
  Attributes:
17363 
   - itemId
17364 
  """
17365 
 
17366 
  thrift_spec = (
17367 
    None, # 0
17368 
    (1, TType.I64, 'itemId', None, None, ), # 1
17369 
  )
17370 
 
17371 
  def __init__(self, itemId=None,):
17372 
    self.itemId = itemId
17373 
 
17374 
  def read(self, iprot):
17375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17377 
      return
17378 
    iprot.readStructBegin()
17379 
    while True:
17380 
      (fname, ftype, fid) = iprot.readFieldBegin()
17381 
      if ftype == TType.STOP:
17382 
        break
17383 
      if fid == 1:
17384 
        if ftype == TType.I64:
17385 
          self.itemId = iprot.readI64();
17386 
        else:
17387 
          iprot.skip(ftype)
17388 
      else:
17389 
        iprot.skip(ftype)
17390 
      iprot.readFieldEnd()
17391 
    iprot.readStructEnd()
17392 
 
17393 
  def write(self, oprot):
17394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17396 
      return
17397 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17398 
    if self.itemId is not None:
17399 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17400 
      oprot.writeI64(self.itemId)
17401 
      oprot.writeFieldEnd()
17402 
    oprot.writeFieldStop()
17403 
    oprot.writeStructEnd()
17404 
 
17405 
  def validate(self):
17406 
    return
17407 
 
17408 
 
17409 
  def __repr__(self):
17410 
    L = ['%s=%r' % (key, value)
17411 
      for key, value in self.__dict__.iteritems()]
17412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17413 
 
17414 
  def __eq__(self, other):
17415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17416 
 
17417 
  def __ne__(self, other):
17418 
    return not (self == other)
17419 
 
17420 
class getAmazonItemDetails_result:
17421 
  """
17422 
  Attributes:
17423 
   - success
17424 
  """
17425 
 
17426 
  thrift_spec = (
17427 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17428 
  )
17429 
 
17430 
  def __init__(self, success=None,):
17431 
    self.success = success
17432 
 
17433 
  def read(self, iprot):
17434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17436 
      return
17437 
    iprot.readStructBegin()
17438 
    while True:
17439 
      (fname, ftype, fid) = iprot.readFieldBegin()
17440 
      if ftype == TType.STOP:
17441 
        break
17442 
      if fid == 0:
17443 
        if ftype == TType.STRUCT:
17444 
          self.success = Amazonlisted()
17445 
          self.success.read(iprot)
17446 
        else:
17447 
          iprot.skip(ftype)
17448 
      else:
17449 
        iprot.skip(ftype)
17450 
      iprot.readFieldEnd()
17451 
    iprot.readStructEnd()
17452 
 
17453 
  def write(self, oprot):
17454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17456 
      return
17457 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17458 
    if self.success is not None:
17459 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17460 
      self.success.write(oprot)
17461 
      oprot.writeFieldEnd()
17462 
    oprot.writeFieldStop()
17463 
    oprot.writeStructEnd()
17464 
 
17465 
  def validate(self):
17466 
    return
17467 
 
17468 
 
17469 
  def __repr__(self):
17470 
    L = ['%s=%r' % (key, value)
17471 
      for key, value in self.__dict__.iteritems()]
17472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17473 
 
17474 
  def __eq__(self, other):
17475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17476 
 
17477 
  def __ne__(self, other):
17478 
    return not (self == other)
17479 
 
17480 
class updateAmazonItemDetails_args:
17481 
  """
17482 
  Attributes:
17483 
   - itemId
17484 
   - fbaPrice
17485 
   - sellingPrice
17486 
   - isFba
17487 
   - isNonFba
17488 
   - isInventoryOverride
7367 kshitij.so 17489 
   - handlingTime
17490 
   - isCustomTime
7281 kshitij.so 17491 
  """
17492 
 
17493 
  thrift_spec = (
17494 
    None, # 0
17495 
    (1, TType.I64, 'itemId', None, None, ), # 1
17496 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
17497 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
17498 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
17499 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
17500 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 17501 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
17502 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 17503 
  )
17504 
 
7367 kshitij.so 17505 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 17506 
    self.itemId = itemId
17507 
    self.fbaPrice = fbaPrice
17508 
    self.sellingPrice = sellingPrice
17509 
    self.isFba = isFba
17510 
    self.isNonFba = isNonFba
17511 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 17512 
    self.handlingTime = handlingTime
17513 
    self.isCustomTime = isCustomTime
7281 kshitij.so 17514 
 
17515 
  def read(self, iprot):
17516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17518 
      return
17519 
    iprot.readStructBegin()
17520 
    while True:
17521 
      (fname, ftype, fid) = iprot.readFieldBegin()
17522 
      if ftype == TType.STOP:
17523 
        break
17524 
      if fid == 1:
17525 
        if ftype == TType.I64:
17526 
          self.itemId = iprot.readI64();
17527 
        else:
17528 
          iprot.skip(ftype)
17529 
      elif fid == 2:
17530 
        if ftype == TType.DOUBLE:
17531 
          self.fbaPrice = iprot.readDouble();
17532 
        else:
17533 
          iprot.skip(ftype)
17534 
      elif fid == 3:
17535 
        if ftype == TType.DOUBLE:
17536 
          self.sellingPrice = iprot.readDouble();
17537 
        else:
17538 
          iprot.skip(ftype)
17539 
      elif fid == 4:
17540 
        if ftype == TType.BOOL:
17541 
          self.isFba = iprot.readBool();
17542 
        else:
17543 
          iprot.skip(ftype)
17544 
      elif fid == 5:
17545 
        if ftype == TType.BOOL:
17546 
          self.isNonFba = iprot.readBool();
17547 
        else:
17548 
          iprot.skip(ftype)
17549 
      elif fid == 6:
17550 
        if ftype == TType.BOOL:
17551 
          self.isInventoryOverride = iprot.readBool();
17552 
        else:
17553 
          iprot.skip(ftype)
7367 kshitij.so 17554 
      elif fid == 7:
17555 
        if ftype == TType.I64:
17556 
          self.handlingTime = iprot.readI64();
17557 
        else:
17558 
          iprot.skip(ftype)
17559 
      elif fid == 8:
17560 
        if ftype == TType.BOOL:
17561 
          self.isCustomTime = iprot.readBool();
17562 
        else:
17563 
          iprot.skip(ftype)
7281 kshitij.so 17564 
      else:
17565 
        iprot.skip(ftype)
17566 
      iprot.readFieldEnd()
17567 
    iprot.readStructEnd()
17568 
 
17569 
  def write(self, oprot):
17570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17572 
      return
17573 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17574 
    if self.itemId is not None:
17575 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17576 
      oprot.writeI64(self.itemId)
17577 
      oprot.writeFieldEnd()
17578 
    if self.fbaPrice is not None:
17579 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17580 
      oprot.writeDouble(self.fbaPrice)
17581 
      oprot.writeFieldEnd()
17582 
    if self.sellingPrice is not None:
17583 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17584 
      oprot.writeDouble(self.sellingPrice)
17585 
      oprot.writeFieldEnd()
17586 
    if self.isFba is not None:
17587 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17588 
      oprot.writeBool(self.isFba)
17589 
      oprot.writeFieldEnd()
17590 
    if self.isNonFba is not None:
17591 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17592 
      oprot.writeBool(self.isNonFba)
17593 
      oprot.writeFieldEnd()
17594 
    if self.isInventoryOverride is not None:
17595 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17596 
      oprot.writeBool(self.isInventoryOverride)
17597 
      oprot.writeFieldEnd()
7367 kshitij.so 17598 
    if self.handlingTime is not None:
17599 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17600 
      oprot.writeI64(self.handlingTime)
17601 
      oprot.writeFieldEnd()
17602 
    if self.isCustomTime is not None:
17603 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17604 
      oprot.writeBool(self.isCustomTime)
17605 
      oprot.writeFieldEnd()
7281 kshitij.so 17606 
    oprot.writeFieldStop()
17607 
    oprot.writeStructEnd()
17608 
 
17609 
  def validate(self):
17610 
    return
17611 
 
17612 
 
17613 
  def __repr__(self):
17614 
    L = ['%s=%r' % (key, value)
17615 
      for key, value in self.__dict__.iteritems()]
17616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17617 
 
17618 
  def __eq__(self, other):
17619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17620 
 
17621 
  def __ne__(self, other):
17622 
    return not (self == other)
17623 
 
17624 
class updateAmazonItemDetails_result:
17625 
 
17626 
  thrift_spec = (
17627 
  )
17628 
 
17629 
  def read(self, iprot):
17630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17632 
      return
17633 
    iprot.readStructBegin()
17634 
    while True:
17635 
      (fname, ftype, fid) = iprot.readFieldBegin()
17636 
      if ftype == TType.STOP:
17637 
        break
17638 
      else:
17639 
        iprot.skip(ftype)
17640 
      iprot.readFieldEnd()
17641 
    iprot.readStructEnd()
17642 
 
17643 
  def write(self, oprot):
17644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17646 
      return
17647 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17648 
    oprot.writeFieldStop()
17649 
    oprot.writeStructEnd()
17650 
 
17651 
  def validate(self):
17652 
    return
17653 
 
17654 
 
17655 
  def __repr__(self):
17656 
    L = ['%s=%r' % (key, value)
17657 
      for key, value in self.__dict__.iteritems()]
17658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17659 
 
17660 
  def __eq__(self, other):
17661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17662 
 
17663 
  def __ne__(self, other):
17664 
    return not (self == other)
17665 
 
17666 
class addAmazonItem_args:
17667 
  """
17668 
  Attributes:
17669 
   - amazonlisted
17670 
  """
17671 
 
17672 
  thrift_spec = (
17673 
    None, # 0
17674 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17675 
  )
17676 
 
17677 
  def __init__(self, amazonlisted=None,):
17678 
    self.amazonlisted = amazonlisted
17679 
 
17680 
  def read(self, iprot):
17681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17683 
      return
17684 
    iprot.readStructBegin()
17685 
    while True:
17686 
      (fname, ftype, fid) = iprot.readFieldBegin()
17687 
      if ftype == TType.STOP:
17688 
        break
17689 
      if fid == 1:
17690 
        if ftype == TType.STRUCT:
17691 
          self.amazonlisted = Amazonlisted()
17692 
          self.amazonlisted.read(iprot)
17693 
        else:
17694 
          iprot.skip(ftype)
17695 
      else:
17696 
        iprot.skip(ftype)
17697 
      iprot.readFieldEnd()
17698 
    iprot.readStructEnd()
17699 
 
17700 
  def write(self, oprot):
17701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17703 
      return
17704 
    oprot.writeStructBegin('addAmazonItem_args')
17705 
    if self.amazonlisted is not None:
17706 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17707 
      self.amazonlisted.write(oprot)
17708 
      oprot.writeFieldEnd()
17709 
    oprot.writeFieldStop()
17710 
    oprot.writeStructEnd()
17711 
 
17712 
  def validate(self):
17713 
    return
17714 
 
17715 
 
17716 
  def __repr__(self):
17717 
    L = ['%s=%r' % (key, value)
17718 
      for key, value in self.__dict__.iteritems()]
17719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17720 
 
17721 
  def __eq__(self, other):
17722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17723 
 
17724 
  def __ne__(self, other):
17725 
    return not (self == other)
17726 
 
17727 
class addAmazonItem_result:
17728 
 
17729 
  thrift_spec = (
17730 
  )
17731 
 
17732 
  def read(self, iprot):
17733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17735 
      return
17736 
    iprot.readStructBegin()
17737 
    while True:
17738 
      (fname, ftype, fid) = iprot.readFieldBegin()
17739 
      if ftype == TType.STOP:
17740 
        break
17741 
      else:
17742 
        iprot.skip(ftype)
17743 
      iprot.readFieldEnd()
17744 
    iprot.readStructEnd()
17745 
 
17746 
  def write(self, oprot):
17747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17749 
      return
17750 
    oprot.writeStructBegin('addAmazonItem_result')
17751 
    oprot.writeFieldStop()
17752 
    oprot.writeStructEnd()
17753 
 
17754 
  def validate(self):
17755 
    return
17756 
 
17757 
 
17758 
  def __repr__(self):
17759 
    L = ['%s=%r' % (key, value)
17760 
      for key, value in self.__dict__.iteritems()]
17761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17762 
 
17763 
  def __eq__(self, other):
17764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17765 
 
17766 
  def __ne__(self, other):
17767 
    return not (self == other)
7291 vikram.rag 17768 
 
17769 
class getAsinItems_args:
17770 
 
17771 
  thrift_spec = (
17772 
  )
17773 
 
17774 
  def read(self, iprot):
17775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17777 
      return
17778 
    iprot.readStructBegin()
17779 
    while True:
17780 
      (fname, ftype, fid) = iprot.readFieldBegin()
17781 
      if ftype == TType.STOP:
17782 
        break
17783 
      else:
17784 
        iprot.skip(ftype)
17785 
      iprot.readFieldEnd()
17786 
    iprot.readStructEnd()
17787 
 
17788 
  def write(self, oprot):
17789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17791 
      return
17792 
    oprot.writeStructBegin('getAsinItems_args')
17793 
    oprot.writeFieldStop()
17794 
    oprot.writeStructEnd()
17795 
 
17796 
  def validate(self):
17797 
    return
17798 
 
17799 
 
17800 
  def __repr__(self):
17801 
    L = ['%s=%r' % (key, value)
17802 
      for key, value in self.__dict__.iteritems()]
17803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17804 
 
17805 
  def __eq__(self, other):
17806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17807 
 
17808 
  def __ne__(self, other):
17809 
    return not (self == other)
17810 
 
17811 
class getAsinItems_result:
17812 
  """
17813 
  Attributes:
17814 
   - success
17815 
  """
17816 
 
17817 
  thrift_spec = (
17818 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17819 
  )
17820 
 
17821 
  def __init__(self, success=None,):
17822 
    self.success = success
17823 
 
17824 
  def read(self, iprot):
17825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17827 
      return
17828 
    iprot.readStructBegin()
17829 
    while True:
17830 
      (fname, ftype, fid) = iprot.readFieldBegin()
17831 
      if ftype == TType.STOP:
17832 
        break
17833 
      if fid == 0:
17834 
        if ftype == TType.LIST:
17835 
          self.success = []
7438 amit.gupta 17836 
          (_etype347, _size344) = iprot.readListBegin()
17837 
          for _i348 in xrange(_size344):
17838 
            _elem349 = Item()
17839 
            _elem349.read(iprot)
17840 
            self.success.append(_elem349)
7291 vikram.rag 17841 
          iprot.readListEnd()
17842 
        else:
17843 
          iprot.skip(ftype)
17844 
      else:
17845 
        iprot.skip(ftype)
17846 
      iprot.readFieldEnd()
17847 
    iprot.readStructEnd()
17848 
 
17849 
  def write(self, oprot):
17850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17852 
      return
17853 
    oprot.writeStructBegin('getAsinItems_result')
17854 
    if self.success is not None:
17855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17857 
      for iter350 in self.success:
17858 
        iter350.write(oprot)
7291 vikram.rag 17859 
      oprot.writeListEnd()
17860 
      oprot.writeFieldEnd()
17861 
    oprot.writeFieldStop()
17862 
    oprot.writeStructEnd()
17863 
 
17864 
  def validate(self):
17865 
    return
17866 
 
17867 
 
17868 
  def __repr__(self):
17869 
    L = ['%s=%r' % (key, value)
17870 
      for key, value in self.__dict__.iteritems()]
17871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17872 
 
17873 
  def __eq__(self, other):
17874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17875 
 
17876 
  def __ne__(self, other):
17877 
    return not (self == other)
17878 
 
17879 
class getAllFbaListedItems_args:
17880 
 
17881 
  thrift_spec = (
17882 
  )
17883 
 
17884 
  def read(self, iprot):
17885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17887 
      return
17888 
    iprot.readStructBegin()
17889 
    while True:
17890 
      (fname, ftype, fid) = iprot.readFieldBegin()
17891 
      if ftype == TType.STOP:
17892 
        break
17893 
      else:
17894 
        iprot.skip(ftype)
17895 
      iprot.readFieldEnd()
17896 
    iprot.readStructEnd()
17897 
 
17898 
  def write(self, oprot):
17899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17901 
      return
17902 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17903 
    oprot.writeFieldStop()
17904 
    oprot.writeStructEnd()
17905 
 
17906 
  def validate(self):
17907 
    return
17908 
 
17909 
 
17910 
  def __repr__(self):
17911 
    L = ['%s=%r' % (key, value)
17912 
      for key, value in self.__dict__.iteritems()]
17913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17914 
 
17915 
  def __eq__(self, other):
17916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17917 
 
17918 
  def __ne__(self, other):
17919 
    return not (self == other)
17920 
 
17921 
class getAllFbaListedItems_result:
17922 
  """
17923 
  Attributes:
17924 
   - success
17925 
  """
17926 
 
17927 
  thrift_spec = (
17928 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17929 
  )
17930 
 
17931 
  def __init__(self, success=None,):
17932 
    self.success = success
17933 
 
17934 
  def read(self, iprot):
17935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17937 
      return
17938 
    iprot.readStructBegin()
17939 
    while True:
17940 
      (fname, ftype, fid) = iprot.readFieldBegin()
17941 
      if ftype == TType.STOP:
17942 
        break
17943 
      if fid == 0:
17944 
        if ftype == TType.LIST:
17945 
          self.success = []
7438 amit.gupta 17946 
          (_etype354, _size351) = iprot.readListBegin()
17947 
          for _i355 in xrange(_size351):
17948 
            _elem356 = Amazonlisted()
17949 
            _elem356.read(iprot)
17950 
            self.success.append(_elem356)
7291 vikram.rag 17951 
          iprot.readListEnd()
17952 
        else:
17953 
          iprot.skip(ftype)
17954 
      else:
17955 
        iprot.skip(ftype)
17956 
      iprot.readFieldEnd()
17957 
    iprot.readStructEnd()
17958 
 
17959 
  def write(self, oprot):
17960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17962 
      return
17963 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17964 
    if self.success is not None:
17965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17967 
      for iter357 in self.success:
17968 
        iter357.write(oprot)
7291 vikram.rag 17969 
      oprot.writeListEnd()
17970 
      oprot.writeFieldEnd()
17971 
    oprot.writeFieldStop()
17972 
    oprot.writeStructEnd()
17973 
 
17974 
  def validate(self):
17975 
    return
17976 
 
17977 
 
17978 
  def __repr__(self):
17979 
    L = ['%s=%r' % (key, value)
17980 
      for key, value in self.__dict__.iteritems()]
17981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17982 
 
17983 
  def __eq__(self, other):
17984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17985 
 
17986 
  def __ne__(self, other):
17987 
    return not (self == other)
17988 
 
17989 
class getAllNonFbaListedItems_args:
17990 
 
17991 
  thrift_spec = (
17992 
  )
17993 
 
17994 
  def read(self, iprot):
17995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17997 
      return
17998 
    iprot.readStructBegin()
17999 
    while True:
18000 
      (fname, ftype, fid) = iprot.readFieldBegin()
18001 
      if ftype == TType.STOP:
18002 
        break
18003 
      else:
18004 
        iprot.skip(ftype)
18005 
      iprot.readFieldEnd()
18006 
    iprot.readStructEnd()
18007 
 
18008 
  def write(self, oprot):
18009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18011 
      return
18012 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
18013 
    oprot.writeFieldStop()
18014 
    oprot.writeStructEnd()
18015 
 
18016 
  def validate(self):
18017 
    return
18018 
 
18019 
 
18020 
  def __repr__(self):
18021 
    L = ['%s=%r' % (key, value)
18022 
      for key, value in self.__dict__.iteritems()]
18023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18024 
 
18025 
  def __eq__(self, other):
18026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18027 
 
18028 
  def __ne__(self, other):
18029 
    return not (self == other)
18030 
 
18031 
class getAllNonFbaListedItems_result:
18032 
  """
18033 
  Attributes:
18034 
   - success
18035 
  """
18036 
 
18037 
  thrift_spec = (
18038 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18039 
  )
18040 
 
18041 
  def __init__(self, success=None,):
18042 
    self.success = success
18043 
 
18044 
  def read(self, iprot):
18045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18047 
      return
18048 
    iprot.readStructBegin()
18049 
    while True:
18050 
      (fname, ftype, fid) = iprot.readFieldBegin()
18051 
      if ftype == TType.STOP:
18052 
        break
18053 
      if fid == 0:
18054 
        if ftype == TType.LIST:
18055 
          self.success = []
7438 amit.gupta 18056 
          (_etype361, _size358) = iprot.readListBegin()
18057 
          for _i362 in xrange(_size358):
18058 
            _elem363 = Amazonlisted()
18059 
            _elem363.read(iprot)
18060 
            self.success.append(_elem363)
7291 vikram.rag 18061 
          iprot.readListEnd()
18062 
        else:
18063 
          iprot.skip(ftype)
18064 
      else:
18065 
        iprot.skip(ftype)
18066 
      iprot.readFieldEnd()
18067 
    iprot.readStructEnd()
18068 
 
18069 
  def write(self, oprot):
18070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18072 
      return
18073 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
18074 
    if self.success is not None:
18075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18076 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 18077 
      for iter364 in self.success:
18078 
        iter364.write(oprot)
7291 vikram.rag 18079 
      oprot.writeListEnd()
18080 
      oprot.writeFieldEnd()
18081 
    oprot.writeFieldStop()
18082 
    oprot.writeStructEnd()
18083 
 
18084 
  def validate(self):
18085 
    return
18086 
 
18087 
 
18088 
  def __repr__(self):
18089 
    L = ['%s=%r' % (key, value)
18090 
      for key, value in self.__dict__.iteritems()]
18091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18092 
 
18093 
  def __eq__(self, other):
18094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18095 
 
18096 
  def __ne__(self, other):
18097 
    return not (self == other)
7460 kshitij.so 18098 
 
18099 
class updateItemInventory_args:
18100 
  """
18101 
  Attributes:
18102 
   - itemId
18103 
   - holdInventory
18104 
   - defaultInventory
18105 
  """
18106 
 
18107 
  thrift_spec = (
18108 
    None, # 0
18109 
    (1, TType.I64, 'itemId', None, None, ), # 1
18110 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
18111 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
18112 
  )
18113 
 
18114 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
18115 
    self.itemId = itemId
18116 
    self.holdInventory = holdInventory
18117 
    self.defaultInventory = defaultInventory
18118 
 
18119 
  def read(self, iprot):
18120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18122 
      return
18123 
    iprot.readStructBegin()
18124 
    while True:
18125 
      (fname, ftype, fid) = iprot.readFieldBegin()
18126 
      if ftype == TType.STOP:
18127 
        break
18128 
      if fid == 1:
18129 
        if ftype == TType.I64:
18130 
          self.itemId = iprot.readI64();
18131 
        else:
18132 
          iprot.skip(ftype)
18133 
      elif fid == 2:
18134 
        if ftype == TType.I64:
18135 
          self.holdInventory = iprot.readI64();
18136 
        else:
18137 
          iprot.skip(ftype)
18138 
      elif fid == 3:
18139 
        if ftype == TType.I64:
18140 
          self.defaultInventory = iprot.readI64();
18141 
        else:
18142 
          iprot.skip(ftype)
18143 
      else:
18144 
        iprot.skip(ftype)
18145 
      iprot.readFieldEnd()
18146 
    iprot.readStructEnd()
18147 
 
18148 
  def write(self, oprot):
18149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18151 
      return
18152 
    oprot.writeStructBegin('updateItemInventory_args')
18153 
    if self.itemId is not None:
18154 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18155 
      oprot.writeI64(self.itemId)
18156 
      oprot.writeFieldEnd()
18157 
    if self.holdInventory is not None:
18158 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
18159 
      oprot.writeI64(self.holdInventory)
18160 
      oprot.writeFieldEnd()
18161 
    if self.defaultInventory is not None:
18162 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
18163 
      oprot.writeI64(self.defaultInventory)
18164 
      oprot.writeFieldEnd()
18165 
    oprot.writeFieldStop()
18166 
    oprot.writeStructEnd()
18167 
 
18168 
  def validate(self):
18169 
    return
18170 
 
18171 
 
18172 
  def __repr__(self):
18173 
    L = ['%s=%r' % (key, value)
18174 
      for key, value in self.__dict__.iteritems()]
18175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18176 
 
18177 
  def __eq__(self, other):
18178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18179 
 
18180 
  def __ne__(self, other):
18181 
    return not (self == other)
18182 
 
18183 
class updateItemInventory_result:
18184 
  """
18185 
  Attributes:
18186 
   - success
18187 
  """
18188 
 
18189 
  thrift_spec = (
18190 
    (0, TType.BOOL, 'success', None, None, ), # 0
18191 
  )
18192 
 
18193 
  def __init__(self, success=None,):
18194 
    self.success = success
18195 
 
18196 
  def read(self, iprot):
18197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18199 
      return
18200 
    iprot.readStructBegin()
18201 
    while True:
18202 
      (fname, ftype, fid) = iprot.readFieldBegin()
18203 
      if ftype == TType.STOP:
18204 
        break
18205 
      if fid == 0:
18206 
        if ftype == TType.BOOL:
18207 
          self.success = iprot.readBool();
18208 
        else:
18209 
          iprot.skip(ftype)
18210 
      else:
18211 
        iprot.skip(ftype)
18212 
      iprot.readFieldEnd()
18213 
    iprot.readStructEnd()
18214 
 
18215 
  def write(self, oprot):
18216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18218 
      return
18219 
    oprot.writeStructBegin('updateItemInventory_result')
18220 
    if self.success is not None:
18221 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18222 
      oprot.writeBool(self.success)
18223 
      oprot.writeFieldEnd()
18224 
    oprot.writeFieldStop()
18225 
    oprot.writeStructEnd()
18226 
 
18227 
  def validate(self):
18228 
    return
18229 
 
18230 
 
18231 
  def __repr__(self):
18232 
    L = ['%s=%r' % (key, value)
18233 
      for key, value in self.__dict__.iteritems()]
18234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18235 
 
18236 
  def __eq__(self, other):
18237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18238 
 
18239 
  def __ne__(self, other):
18240 
    return not (self == other)
7770 kshitij.so 18241 
 
18242 
class updateTimestampForAmazonFeeds_args:
18243 
  """
18244 
  Attributes:
18245 
   - type
18246 
   - sku
18247 
   - timestamp
18248 
  """
18249 
 
18250 
  thrift_spec = (
18251 
    None, # 0
18252 
    (1, TType.STRING, 'type', None, None, ), # 1
18253 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
18254 
    (3, TType.I64, 'timestamp', None, None, ), # 3
18255 
  )
18256 
 
18257 
  def __init__(self, type=None, sku=None, timestamp=None,):
18258 
    self.type = type
18259 
    self.sku = sku
18260 
    self.timestamp = timestamp
18261 
 
18262 
  def read(self, iprot):
18263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18265 
      return
18266 
    iprot.readStructBegin()
18267 
    while True:
18268 
      (fname, ftype, fid) = iprot.readFieldBegin()
18269 
      if ftype == TType.STOP:
18270 
        break
18271 
      if fid == 1:
18272 
        if ftype == TType.STRING:
18273 
          self.type = iprot.readString();
18274 
        else:
18275 
          iprot.skip(ftype)
18276 
      elif fid == 2:
18277 
        if ftype == TType.LIST:
18278 
          self.sku = []
18279 
          (_etype368, _size365) = iprot.readListBegin()
18280 
          for _i369 in xrange(_size365):
18281 
            _elem370 = iprot.readI64();
18282 
            self.sku.append(_elem370)
18283 
          iprot.readListEnd()
18284 
        else:
18285 
          iprot.skip(ftype)
18286 
      elif fid == 3:
18287 
        if ftype == TType.I64:
18288 
          self.timestamp = iprot.readI64();
18289 
        else:
18290 
          iprot.skip(ftype)
18291 
      else:
18292 
        iprot.skip(ftype)
18293 
      iprot.readFieldEnd()
18294 
    iprot.readStructEnd()
18295 
 
18296 
  def write(self, oprot):
18297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18299 
      return
18300 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
18301 
    if self.type is not None:
18302 
      oprot.writeFieldBegin('type', TType.STRING, 1)
18303 
      oprot.writeString(self.type)
18304 
      oprot.writeFieldEnd()
18305 
    if self.sku is not None:
18306 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
18307 
      oprot.writeListBegin(TType.I64, len(self.sku))
18308 
      for iter371 in self.sku:
18309 
        oprot.writeI64(iter371)
18310 
      oprot.writeListEnd()
18311 
      oprot.writeFieldEnd()
18312 
    if self.timestamp is not None:
18313 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
18314 
      oprot.writeI64(self.timestamp)
18315 
      oprot.writeFieldEnd()
18316 
    oprot.writeFieldStop()
18317 
    oprot.writeStructEnd()
18318 
 
18319 
  def validate(self):
18320 
    return
18321 
 
18322 
 
18323 
  def __repr__(self):
18324 
    L = ['%s=%r' % (key, value)
18325 
      for key, value in self.__dict__.iteritems()]
18326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18327 
 
18328 
  def __eq__(self, other):
18329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18330 
 
18331 
  def __ne__(self, other):
18332 
    return not (self == other)
18333 
 
18334 
class updateTimestampForAmazonFeeds_result:
18335 
  """
18336 
  Attributes:
18337 
   - success
18338 
  """
18339 
 
18340 
  thrift_spec = (
18341 
    (0, TType.BOOL, 'success', None, None, ), # 0
18342 
  )
18343 
 
18344 
  def __init__(self, success=None,):
18345 
    self.success = success
18346 
 
18347 
  def read(self, iprot):
18348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18350 
      return
18351 
    iprot.readStructBegin()
18352 
    while True:
18353 
      (fname, ftype, fid) = iprot.readFieldBegin()
18354 
      if ftype == TType.STOP:
18355 
        break
18356 
      if fid == 0:
18357 
        if ftype == TType.BOOL:
18358 
          self.success = iprot.readBool();
18359 
        else:
18360 
          iprot.skip(ftype)
18361 
      else:
18362 
        iprot.skip(ftype)
18363 
      iprot.readFieldEnd()
18364 
    iprot.readStructEnd()
18365 
 
18366 
  def write(self, oprot):
18367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18369 
      return
18370 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
18371 
    if self.success is not None:
18372 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18373 
      oprot.writeBool(self.success)
18374 
      oprot.writeFieldEnd()
18375 
    oprot.writeFieldStop()
18376 
    oprot.writeStructEnd()
18377 
 
18378 
  def validate(self):
18379 
    return
18380 
 
18381 
 
18382 
  def __repr__(self):
18383 
    L = ['%s=%r' % (key, value)
18384 
      for key, value in self.__dict__.iteritems()]
18385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18386 
 
18387 
  def __eq__(self, other):
18388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18389 
 
18390 
  def __ne__(self, other):
18391 
    return not (self == other)
7897 amar.kumar 18392 
 
18393 
class getAllParentCategories_args:
18394 
 
18395 
  thrift_spec = (
18396 
  )
18397 
 
18398 
  def read(self, iprot):
18399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18401 
      return
18402 
    iprot.readStructBegin()
18403 
    while True:
18404 
      (fname, ftype, fid) = iprot.readFieldBegin()
18405 
      if ftype == TType.STOP:
18406 
        break
18407 
      else:
18408 
        iprot.skip(ftype)
18409 
      iprot.readFieldEnd()
18410 
    iprot.readStructEnd()
18411 
 
18412 
  def write(self, oprot):
18413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18415 
      return
18416 
    oprot.writeStructBegin('getAllParentCategories_args')
18417 
    oprot.writeFieldStop()
18418 
    oprot.writeStructEnd()
18419 
 
18420 
  def validate(self):
18421 
    return
18422 
 
18423 
 
18424 
  def __repr__(self):
18425 
    L = ['%s=%r' % (key, value)
18426 
      for key, value in self.__dict__.iteritems()]
18427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18428 
 
18429 
  def __eq__(self, other):
18430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18431 
 
18432 
  def __ne__(self, other):
18433 
    return not (self == other)
18434 
 
18435 
class getAllParentCategories_result:
18436 
  """
18437 
  Attributes:
18438 
   - success
18439 
  """
18440 
 
18441 
  thrift_spec = (
18442 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
18443 
  )
18444 
 
18445 
  def __init__(self, success=None,):
18446 
    self.success = success
18447 
 
18448 
  def read(self, iprot):
18449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18451 
      return
18452 
    iprot.readStructBegin()
18453 
    while True:
18454 
      (fname, ftype, fid) = iprot.readFieldBegin()
18455 
      if ftype == TType.STOP:
18456 
        break
18457 
      if fid == 0:
18458 
        if ftype == TType.LIST:
18459 
          self.success = []
18460 
          (_etype375, _size372) = iprot.readListBegin()
18461 
          for _i376 in xrange(_size372):
18462 
            _elem377 = Category()
18463 
            _elem377.read(iprot)
18464 
            self.success.append(_elem377)
18465 
          iprot.readListEnd()
18466 
        else:
18467 
          iprot.skip(ftype)
18468 
      else:
18469 
        iprot.skip(ftype)
18470 
      iprot.readFieldEnd()
18471 
    iprot.readStructEnd()
18472 
 
18473 
  def write(self, oprot):
18474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18476 
      return
18477 
    oprot.writeStructBegin('getAllParentCategories_result')
18478 
    if self.success is not None:
18479 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18480 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18481 
      for iter378 in self.success:
18482 
        iter378.write(oprot)
18483 
      oprot.writeListEnd()
18484 
      oprot.writeFieldEnd()
18485 
    oprot.writeFieldStop()
18486 
    oprot.writeStructEnd()
18487 
 
18488 
  def validate(self):
18489 
    return
18490 
 
18491 
 
18492 
  def __repr__(self):
18493 
    L = ['%s=%r' % (key, value)
18494 
      for key, value in self.__dict__.iteritems()]
18495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18496 
 
18497 
  def __eq__(self, other):
18498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18499 
 
18500 
  def __ne__(self, other):
18501 
    return not (self == other)
7977 kshitij.so 18502 
 
18503 
class addPageViewEvent_args:
18504 
  """
18505 
  Attributes:
18506 
   - pageViewEvents
18507 
  """
18508 
 
18509 
  thrift_spec = (
18510 
    None, # 0
18511 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
18512 
  )
18513 
 
18514 
  def __init__(self, pageViewEvents=None,):
18515 
    self.pageViewEvents = pageViewEvents
18516 
 
18517 
  def read(self, iprot):
18518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18520 
      return
18521 
    iprot.readStructBegin()
18522 
    while True:
18523 
      (fname, ftype, fid) = iprot.readFieldBegin()
18524 
      if ftype == TType.STOP:
18525 
        break
18526 
      if fid == 1:
18527 
        if ftype == TType.STRUCT:
18528 
          self.pageViewEvents = PageViewEvents()
18529 
          self.pageViewEvents.read(iprot)
18530 
        else:
18531 
          iprot.skip(ftype)
18532 
      else:
18533 
        iprot.skip(ftype)
18534 
      iprot.readFieldEnd()
18535 
    iprot.readStructEnd()
18536 
 
18537 
  def write(self, oprot):
18538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18540 
      return
18541 
    oprot.writeStructBegin('addPageViewEvent_args')
18542 
    if self.pageViewEvents is not None:
18543 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
18544 
      self.pageViewEvents.write(oprot)
18545 
      oprot.writeFieldEnd()
18546 
    oprot.writeFieldStop()
18547 
    oprot.writeStructEnd()
18548 
 
18549 
  def validate(self):
18550 
    return
18551 
 
18552 
 
18553 
  def __repr__(self):
18554 
    L = ['%s=%r' % (key, value)
18555 
      for key, value in self.__dict__.iteritems()]
18556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18557 
 
18558 
  def __eq__(self, other):
18559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18560 
 
18561 
  def __ne__(self, other):
18562 
    return not (self == other)
18563 
 
18564 
class addPageViewEvent_result:
18565 
 
18566 
  thrift_spec = (
18567 
  )
18568 
 
18569 
  def read(self, iprot):
18570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18572 
      return
18573 
    iprot.readStructBegin()
18574 
    while True:
18575 
      (fname, ftype, fid) = iprot.readFieldBegin()
18576 
      if ftype == TType.STOP:
18577 
        break
18578 
      else:
18579 
        iprot.skip(ftype)
18580 
      iprot.readFieldEnd()
18581 
    iprot.readStructEnd()
18582 
 
18583 
  def write(self, oprot):
18584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18586 
      return
18587 
    oprot.writeStructBegin('addPageViewEvent_result')
18588 
    oprot.writeFieldStop()
18589 
    oprot.writeStructEnd()
18590 
 
18591 
  def validate(self):
18592 
    return
18593 
 
18594 
 
18595 
  def __repr__(self):
18596 
    L = ['%s=%r' % (key, value)
18597 
      for key, value in self.__dict__.iteritems()]
18598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18599 
 
18600 
  def __eq__(self, other):
18601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18602 
 
18603 
  def __ne__(self, other):
18604 
    return not (self == other)
18605 
 
18606 
class addCartEvent_args:
18607 
  """
18608 
  Attributes:
18609 
   - cartEvents
18610 
  """
18611 
 
18612 
  thrift_spec = (
18613 
    None, # 0
18614 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
18615 
  )
18616 
 
18617 
  def __init__(self, cartEvents=None,):
18618 
    self.cartEvents = cartEvents
18619 
 
18620 
  def read(self, iprot):
18621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18623 
      return
18624 
    iprot.readStructBegin()
18625 
    while True:
18626 
      (fname, ftype, fid) = iprot.readFieldBegin()
18627 
      if ftype == TType.STOP:
18628 
        break
18629 
      if fid == 1:
18630 
        if ftype == TType.STRUCT:
18631 
          self.cartEvents = CartEvents()
18632 
          self.cartEvents.read(iprot)
18633 
        else:
18634 
          iprot.skip(ftype)
18635 
      else:
18636 
        iprot.skip(ftype)
18637 
      iprot.readFieldEnd()
18638 
    iprot.readStructEnd()
18639 
 
18640 
  def write(self, oprot):
18641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18643 
      return
18644 
    oprot.writeStructBegin('addCartEvent_args')
18645 
    if self.cartEvents is not None:
18646 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
18647 
      self.cartEvents.write(oprot)
18648 
      oprot.writeFieldEnd()
18649 
    oprot.writeFieldStop()
18650 
    oprot.writeStructEnd()
18651 
 
18652 
  def validate(self):
18653 
    return
18654 
 
18655 
 
18656 
  def __repr__(self):
18657 
    L = ['%s=%r' % (key, value)
18658 
      for key, value in self.__dict__.iteritems()]
18659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18660 
 
18661 
  def __eq__(self, other):
18662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18663 
 
18664 
  def __ne__(self, other):
18665 
    return not (self == other)
18666 
 
18667 
class addCartEvent_result:
18668 
 
18669 
  thrift_spec = (
18670 
  )
18671 
 
18672 
  def read(self, iprot):
18673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18675 
      return
18676 
    iprot.readStructBegin()
18677 
    while True:
18678 
      (fname, ftype, fid) = iprot.readFieldBegin()
18679 
      if ftype == TType.STOP:
18680 
        break
18681 
      else:
18682 
        iprot.skip(ftype)
18683 
      iprot.readFieldEnd()
18684 
    iprot.readStructEnd()
18685 
 
18686 
  def write(self, oprot):
18687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18689 
      return
18690 
    oprot.writeStructBegin('addCartEvent_result')
18691 
    oprot.writeFieldStop()
18692 
    oprot.writeStructEnd()
18693 
 
18694 
  def validate(self):
18695 
    return
18696 
 
18697 
 
18698 
  def __repr__(self):
18699 
    L = ['%s=%r' % (key, value)
18700 
      for key, value in self.__dict__.iteritems()]
18701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18702 
 
18703 
  def __eq__(self, other):
18704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18705 
 
18706 
  def __ne__(self, other):
18707 
    return not (self == other)
8139 kshitij.so 18708 
 
18709 
class getAmazonListedItems_args:
18710 
  """
18711 
  Attributes:
18712 
   - offset
18713 
   - limit
18714 
  """
18715 
 
18716 
  thrift_spec = (
18717 
    None, # 0
18718 
    (1, TType.I64, 'offset', None, None, ), # 1
18719 
    (2, TType.I64, 'limit', None, None, ), # 2
18720 
  )
18721 
 
18722 
  def __init__(self, offset=None, limit=None,):
18723 
    self.offset = offset
18724 
    self.limit = limit
18725 
 
18726 
  def read(self, iprot):
18727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18729 
      return
18730 
    iprot.readStructBegin()
18731 
    while True:
18732 
      (fname, ftype, fid) = iprot.readFieldBegin()
18733 
      if ftype == TType.STOP:
18734 
        break
18735 
      if fid == 1:
18736 
        if ftype == TType.I64:
18737 
          self.offset = iprot.readI64();
18738 
        else:
18739 
          iprot.skip(ftype)
18740 
      elif fid == 2:
18741 
        if ftype == TType.I64:
18742 
          self.limit = iprot.readI64();
18743 
        else:
18744 
          iprot.skip(ftype)
18745 
      else:
18746 
        iprot.skip(ftype)
18747 
      iprot.readFieldEnd()
18748 
    iprot.readStructEnd()
18749 
 
18750 
  def write(self, oprot):
18751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18753 
      return
18754 
    oprot.writeStructBegin('getAmazonListedItems_args')
18755 
    if self.offset is not None:
18756 
      oprot.writeFieldBegin('offset', TType.I64, 1)
18757 
      oprot.writeI64(self.offset)
18758 
      oprot.writeFieldEnd()
18759 
    if self.limit is not None:
18760 
      oprot.writeFieldBegin('limit', TType.I64, 2)
18761 
      oprot.writeI64(self.limit)
18762 
      oprot.writeFieldEnd()
18763 
    oprot.writeFieldStop()
18764 
    oprot.writeStructEnd()
18765 
 
18766 
  def validate(self):
18767 
    return
18768 
 
18769 
 
18770 
  def __repr__(self):
18771 
    L = ['%s=%r' % (key, value)
18772 
      for key, value in self.__dict__.iteritems()]
18773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18774 
 
18775 
  def __eq__(self, other):
18776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18777 
 
18778 
  def __ne__(self, other):
18779 
    return not (self == other)
18780 
 
18781 
class getAmazonListedItems_result:
18782 
  """
18783 
  Attributes:
18784 
   - success
18785 
  """
18786 
 
18787 
  thrift_spec = (
18788 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
18789 
  )
18790 
 
18791 
  def __init__(self, success=None,):
18792 
    self.success = success
18793 
 
18794 
  def read(self, iprot):
18795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18797 
      return
18798 
    iprot.readStructBegin()
18799 
    while True:
18800 
      (fname, ftype, fid) = iprot.readFieldBegin()
18801 
      if ftype == TType.STOP:
18802 
        break
18803 
      if fid == 0:
18804 
        if ftype == TType.LIST:
18805 
          self.success = []
18806 
          (_etype382, _size379) = iprot.readListBegin()
18807 
          for _i383 in xrange(_size379):
18808 
            _elem384 = Amazonlisted()
18809 
            _elem384.read(iprot)
18810 
            self.success.append(_elem384)
18811 
          iprot.readListEnd()
18812 
        else:
18813 
          iprot.skip(ftype)
18814 
      else:
18815 
        iprot.skip(ftype)
18816 
      iprot.readFieldEnd()
18817 
    iprot.readStructEnd()
18818 
 
18819 
  def write(self, oprot):
18820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18822 
      return
18823 
    oprot.writeStructBegin('getAmazonListedItems_result')
18824 
    if self.success is not None:
18825 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18826 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
18827 
      for iter385 in self.success:
18828 
        iter385.write(oprot)
18829 
      oprot.writeListEnd()
18830 
      oprot.writeFieldEnd()
18831 
    oprot.writeFieldStop()
18832 
    oprot.writeStructEnd()
18833 
 
18834 
  def validate(self):
18835 
    return
18836 
 
18837 
 
18838 
  def __repr__(self):
18839 
    L = ['%s=%r' % (key, value)
18840 
      for key, value in self.__dict__.iteritems()]
18841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18842 
 
18843 
  def __eq__(self, other):
18844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18845 
 
18846 
  def __ne__(self, other):
18847 
    return not (self == other)