Subversion Repositories SmartDukaan

Rev

Rev 7291 | Rev 7330 | 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 
 
46 
  def getItemStatusDescription(self, itemId):
47 
    """
48 
    Parameters:
49 
     - itemId
50 
    """
51 
    pass
52 
 
53 
  def startItemOn(self, item_id, timestamp):
54 
    """
55 
    Parameters:
56 
     - item_id
57 
     - timestamp
58 
    """
59 
    pass
60 
 
61 
  def retireItemOn(self, item_id, timestamp):
62 
    """
63 
    Parameters:
64 
     - item_id
65 
     - timestamp
66 
    """
67 
    pass
68 
 
69 
  def changeItemStatus(self, item_id, timestamp, newstatus):
70 
    """
71 
    Parameters:
72 
     - item_id
73 
     - timestamp
74 
     - newstatus
75 
    """
76 
    pass
77 
 
78 
  def getItem(self, item_id):
79 
    """
80 
    Parameters:
81 
     - item_id
82 
    """
83 
    pass
84 
 
85 
  def getItemsByCatalogId(self, catalog_item_id):
86 
    """
87 
    Parameters:
88 
     - catalog_item_id
89 
    """
90 
    pass
91 
 
92 
  def getValidItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getAllItems(self, isActive):
100 
    """
101 
    Parameters:
102 
     - isActive
103 
    """
104 
    pass
105 
 
106 
  def getAllItemsByStatus(self, itemStatus):
107 
    """
108 
    Parameters:
109 
     - itemStatus
110 
    """
111 
    pass
112 
 
113 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
114 
    """
115 
    Parameters:
116 
     - entityId
117 
     - category
118 
     - brand
119 
     - modelName
120 
     - modelNumber
121 
    """
122 
    pass
123 
 
124 
  def getAllItemsInRange(self, offset, limit):
125 
    """
126 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
127 
 
128 
    Parameters:
129 
     - offset
130 
     - limit
131 
    """
132 
    pass
133 
 
134 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
135 
    """
136 
    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.
137 
 
138 
    Parameters:
139 
     - itemStatus
140 
     - offset
141 
     - limit
142 
    """
143 
    pass
144 
 
145 
  def getItemCountByStatus(self, useStatus, itemStatus):
146 
    """
147 
    Gets a count of all items by status
148 
 
149 
    Parameters:
150 
     - useStatus
151 
     - itemStatus
152 
    """
153 
    pass
154 
 
155 
  def getBestSellers(self, ):
156 
    pass
157 
 
158 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
159 
    """
160 
    Parameters:
161 
     - beginIndex
162 
     - totalItems
163 
     - brand
164 
     - category
165 
    """
166 
    pass
167 
 
168 
  def getBestSellersCount(self, ):
169 
    pass
170 
 
171 
  def getBestDeals(self, ):
172 
    pass
173 
 
174 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
175 
    """
176 
    Parameters:
177 
     - beginIndex
178 
     - totalItems
179 
     - brand
180 
     - category
181 
    """
182 
    pass
183 
 
184 
  def getBestDealsCount(self, ):
185 
    pass
186 
 
187 
  def getComingSoon(self, ):
188 
    pass
189 
 
190 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
191 
    """
192 
    Parameters:
193 
     - beginIndex
194 
     - totalItems
195 
     - brand
196 
     - category
197 
    """
198 
    pass
199 
 
200 
  def getComingSoonCount(self, ):
201 
    pass
202 
 
203 
  def getLatestArrivals(self, ):
204 
    """
205 
    Returns a list of items sorted in the descending order by start date.
206 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
207 
    """
208 
    pass
209 
 
210 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
211 
    """
212 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
213 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
214 
 
215 
    Parameters:
216 
     - beginIndex
217 
     - totalItems
218 
     - brand
219 
     - categories
220 
    """
221 
    pass
222 
 
223 
  def getLatestArrivalsCount(self, ):
224 
    """
225 
    Get the total number of latest arrivals we are willing to show.
226 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
227 
    """
228 
    pass
229 
 
230 
  def generateNewEntityID(self, ):
231 
    pass
232 
 
233 
  def addCategory(self, category):
234 
    """
235 
    All category related functions
236 
 
237 
    Parameters:
238 
     - category
239 
    """
240 
    pass
241 
 
242 
  def getCategory(self, id):
243 
    """
244 
    Parameters:
245 
     - id
246 
    """
247 
    pass
248 
 
249 
  def getAllCategories(self, ):
250 
    pass
251 
 
252 
  def getAllSimilarItems(self, itemId):
253 
    """
254 
    Returns the list of similar items.
255 
 
256 
    Parameters:
257 
     - itemId
258 
    """
259 
    pass
260 
 
261 
  def addSimilarItem(self, itemId, catalogItemId):
262 
    """
263 
    Adds similar item.
264 
 
265 
    Parameters:
266 
     - itemId
267 
     - catalogItemId
268 
    """
269 
    pass
270 
 
6512 kshitij.so 271 
  def addTag(self, displayName, itemId):
272 
    """
273 
    Tag Related
274 
 
275 
    Parameters:
276 
     - displayName
277 
     - itemId
278 
    """
279 
    pass
280 
 
281 
  def deleteEntityTag(self, displayName, itemId):
282 
    """
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteTag(self, displayName):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
    """
294 
    pass
295 
 
296 
  def getAllTags(self, ):
297 
    pass
298 
 
299 
  def getAllEntitiesByTagName(self, displayName):
300 
    """
301 
    Parameters:
302 
     - displayName
303 
    """
304 
    pass
305 
 
6845 amit.gupta 306 
  def getAllEntityTags(self, ):
307 
    pass
308 
 
6850 kshitij.so 309 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
310 
    """
311 
    Parameters:
312 
     - bannerName
313 
     - imageName
314 
     - link
315 
     - priority
316 
     - isActive
317 
     - hasMap
318 
    """
319 
    pass
320 
 
321 
  def getAllBanners(self, ):
322 
    pass
323 
 
324 
  def deleteBanner(self, bannerName):
325 
    """
326 
    Parameters:
327 
     - bannerName
328 
    """
329 
    pass
330 
 
331 
  def getBannerDetails(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getActiveBanners(self, ):
339 
    pass
340 
 
6849 kshitij.so 341 
  def addBannerMap(self, bannerName, mapLink, coordinates):
342 
    """
343 
    Parameters:
344 
     - bannerName
345 
     - mapLink
346 
     - coordinates
347 
    """
348 
    pass
349 
 
350 
  def deleteBannerMap(self, bannerName):
351 
    """
352 
    Parameters:
353 
     - bannerName
354 
    """
355 
    pass
356 
 
357 
  def getBannerMapDetails(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
5944 mandeep.dh 364 
  def deleteSimilarItem(self, itemId, catalogItemId):
365 
    """
366 
    Delete similar item.
367 
 
368 
    Parameters:
369 
     - itemId
370 
     - catalogItemId
371 
    """
372 
    pass
373 
 
374 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
375 
    """
376 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
377 
    If yes, returns the itemId else returns 0
378 
 
379 
    Parameters:
380 
     - brand
381 
     - modelNumber
382 
     - modelName
383 
     - color
384 
    """
385 
    pass
386 
 
387 
  def validateRiskyStatus(self, itemId):
388 
    """
389 
    Check wether item is risky and change status if inventory is not available for risky items
390 
 
391 
    Parameters:
392 
     - itemId
393 
    """
394 
    pass
395 
 
396 
  def changeItemRiskyFlag(self, itemId, risky):
397 
    """
398 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
399 
 
400 
    Parameters:
401 
     - itemId
402 
     - risky
403 
    """
404 
    pass
405 
 
406 
  def getItemsByRiskyFlag(self, ):
407 
    """
408 
    Returns list of items marked as risky.
409 
    """
410 
    pass
411 
 
412 
  def getItemsForMasterSheet(self, category, brand):
413 
    """
414 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
415 
 
416 
    Parameters:
417 
     - category
418 
     - brand
419 
    """
420 
    pass
421 
 
422 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
423 
    """
424 
    Returns list of catalog ids of items with same similarity index as of the given itemId
425 
 
426 
    Parameters:
427 
     - beginIndex
428 
     - totalItems
429 
     - itemId
430 
    """
431 
    pass
432 
 
433 
  def addProductNotification(self, itemId, email):
434 
    """
435 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
436 
 
437 
    Parameters:
438 
     - itemId
439 
     - email
440 
    """
441 
    pass
442 
 
443 
  def sendProductNotifications(self, ):
444 
    """
445 
    Send the product notifications to the users for items which has stock.
446 
    """
447 
    pass
448 
 
449 
  def getAllBrandsByCategory(self, categoryId):
450 
    """
451 
    Returns list of brand names for a given category Id
452 
 
453 
    Parameters:
454 
     - categoryId
455 
    """
456 
    pass
457 
 
458 
  def getAllBrands(self, ):
459 
    """
460 
    Returns list of brand names
461 
    """
462 
    pass
463 
 
464 
  def getAllSources(self, ):
465 
    """
466 
    Return list of all sources
467 
    """
468 
    pass
469 
 
470 
  def getItemPricingBySource(self, itemId, sourceId):
471 
    """
472 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
473 
 
474 
    Parameters:
475 
     - itemId
476 
     - sourceId
477 
    """
478 
    pass
479 
 
480 
  def addSourceItemPricing(self, sourceItemPricing):
481 
    """
482 
    Adds prices to be displayed corresponding to the item if user comes from a source.
483 
    If item is not found or source is not found, it will throw exception.
484 
 
485 
    Parameters:
486 
     - sourceItemPricing
487 
    """
488 
    pass
489 
 
490 
  def getAllSourcePricing(self, itemId):
491 
    """
492 
    Returns the list of source pricing information of an item.
493 
    Raises an exception if item not found corresponding to itemId
494 
 
495 
    Parameters:
496 
     - itemId
497 
    """
498 
    pass
499 
 
500 
  def getItemForSource(self, item_id, sourceId):
501 
    """
502 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
503 
 
504 
    Parameters:
505 
     - item_id
506 
     - sourceId
507 
    """
508 
    pass
509 
 
510 
  def searchItemsInRange(self, searchTerms, offset, limit):
511 
    """
512 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
513 
 
514 
    Parameters:
515 
     - searchTerms
516 
     - offset
517 
     - limit
518 
    """
519 
    pass
520 
 
521 
  def getSearchResultCount(self, searchTerms):
522 
    """
523 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
524 
 
525 
    Parameters:
526 
     - searchTerms
527 
    """
528 
    pass
529 
 
530 
  def getProductNotifications(self, startDateTime):
531 
    """
532 
    Returns a list of product notifications added after a supplied datetime
533 
 
534 
    Parameters:
535 
     - startDateTime
536 
    """
537 
    pass
538 
 
539 
  def getProductNotificationRequestCount(self, startDateTime):
540 
    """
541 
    Returns a list of count of requests for product notification against each item
542 
 
543 
    Parameters:
544 
     - startDateTime
545 
    """
546 
    pass
547 
 
548 
  def addAuthorizationLog(self, itemId, username, reason):
549 
    """
550 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
551 
 
552 
    Parameters:
553 
     - itemId
554 
     - username
555 
     - reason
556 
    """
557 
    pass
558 
 
559 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
560 
    """
561 
    Parameters:
562 
     - catalog_item_id
563 
     - voucherType
564 
     - voucherAmount
565 
    """
566 
    pass
567 
 
568 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
569 
    """
570 
    Parameters:
571 
     - catalog_item_id
572 
     - voucherType
573 
    """
574 
    pass
575 
 
576 
  def getVoucherAmount(self, itemId, voucherType):
577 
    """
578 
    Parameters:
579 
     - itemId
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getAllItemVouchers(self, itemId):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
    """
589 
    pass
590 
 
591 
  def isValidCatalogItemId(self, catalog_item_id):
592 
    """
593 
    Parameters:
594 
     - catalog_item_id
595 
    """
596 
    pass
597 
 
6039 amit.gupta 598 
  def getVatPercentageForItem(self, itemId, price):
599 
    """
600 
    Parameters:
601 
     - itemId
602 
     - price
603 
    """
604 
    pass
5944 mandeep.dh 605 
 
6039 amit.gupta 606 
  def getVatAmountForItem(self, itemId, price):
607 
    """
608 
    Parameters:
609 
     - itemId
610 
     - price
611 
    """
612 
    pass
613 
 
6531 vikram.rag 614 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
615 
    """
616 
    Parameters:
617 
     - offset
618 
     - limit
619 
    """
620 
    pass
6039 amit.gupta 621 
 
6821 amar.kumar 622 
  def getAllAliveItems(self, ):
623 
    pass
624 
 
6921 anupam.sin 625 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 626 
    """
627 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 628 
 
6805 anupam.sin 629 
    Parameters:
630 
     - itemId
6921 anupam.sin 631 
     - price
6805 anupam.sin 632 
     - insurerId
633 
     - quantity
634 
    """
635 
    pass
636 
 
637 
  def getInsurer(self, insurerId):
638 
    """
639 
    Parameters:
640 
     - insurerId
641 
    """
642 
    pass
643 
 
6838 vikram.rag 644 
  def getAllInsurers(self, ):
645 
    pass
6805 anupam.sin 646 
 
6962 rajveer 647 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
648 
    """
649 
    Parameters:
650 
     - insurerId
651 
     - amount
652 
    """
653 
    pass
6838 vikram.rag 654 
 
7190 amar.kumar 655 
  def getFreebieForItem(self, itemId):
656 
    """
657 
    Parameters:
658 
     - itemId
659 
    """
660 
    pass
6962 rajveer 661 
 
7190 amar.kumar 662 
  def addOrUpdateFreebieForItem(self, freebieItem):
663 
    """
664 
    Parameters:
665 
     - freebieItem
666 
    """
667 
    pass
668 
 
7272 amit.gupta 669 
  def addOrUpdateBrandInfo(self, brandInfo):
670 
    """
671 
    Parameters:
672 
     - brandInfo
673 
    """
674 
    pass
675 
 
676 
  def getBrandInfo(self, ):
677 
    pass
678 
 
7256 rajveer 679 
  def getStorePricing(self, itemId):
680 
    """
681 
    Parameters:
682 
     - itemId
683 
    """
684 
    pass
7190 amar.kumar 685 
 
7306 rajveer 686 
  def getStorePricings(self, itemIds):
687 
    """
688 
    Parameters:
689 
     - itemIds
690 
    """
691 
    pass
692 
 
7265 rajveer 693 
  def updateStorePricing(self, sp):
694 
    """
695 
    Parameters:
696 
     - sp
697 
    """
698 
    pass
7256 rajveer 699 
 
7281 kshitij.so 700 
  def getAllAmazonListedItems(self, ):
701 
    pass
7265 rajveer 702 
 
7281 kshitij.so 703 
  def getAmazonItemDetails(self, itemId):
704 
    """
705 
    Parameters:
706 
     - itemId
707 
    """
708 
    pass
709 
 
710 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
711 
    """
712 
    Parameters:
713 
     - itemId
714 
     - fbaPrice
715 
     - sellingPrice
716 
     - isFba
717 
     - isNonFba
718 
     - isInventoryOverride
719 
    """
720 
    pass
721 
 
722 
  def addAmazonItem(self, amazonlisted):
723 
    """
724 
    Parameters:
725 
     - amazonlisted
726 
    """
727 
    pass
728 
 
7291 vikram.rag 729 
  def getAsinItems(self, ):
730 
    pass
7281 kshitij.so 731 
 
7291 vikram.rag 732 
  def getAllFbaListedItems(self, ):
733 
    pass
734 
 
735 
  def getAllNonFbaListedItems(self, ):
736 
    pass
737 
 
738 
 
5944 mandeep.dh 739 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
740 
  def __init__(self, iprot, oprot=None):
741 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
742 
 
743 
  def addItem(self, item):
744 
    """
745 
    Availability and inventory attributes
746 
 
747 
    Parameters:
748 
     - item
749 
    """
750 
    self.send_addItem(item)
751 
    return self.recv_addItem()
752 
 
753 
  def send_addItem(self, item):
754 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
755 
    args = addItem_args()
756 
    args.item = item
757 
    args.write(self._oprot)
758 
    self._oprot.writeMessageEnd()
759 
    self._oprot.trans.flush()
760 
 
761 
  def recv_addItem(self, ):
762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
763 
    if mtype == TMessageType.EXCEPTION:
764 
      x = TApplicationException()
765 
      x.read(self._iprot)
766 
      self._iprot.readMessageEnd()
767 
      raise x
768 
    result = addItem_result()
769 
    result.read(self._iprot)
770 
    self._iprot.readMessageEnd()
771 
    if result.success is not None:
772 
      return result.success
773 
    if result.cex is not None:
774 
      raise result.cex
775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
776 
 
777 
  def updateItem(self, item):
778 
    """
779 
    Parameters:
780 
     - item
781 
    """
782 
    self.send_updateItem(item)
783 
    return self.recv_updateItem()
784 
 
785 
  def send_updateItem(self, item):
786 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
787 
    args = updateItem_args()
788 
    args.item = item
789 
    args.write(self._oprot)
790 
    self._oprot.writeMessageEnd()
791 
    self._oprot.trans.flush()
792 
 
793 
  def recv_updateItem(self, ):
794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
795 
    if mtype == TMessageType.EXCEPTION:
796 
      x = TApplicationException()
797 
      x.read(self._iprot)
798 
      self._iprot.readMessageEnd()
799 
      raise x
800 
    result = updateItem_result()
801 
    result.read(self._iprot)
802 
    self._iprot.readMessageEnd()
803 
    if result.success is not None:
804 
      return result.success
805 
    if result.cex is not None:
806 
      raise result.cex
807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
808 
 
809 
  def isActive(self, itemId):
810 
    """
811 
    Checks if the item given to the corresponding itemId is active. If it's active,
812 
    whether it's risky and if it's risky, its inventory position.
813 
 
814 
    Parameters:
815 
     - itemId
816 
    """
817 
    self.send_isActive(itemId)
818 
    return self.recv_isActive()
819 
 
820 
  def send_isActive(self, itemId):
821 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
822 
    args = isActive_args()
823 
    args.itemId = itemId
824 
    args.write(self._oprot)
825 
    self._oprot.writeMessageEnd()
826 
    self._oprot.trans.flush()
827 
 
828 
  def recv_isActive(self, ):
829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
830 
    if mtype == TMessageType.EXCEPTION:
831 
      x = TApplicationException()
832 
      x.read(self._iprot)
833 
      self._iprot.readMessageEnd()
834 
      raise x
835 
    result = isActive_result()
836 
    result.read(self._iprot)
837 
    self._iprot.readMessageEnd()
838 
    if result.success is not None:
839 
      return result.success
840 
    if result.isex is not None:
841 
      raise result.isex
842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
843 
 
844 
  def getItemStatusDescription(self, itemId):
845 
    """
846 
    Parameters:
847 
     - itemId
848 
    """
849 
    self.send_getItemStatusDescription(itemId)
850 
    return self.recv_getItemStatusDescription()
851 
 
852 
  def send_getItemStatusDescription(self, itemId):
853 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
854 
    args = getItemStatusDescription_args()
855 
    args.itemId = itemId
856 
    args.write(self._oprot)
857 
    self._oprot.writeMessageEnd()
858 
    self._oprot.trans.flush()
859 
 
860 
  def recv_getItemStatusDescription(self, ):
861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
862 
    if mtype == TMessageType.EXCEPTION:
863 
      x = TApplicationException()
864 
      x.read(self._iprot)
865 
      self._iprot.readMessageEnd()
866 
      raise x
867 
    result = getItemStatusDescription_result()
868 
    result.read(self._iprot)
869 
    self._iprot.readMessageEnd()
870 
    if result.success is not None:
871 
      return result.success
872 
    if result.isex is not None:
873 
      raise result.isex
874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
875 
 
876 
  def startItemOn(self, item_id, timestamp):
877 
    """
878 
    Parameters:
879 
     - item_id
880 
     - timestamp
881 
    """
882 
    self.send_startItemOn(item_id, timestamp)
883 
    self.recv_startItemOn()
884 
 
885 
  def send_startItemOn(self, item_id, timestamp):
886 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
887 
    args = startItemOn_args()
888 
    args.item_id = item_id
889 
    args.timestamp = timestamp
890 
    args.write(self._oprot)
891 
    self._oprot.writeMessageEnd()
892 
    self._oprot.trans.flush()
893 
 
894 
  def recv_startItemOn(self, ):
895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
896 
    if mtype == TMessageType.EXCEPTION:
897 
      x = TApplicationException()
898 
      x.read(self._iprot)
899 
      self._iprot.readMessageEnd()
900 
      raise x
901 
    result = startItemOn_result()
902 
    result.read(self._iprot)
903 
    self._iprot.readMessageEnd()
904 
    if result.cex is not None:
905 
      raise result.cex
906 
    return
907 
 
908 
  def retireItemOn(self, item_id, timestamp):
909 
    """
910 
    Parameters:
911 
     - item_id
912 
     - timestamp
913 
    """
914 
    self.send_retireItemOn(item_id, timestamp)
915 
    self.recv_retireItemOn()
916 
 
917 
  def send_retireItemOn(self, item_id, timestamp):
918 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
919 
    args = retireItemOn_args()
920 
    args.item_id = item_id
921 
    args.timestamp = timestamp
922 
    args.write(self._oprot)
923 
    self._oprot.writeMessageEnd()
924 
    self._oprot.trans.flush()
925 
 
926 
  def recv_retireItemOn(self, ):
927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
928 
    if mtype == TMessageType.EXCEPTION:
929 
      x = TApplicationException()
930 
      x.read(self._iprot)
931 
      self._iprot.readMessageEnd()
932 
      raise x
933 
    result = retireItemOn_result()
934 
    result.read(self._iprot)
935 
    self._iprot.readMessageEnd()
936 
    if result.cex is not None:
937 
      raise result.cex
938 
    return
939 
 
940 
  def changeItemStatus(self, item_id, timestamp, newstatus):
941 
    """
942 
    Parameters:
943 
     - item_id
944 
     - timestamp
945 
     - newstatus
946 
    """
947 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
948 
    self.recv_changeItemStatus()
949 
 
950 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
951 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
952 
    args = changeItemStatus_args()
953 
    args.item_id = item_id
954 
    args.timestamp = timestamp
955 
    args.newstatus = newstatus
956 
    args.write(self._oprot)
957 
    self._oprot.writeMessageEnd()
958 
    self._oprot.trans.flush()
959 
 
960 
  def recv_changeItemStatus(self, ):
961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
962 
    if mtype == TMessageType.EXCEPTION:
963 
      x = TApplicationException()
964 
      x.read(self._iprot)
965 
      self._iprot.readMessageEnd()
966 
      raise x
967 
    result = changeItemStatus_result()
968 
    result.read(self._iprot)
969 
    self._iprot.readMessageEnd()
970 
    if result.cex is not None:
971 
      raise result.cex
972 
    return
973 
 
974 
  def getItem(self, item_id):
975 
    """
976 
    Parameters:
977 
     - item_id
978 
    """
979 
    self.send_getItem(item_id)
980 
    return self.recv_getItem()
981 
 
982 
  def send_getItem(self, item_id):
983 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
984 
    args = getItem_args()
985 
    args.item_id = item_id
986 
    args.write(self._oprot)
987 
    self._oprot.writeMessageEnd()
988 
    self._oprot.trans.flush()
989 
 
990 
  def recv_getItem(self, ):
991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
992 
    if mtype == TMessageType.EXCEPTION:
993 
      x = TApplicationException()
994 
      x.read(self._iprot)
995 
      self._iprot.readMessageEnd()
996 
      raise x
997 
    result = getItem_result()
998 
    result.read(self._iprot)
999 
    self._iprot.readMessageEnd()
1000 
    if result.success is not None:
1001 
      return result.success
1002 
    if result.cex is not None:
1003 
      raise result.cex
1004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1005 
 
1006 
  def getItemsByCatalogId(self, catalog_item_id):
1007 
    """
1008 
    Parameters:
1009 
     - catalog_item_id
1010 
    """
1011 
    self.send_getItemsByCatalogId(catalog_item_id)
1012 
    return self.recv_getItemsByCatalogId()
1013 
 
1014 
  def send_getItemsByCatalogId(self, catalog_item_id):
1015 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1016 
    args = getItemsByCatalogId_args()
1017 
    args.catalog_item_id = catalog_item_id
1018 
    args.write(self._oprot)
1019 
    self._oprot.writeMessageEnd()
1020 
    self._oprot.trans.flush()
1021 
 
1022 
  def recv_getItemsByCatalogId(self, ):
1023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1024 
    if mtype == TMessageType.EXCEPTION:
1025 
      x = TApplicationException()
1026 
      x.read(self._iprot)
1027 
      self._iprot.readMessageEnd()
1028 
      raise x
1029 
    result = getItemsByCatalogId_result()
1030 
    result.read(self._iprot)
1031 
    self._iprot.readMessageEnd()
1032 
    if result.success is not None:
1033 
      return result.success
1034 
    if result.cex is not None:
1035 
      raise result.cex
1036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1037 
 
1038 
  def getValidItemsByCatalogId(self, catalog_item_id):
1039 
    """
1040 
    Parameters:
1041 
     - catalog_item_id
1042 
    """
1043 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1044 
    return self.recv_getValidItemsByCatalogId()
1045 
 
1046 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1047 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1048 
    args = getValidItemsByCatalogId_args()
1049 
    args.catalog_item_id = catalog_item_id
1050 
    args.write(self._oprot)
1051 
    self._oprot.writeMessageEnd()
1052 
    self._oprot.trans.flush()
1053 
 
1054 
  def recv_getValidItemsByCatalogId(self, ):
1055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1056 
    if mtype == TMessageType.EXCEPTION:
1057 
      x = TApplicationException()
1058 
      x.read(self._iprot)
1059 
      self._iprot.readMessageEnd()
1060 
      raise x
1061 
    result = getValidItemsByCatalogId_result()
1062 
    result.read(self._iprot)
1063 
    self._iprot.readMessageEnd()
1064 
    if result.success is not None:
1065 
      return result.success
1066 
    if result.cex is not None:
1067 
      raise result.cex
1068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1069 
 
1070 
  def getAllItems(self, isActive):
1071 
    """
1072 
    Parameters:
1073 
     - isActive
1074 
    """
1075 
    self.send_getAllItems(isActive)
1076 
    return self.recv_getAllItems()
1077 
 
1078 
  def send_getAllItems(self, isActive):
1079 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1080 
    args = getAllItems_args()
1081 
    args.isActive = isActive
1082 
    args.write(self._oprot)
1083 
    self._oprot.writeMessageEnd()
1084 
    self._oprot.trans.flush()
1085 
 
1086 
  def recv_getAllItems(self, ):
1087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1088 
    if mtype == TMessageType.EXCEPTION:
1089 
      x = TApplicationException()
1090 
      x.read(self._iprot)
1091 
      self._iprot.readMessageEnd()
1092 
      raise x
1093 
    result = getAllItems_result()
1094 
    result.read(self._iprot)
1095 
    self._iprot.readMessageEnd()
1096 
    if result.success is not None:
1097 
      return result.success
1098 
    if result.cex is not None:
1099 
      raise result.cex
1100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1101 
 
1102 
  def getAllItemsByStatus(self, itemStatus):
1103 
    """
1104 
    Parameters:
1105 
     - itemStatus
1106 
    """
1107 
    self.send_getAllItemsByStatus(itemStatus)
1108 
    return self.recv_getAllItemsByStatus()
1109 
 
1110 
  def send_getAllItemsByStatus(self, itemStatus):
1111 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1112 
    args = getAllItemsByStatus_args()
1113 
    args.itemStatus = itemStatus
1114 
    args.write(self._oprot)
1115 
    self._oprot.writeMessageEnd()
1116 
    self._oprot.trans.flush()
1117 
 
1118 
  def recv_getAllItemsByStatus(self, ):
1119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1120 
    if mtype == TMessageType.EXCEPTION:
1121 
      x = TApplicationException()
1122 
      x.read(self._iprot)
1123 
      self._iprot.readMessageEnd()
1124 
      raise x
1125 
    result = getAllItemsByStatus_result()
1126 
    result.read(self._iprot)
1127 
    self._iprot.readMessageEnd()
1128 
    if result.success is not None:
1129 
      return result.success
1130 
    if result.cex is not None:
1131 
      raise result.cex
1132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1133 
 
1134 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1135 
    """
1136 
    Parameters:
1137 
     - entityId
1138 
     - category
1139 
     - brand
1140 
     - modelName
1141 
     - modelNumber
1142 
    """
1143 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1144 
    return self.recv_markItemAsContentComplete()
1145 
 
1146 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1147 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1148 
    args = markItemAsContentComplete_args()
1149 
    args.entityId = entityId
1150 
    args.category = category
1151 
    args.brand = brand
1152 
    args.modelName = modelName
1153 
    args.modelNumber = modelNumber
1154 
    args.write(self._oprot)
1155 
    self._oprot.writeMessageEnd()
1156 
    self._oprot.trans.flush()
1157 
 
1158 
  def recv_markItemAsContentComplete(self, ):
1159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1160 
    if mtype == TMessageType.EXCEPTION:
1161 
      x = TApplicationException()
1162 
      x.read(self._iprot)
1163 
      self._iprot.readMessageEnd()
1164 
      raise x
1165 
    result = markItemAsContentComplete_result()
1166 
    result.read(self._iprot)
1167 
    self._iprot.readMessageEnd()
1168 
    if result.success is not None:
1169 
      return result.success
1170 
    if result.cex is not None:
1171 
      raise result.cex
1172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1173 
 
1174 
  def getAllItemsInRange(self, offset, limit):
1175 
    """
1176 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1177 
 
1178 
    Parameters:
1179 
     - offset
1180 
     - limit
1181 
    """
1182 
    self.send_getAllItemsInRange(offset, limit)
1183 
    return self.recv_getAllItemsInRange()
1184 
 
1185 
  def send_getAllItemsInRange(self, offset, limit):
1186 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1187 
    args = getAllItemsInRange_args()
1188 
    args.offset = offset
1189 
    args.limit = limit
1190 
    args.write(self._oprot)
1191 
    self._oprot.writeMessageEnd()
1192 
    self._oprot.trans.flush()
1193 
 
1194 
  def recv_getAllItemsInRange(self, ):
1195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1196 
    if mtype == TMessageType.EXCEPTION:
1197 
      x = TApplicationException()
1198 
      x.read(self._iprot)
1199 
      self._iprot.readMessageEnd()
1200 
      raise x
1201 
    result = getAllItemsInRange_result()
1202 
    result.read(self._iprot)
1203 
    self._iprot.readMessageEnd()
1204 
    if result.success is not None:
1205 
      return result.success
1206 
    if result.cex is not None:
1207 
      raise result.cex
1208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1209 
 
1210 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1211 
    """
1212 
    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.
1213 
 
1214 
    Parameters:
1215 
     - itemStatus
1216 
     - offset
1217 
     - limit
1218 
    """
1219 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1220 
    return self.recv_getAllItemsByStatusInRange()
1221 
 
1222 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1223 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1224 
    args = getAllItemsByStatusInRange_args()
1225 
    args.itemStatus = itemStatus
1226 
    args.offset = offset
1227 
    args.limit = limit
1228 
    args.write(self._oprot)
1229 
    self._oprot.writeMessageEnd()
1230 
    self._oprot.trans.flush()
1231 
 
1232 
  def recv_getAllItemsByStatusInRange(self, ):
1233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1234 
    if mtype == TMessageType.EXCEPTION:
1235 
      x = TApplicationException()
1236 
      x.read(self._iprot)
1237 
      self._iprot.readMessageEnd()
1238 
      raise x
1239 
    result = getAllItemsByStatusInRange_result()
1240 
    result.read(self._iprot)
1241 
    self._iprot.readMessageEnd()
1242 
    if result.success is not None:
1243 
      return result.success
1244 
    if result.cex is not None:
1245 
      raise result.cex
1246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1247 
 
1248 
  def getItemCountByStatus(self, useStatus, itemStatus):
1249 
    """
1250 
    Gets a count of all items by status
1251 
 
1252 
    Parameters:
1253 
     - useStatus
1254 
     - itemStatus
1255 
    """
1256 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1257 
    return self.recv_getItemCountByStatus()
1258 
 
1259 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1260 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1261 
    args = getItemCountByStatus_args()
1262 
    args.useStatus = useStatus
1263 
    args.itemStatus = itemStatus
1264 
    args.write(self._oprot)
1265 
    self._oprot.writeMessageEnd()
1266 
    self._oprot.trans.flush()
1267 
 
1268 
  def recv_getItemCountByStatus(self, ):
1269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1270 
    if mtype == TMessageType.EXCEPTION:
1271 
      x = TApplicationException()
1272 
      x.read(self._iprot)
1273 
      self._iprot.readMessageEnd()
1274 
      raise x
1275 
    result = getItemCountByStatus_result()
1276 
    result.read(self._iprot)
1277 
    self._iprot.readMessageEnd()
1278 
    if result.success is not None:
1279 
      return result.success
1280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1281 
 
1282 
  def getBestSellers(self, ):
1283 
    self.send_getBestSellers()
1284 
    return self.recv_getBestSellers()
1285 
 
1286 
  def send_getBestSellers(self, ):
1287 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1288 
    args = getBestSellers_args()
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getBestSellers(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getBestSellers_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
1303 
    if result.success is not None:
1304 
      return result.success
1305 
    if result.isex is not None:
1306 
      raise result.isex
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1308 
 
1309 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1310 
    """
1311 
    Parameters:
1312 
     - beginIndex
1313 
     - totalItems
1314 
     - brand
1315 
     - category
1316 
    """
1317 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1318 
    return self.recv_getBestSellersCatalogIds()
1319 
 
1320 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1321 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1322 
    args = getBestSellersCatalogIds_args()
1323 
    args.beginIndex = beginIndex
1324 
    args.totalItems = totalItems
1325 
    args.brand = brand
1326 
    args.category = category
1327 
    args.write(self._oprot)
1328 
    self._oprot.writeMessageEnd()
1329 
    self._oprot.trans.flush()
1330 
 
1331 
  def recv_getBestSellersCatalogIds(self, ):
1332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1333 
    if mtype == TMessageType.EXCEPTION:
1334 
      x = TApplicationException()
1335 
      x.read(self._iprot)
1336 
      self._iprot.readMessageEnd()
1337 
      raise x
1338 
    result = getBestSellersCatalogIds_result()
1339 
    result.read(self._iprot)
1340 
    self._iprot.readMessageEnd()
1341 
    if result.success is not None:
1342 
      return result.success
1343 
    if result.cex is not None:
1344 
      raise result.cex
1345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1346 
 
1347 
  def getBestSellersCount(self, ):
1348 
    self.send_getBestSellersCount()
1349 
    return self.recv_getBestSellersCount()
1350 
 
1351 
  def send_getBestSellersCount(self, ):
1352 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1353 
    args = getBestSellersCount_args()
1354 
    args.write(self._oprot)
1355 
    self._oprot.writeMessageEnd()
1356 
    self._oprot.trans.flush()
1357 
 
1358 
  def recv_getBestSellersCount(self, ):
1359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1360 
    if mtype == TMessageType.EXCEPTION:
1361 
      x = TApplicationException()
1362 
      x.read(self._iprot)
1363 
      self._iprot.readMessageEnd()
1364 
      raise x
1365 
    result = getBestSellersCount_result()
1366 
    result.read(self._iprot)
1367 
    self._iprot.readMessageEnd()
1368 
    if result.success is not None:
1369 
      return result.success
1370 
    if result.cex is not None:
1371 
      raise result.cex
1372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1373 
 
1374 
  def getBestDeals(self, ):
1375 
    self.send_getBestDeals()
1376 
    return self.recv_getBestDeals()
1377 
 
1378 
  def send_getBestDeals(self, ):
1379 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1380 
    args = getBestDeals_args()
1381 
    args.write(self._oprot)
1382 
    self._oprot.writeMessageEnd()
1383 
    self._oprot.trans.flush()
1384 
 
1385 
  def recv_getBestDeals(self, ):
1386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1387 
    if mtype == TMessageType.EXCEPTION:
1388 
      x = TApplicationException()
1389 
      x.read(self._iprot)
1390 
      self._iprot.readMessageEnd()
1391 
      raise x
1392 
    result = getBestDeals_result()
1393 
    result.read(self._iprot)
1394 
    self._iprot.readMessageEnd()
1395 
    if result.success is not None:
1396 
      return result.success
1397 
    if result.isex is not None:
1398 
      raise result.isex
1399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1400 
 
1401 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1402 
    """
1403 
    Parameters:
1404 
     - beginIndex
1405 
     - totalItems
1406 
     - brand
1407 
     - category
1408 
    """
1409 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1410 
    return self.recv_getBestDealsCatalogIds()
1411 
 
1412 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1413 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1414 
    args = getBestDealsCatalogIds_args()
1415 
    args.beginIndex = beginIndex
1416 
    args.totalItems = totalItems
1417 
    args.brand = brand
1418 
    args.category = category
1419 
    args.write(self._oprot)
1420 
    self._oprot.writeMessageEnd()
1421 
    self._oprot.trans.flush()
1422 
 
1423 
  def recv_getBestDealsCatalogIds(self, ):
1424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1425 
    if mtype == TMessageType.EXCEPTION:
1426 
      x = TApplicationException()
1427 
      x.read(self._iprot)
1428 
      self._iprot.readMessageEnd()
1429 
      raise x
1430 
    result = getBestDealsCatalogIds_result()
1431 
    result.read(self._iprot)
1432 
    self._iprot.readMessageEnd()
1433 
    if result.success is not None:
1434 
      return result.success
1435 
    if result.cex is not None:
1436 
      raise result.cex
1437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1438 
 
1439 
  def getBestDealsCount(self, ):
1440 
    self.send_getBestDealsCount()
1441 
    return self.recv_getBestDealsCount()
1442 
 
1443 
  def send_getBestDealsCount(self, ):
1444 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1445 
    args = getBestDealsCount_args()
1446 
    args.write(self._oprot)
1447 
    self._oprot.writeMessageEnd()
1448 
    self._oprot.trans.flush()
1449 
 
1450 
  def recv_getBestDealsCount(self, ):
1451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1452 
    if mtype == TMessageType.EXCEPTION:
1453 
      x = TApplicationException()
1454 
      x.read(self._iprot)
1455 
      self._iprot.readMessageEnd()
1456 
      raise x
1457 
    result = getBestDealsCount_result()
1458 
    result.read(self._iprot)
1459 
    self._iprot.readMessageEnd()
1460 
    if result.success is not None:
1461 
      return result.success
1462 
    if result.cex is not None:
1463 
      raise result.cex
1464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1465 
 
1466 
  def getComingSoon(self, ):
1467 
    self.send_getComingSoon()
1468 
    return self.recv_getComingSoon()
1469 
 
1470 
  def send_getComingSoon(self, ):
1471 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1472 
    args = getComingSoon_args()
1473 
    args.write(self._oprot)
1474 
    self._oprot.writeMessageEnd()
1475 
    self._oprot.trans.flush()
1476 
 
1477 
  def recv_getComingSoon(self, ):
1478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1479 
    if mtype == TMessageType.EXCEPTION:
1480 
      x = TApplicationException()
1481 
      x.read(self._iprot)
1482 
      self._iprot.readMessageEnd()
1483 
      raise x
1484 
    result = getComingSoon_result()
1485 
    result.read(self._iprot)
1486 
    self._iprot.readMessageEnd()
1487 
    if result.success is not None:
1488 
      return result.success
1489 
    if result.isex is not None:
1490 
      raise result.isex
1491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1492 
 
1493 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1494 
    """
1495 
    Parameters:
1496 
     - beginIndex
1497 
     - totalItems
1498 
     - brand
1499 
     - category
1500 
    """
1501 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1502 
    return self.recv_getComingSoonCatalogIds()
1503 
 
1504 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1505 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1506 
    args = getComingSoonCatalogIds_args()
1507 
    args.beginIndex = beginIndex
1508 
    args.totalItems = totalItems
1509 
    args.brand = brand
1510 
    args.category = category
1511 
    args.write(self._oprot)
1512 
    self._oprot.writeMessageEnd()
1513 
    self._oprot.trans.flush()
1514 
 
1515 
  def recv_getComingSoonCatalogIds(self, ):
1516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1517 
    if mtype == TMessageType.EXCEPTION:
1518 
      x = TApplicationException()
1519 
      x.read(self._iprot)
1520 
      self._iprot.readMessageEnd()
1521 
      raise x
1522 
    result = getComingSoonCatalogIds_result()
1523 
    result.read(self._iprot)
1524 
    self._iprot.readMessageEnd()
1525 
    if result.success is not None:
1526 
      return result.success
1527 
    if result.cex is not None:
1528 
      raise result.cex
1529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1530 
 
1531 
  def getComingSoonCount(self, ):
1532 
    self.send_getComingSoonCount()
1533 
    return self.recv_getComingSoonCount()
1534 
 
1535 
  def send_getComingSoonCount(self, ):
1536 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1537 
    args = getComingSoonCount_args()
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_getComingSoonCount(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = getComingSoonCount_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
1552 
    if result.success is not None:
1553 
      return result.success
1554 
    if result.cex is not None:
1555 
      raise result.cex
1556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1557 
 
1558 
  def getLatestArrivals(self, ):
1559 
    """
1560 
    Returns a list of items sorted in the descending order by start date.
1561 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1562 
    """
1563 
    self.send_getLatestArrivals()
1564 
    return self.recv_getLatestArrivals()
1565 
 
1566 
  def send_getLatestArrivals(self, ):
1567 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1568 
    args = getLatestArrivals_args()
1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_getLatestArrivals(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = getLatestArrivals_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
1583 
    if result.success is not None:
1584 
      return result.success
1585 
    if result.isex is not None:
1586 
      raise result.isex
1587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1588 
 
1589 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1590 
    """
1591 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1592 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1593 
 
1594 
    Parameters:
1595 
     - beginIndex
1596 
     - totalItems
1597 
     - brand
1598 
     - categories
1599 
    """
1600 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1601 
    return self.recv_getLatestArrivalsCatalogIds()
1602 
 
1603 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1604 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1605 
    args = getLatestArrivalsCatalogIds_args()
1606 
    args.beginIndex = beginIndex
1607 
    args.totalItems = totalItems
1608 
    args.brand = brand
1609 
    args.categories = categories
1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1614 
  def recv_getLatestArrivalsCatalogIds(self, ):
1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1621 
    result = getLatestArrivalsCatalogIds_result()
1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
1624 
    if result.success is not None:
1625 
      return result.success
1626 
    if result.cex is not None:
1627 
      raise result.cex
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1629 
 
1630 
  def getLatestArrivalsCount(self, ):
1631 
    """
1632 
    Get the total number of latest arrivals we are willing to show.
1633 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1634 
    """
1635 
    self.send_getLatestArrivalsCount()
1636 
    return self.recv_getLatestArrivalsCount()
1637 
 
1638 
  def send_getLatestArrivalsCount(self, ):
1639 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1640 
    args = getLatestArrivalsCount_args()
1641 
    args.write(self._oprot)
1642 
    self._oprot.writeMessageEnd()
1643 
    self._oprot.trans.flush()
1644 
 
1645 
  def recv_getLatestArrivalsCount(self, ):
1646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1647 
    if mtype == TMessageType.EXCEPTION:
1648 
      x = TApplicationException()
1649 
      x.read(self._iprot)
1650 
      self._iprot.readMessageEnd()
1651 
      raise x
1652 
    result = getLatestArrivalsCount_result()
1653 
    result.read(self._iprot)
1654 
    self._iprot.readMessageEnd()
1655 
    if result.success is not None:
1656 
      return result.success
1657 
    if result.cex is not None:
1658 
      raise result.cex
1659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1660 
 
1661 
  def generateNewEntityID(self, ):
1662 
    self.send_generateNewEntityID()
1663 
    return self.recv_generateNewEntityID()
1664 
 
1665 
  def send_generateNewEntityID(self, ):
1666 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1667 
    args = generateNewEntityID_args()
1668 
    args.write(self._oprot)
1669 
    self._oprot.writeMessageEnd()
1670 
    self._oprot.trans.flush()
1671 
 
1672 
  def recv_generateNewEntityID(self, ):
1673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1674 
    if mtype == TMessageType.EXCEPTION:
1675 
      x = TApplicationException()
1676 
      x.read(self._iprot)
1677 
      self._iprot.readMessageEnd()
1678 
      raise x
1679 
    result = generateNewEntityID_result()
1680 
    result.read(self._iprot)
1681 
    self._iprot.readMessageEnd()
1682 
    if result.success is not None:
1683 
      return result.success
1684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1685 
 
1686 
  def addCategory(self, category):
1687 
    """
1688 
    All category related functions
1689 
 
1690 
    Parameters:
1691 
     - category
1692 
    """
1693 
    self.send_addCategory(category)
1694 
    return self.recv_addCategory()
1695 
 
1696 
  def send_addCategory(self, category):
1697 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1698 
    args = addCategory_args()
1699 
    args.category = category
1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
1704 
  def recv_addCategory(self, ):
1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
1711 
    result = addCategory_result()
1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
1714 
    if result.success is not None:
1715 
      return result.success
1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1717 
 
1718 
  def getCategory(self, id):
1719 
    """
1720 
    Parameters:
1721 
     - id
1722 
    """
1723 
    self.send_getCategory(id)
1724 
    return self.recv_getCategory()
1725 
 
1726 
  def send_getCategory(self, id):
1727 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1728 
    args = getCategory_args()
1729 
    args.id = id
1730 
    args.write(self._oprot)
1731 
    self._oprot.writeMessageEnd()
1732 
    self._oprot.trans.flush()
1733 
 
1734 
  def recv_getCategory(self, ):
1735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1736 
    if mtype == TMessageType.EXCEPTION:
1737 
      x = TApplicationException()
1738 
      x.read(self._iprot)
1739 
      self._iprot.readMessageEnd()
1740 
      raise x
1741 
    result = getCategory_result()
1742 
    result.read(self._iprot)
1743 
    self._iprot.readMessageEnd()
1744 
    if result.success is not None:
1745 
      return result.success
1746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1747 
 
1748 
  def getAllCategories(self, ):
1749 
    self.send_getAllCategories()
1750 
    return self.recv_getAllCategories()
1751 
 
1752 
  def send_getAllCategories(self, ):
1753 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1754 
    args = getAllCategories_args()
1755 
    args.write(self._oprot)
1756 
    self._oprot.writeMessageEnd()
1757 
    self._oprot.trans.flush()
1758 
 
1759 
  def recv_getAllCategories(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 = getAllCategories_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, "getAllCategories failed: unknown result");
1772 
 
1773 
  def getAllSimilarItems(self, itemId):
1774 
    """
1775 
    Returns the list of similar items.
1776 
 
1777 
    Parameters:
1778 
     - itemId
1779 
    """
1780 
    self.send_getAllSimilarItems(itemId)
1781 
    return self.recv_getAllSimilarItems()
1782 
 
1783 
  def send_getAllSimilarItems(self, itemId):
1784 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1785 
    args = getAllSimilarItems_args()
1786 
    args.itemId = itemId
1787 
    args.write(self._oprot)
1788 
    self._oprot.writeMessageEnd()
1789 
    self._oprot.trans.flush()
1790 
 
1791 
  def recv_getAllSimilarItems(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 = getAllSimilarItems_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, "getAllSimilarItems failed: unknown result");
1804 
 
1805 
  def addSimilarItem(self, itemId, catalogItemId):
1806 
    """
1807 
    Adds similar item.
1808 
 
1809 
    Parameters:
1810 
     - itemId
1811 
     - catalogItemId
1812 
    """
1813 
    self.send_addSimilarItem(itemId, catalogItemId)
1814 
    return self.recv_addSimilarItem()
1815 
 
1816 
  def send_addSimilarItem(self, itemId, catalogItemId):
1817 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1818 
    args = addSimilarItem_args()
1819 
    args.itemId = itemId
1820 
    args.catalogItemId = catalogItemId
1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
1825 
  def recv_addSimilarItem(self, ):
1826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1827 
    if mtype == TMessageType.EXCEPTION:
1828 
      x = TApplicationException()
1829 
      x.read(self._iprot)
1830 
      self._iprot.readMessageEnd()
1831 
      raise x
1832 
    result = addSimilarItem_result()
1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
1835 
    if result.success is not None:
1836 
      return result.success
1837 
    if result.cex is not None:
1838 
      raise result.cex
1839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1840 
 
6512 kshitij.so 1841 
  def addTag(self, displayName, itemId):
1842 
    """
1843 
    Tag Related
1844 
 
1845 
    Parameters:
1846 
     - displayName
1847 
     - itemId
1848 
    """
1849 
    self.send_addTag(displayName, itemId)
1850 
    return self.recv_addTag()
1851 
 
1852 
  def send_addTag(self, displayName, itemId):
1853 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1854 
    args = addTag_args()
1855 
    args.displayName = displayName
1856 
    args.itemId = itemId
1857 
    args.write(self._oprot)
1858 
    self._oprot.writeMessageEnd()
1859 
    self._oprot.trans.flush()
1860 
 
1861 
  def recv_addTag(self, ):
1862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1863 
    if mtype == TMessageType.EXCEPTION:
1864 
      x = TApplicationException()
1865 
      x.read(self._iprot)
1866 
      self._iprot.readMessageEnd()
1867 
      raise x
1868 
    result = addTag_result()
1869 
    result.read(self._iprot)
1870 
    self._iprot.readMessageEnd()
1871 
    if result.success is not None:
1872 
      return result.success
1873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1874 
 
1875 
  def deleteEntityTag(self, displayName, itemId):
1876 
    """
1877 
    Parameters:
1878 
     - displayName
1879 
     - itemId
1880 
    """
1881 
    self.send_deleteEntityTag(displayName, itemId)
1882 
    return self.recv_deleteEntityTag()
1883 
 
1884 
  def send_deleteEntityTag(self, displayName, itemId):
1885 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1886 
    args = deleteEntityTag_args()
1887 
    args.displayName = displayName
1888 
    args.itemId = itemId
1889 
    args.write(self._oprot)
1890 
    self._oprot.writeMessageEnd()
1891 
    self._oprot.trans.flush()
1892 
 
1893 
  def recv_deleteEntityTag(self, ):
1894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1895 
    if mtype == TMessageType.EXCEPTION:
1896 
      x = TApplicationException()
1897 
      x.read(self._iprot)
1898 
      self._iprot.readMessageEnd()
1899 
      raise x
1900 
    result = deleteEntityTag_result()
1901 
    result.read(self._iprot)
1902 
    self._iprot.readMessageEnd()
1903 
    if result.success is not None:
1904 
      return result.success
1905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1906 
 
1907 
  def deleteTag(self, displayName):
1908 
    """
1909 
    Parameters:
1910 
     - displayName
1911 
    """
1912 
    self.send_deleteTag(displayName)
1913 
    return self.recv_deleteTag()
1914 
 
1915 
  def send_deleteTag(self, displayName):
1916 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1917 
    args = deleteTag_args()
1918 
    args.displayName = displayName
1919 
    args.write(self._oprot)
1920 
    self._oprot.writeMessageEnd()
1921 
    self._oprot.trans.flush()
1922 
 
1923 
  def recv_deleteTag(self, ):
1924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1925 
    if mtype == TMessageType.EXCEPTION:
1926 
      x = TApplicationException()
1927 
      x.read(self._iprot)
1928 
      self._iprot.readMessageEnd()
1929 
      raise x
1930 
    result = deleteTag_result()
1931 
    result.read(self._iprot)
1932 
    self._iprot.readMessageEnd()
1933 
    if result.success is not None:
1934 
      return result.success
1935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1936 
 
1937 
  def getAllTags(self, ):
1938 
    self.send_getAllTags()
1939 
    return self.recv_getAllTags()
1940 
 
1941 
  def send_getAllTags(self, ):
1942 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1943 
    args = getAllTags_args()
1944 
    args.write(self._oprot)
1945 
    self._oprot.writeMessageEnd()
1946 
    self._oprot.trans.flush()
1947 
 
1948 
  def recv_getAllTags(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 = getAllTags_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, "getAllTags failed: unknown result");
1961 
 
1962 
  def getAllEntitiesByTagName(self, displayName):
1963 
    """
1964 
    Parameters:
1965 
     - displayName
1966 
    """
1967 
    self.send_getAllEntitiesByTagName(displayName)
1968 
    return self.recv_getAllEntitiesByTagName()
1969 
 
1970 
  def send_getAllEntitiesByTagName(self, displayName):
1971 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
1972 
    args = getAllEntitiesByTagName_args()
1973 
    args.displayName = displayName
1974 
    args.write(self._oprot)
1975 
    self._oprot.writeMessageEnd()
1976 
    self._oprot.trans.flush()
1977 
 
1978 
  def recv_getAllEntitiesByTagName(self, ):
1979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1980 
    if mtype == TMessageType.EXCEPTION:
1981 
      x = TApplicationException()
1982 
      x.read(self._iprot)
1983 
      self._iprot.readMessageEnd()
1984 
      raise x
1985 
    result = getAllEntitiesByTagName_result()
1986 
    result.read(self._iprot)
1987 
    self._iprot.readMessageEnd()
1988 
    if result.success is not None:
1989 
      return result.success
1990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
1991 
 
6845 amit.gupta 1992 
  def getAllEntityTags(self, ):
1993 
    self.send_getAllEntityTags()
1994 
    return self.recv_getAllEntityTags()
1995 
 
1996 
  def send_getAllEntityTags(self, ):
1997 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
1998 
    args = getAllEntityTags_args()
1999 
    args.write(self._oprot)
2000 
    self._oprot.writeMessageEnd()
2001 
    self._oprot.trans.flush()
2002 
 
2003 
  def recv_getAllEntityTags(self, ):
2004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2005 
    if mtype == TMessageType.EXCEPTION:
2006 
      x = TApplicationException()
2007 
      x.read(self._iprot)
2008 
      self._iprot.readMessageEnd()
2009 
      raise x
2010 
    result = getAllEntityTags_result()
2011 
    result.read(self._iprot)
2012 
    self._iprot.readMessageEnd()
2013 
    if result.success is not None:
2014 
      return result.success
2015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2016 
 
6850 kshitij.so 2017 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2018 
    """
2019 
    Parameters:
2020 
     - bannerName
2021 
     - imageName
2022 
     - link
2023 
     - priority
2024 
     - isActive
2025 
     - hasMap
2026 
    """
2027 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2028 
    return self.recv_addBanner()
2029 
 
2030 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2031 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2032 
    args = addBanner_args()
2033 
    args.bannerName = bannerName
2034 
    args.imageName = imageName
2035 
    args.link = link
2036 
    args.priority = priority
2037 
    args.isActive = isActive
2038 
    args.hasMap = hasMap
2039 
    args.write(self._oprot)
2040 
    self._oprot.writeMessageEnd()
2041 
    self._oprot.trans.flush()
2042 
 
2043 
  def recv_addBanner(self, ):
2044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2045 
    if mtype == TMessageType.EXCEPTION:
2046 
      x = TApplicationException()
2047 
      x.read(self._iprot)
2048 
      self._iprot.readMessageEnd()
2049 
      raise x
2050 
    result = addBanner_result()
2051 
    result.read(self._iprot)
2052 
    self._iprot.readMessageEnd()
2053 
    if result.success is not None:
2054 
      return result.success
2055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2056 
 
2057 
  def getAllBanners(self, ):
2058 
    self.send_getAllBanners()
2059 
    return self.recv_getAllBanners()
2060 
 
2061 
  def send_getAllBanners(self, ):
2062 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2063 
    args = getAllBanners_args()
2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
2068 
  def recv_getAllBanners(self, ):
2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
2075 
    result = getAllBanners_result()
2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
2078 
    if result.success is not None:
2079 
      return result.success
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2081 
 
2082 
  def deleteBanner(self, bannerName):
2083 
    """
2084 
    Parameters:
2085 
     - bannerName
2086 
    """
2087 
    self.send_deleteBanner(bannerName)
2088 
    return self.recv_deleteBanner()
2089 
 
2090 
  def send_deleteBanner(self, bannerName):
2091 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2092 
    args = deleteBanner_args()
2093 
    args.bannerName = bannerName
2094 
    args.write(self._oprot)
2095 
    self._oprot.writeMessageEnd()
2096 
    self._oprot.trans.flush()
2097 
 
2098 
  def recv_deleteBanner(self, ):
2099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2100 
    if mtype == TMessageType.EXCEPTION:
2101 
      x = TApplicationException()
2102 
      x.read(self._iprot)
2103 
      self._iprot.readMessageEnd()
2104 
      raise x
2105 
    result = deleteBanner_result()
2106 
    result.read(self._iprot)
2107 
    self._iprot.readMessageEnd()
2108 
    if result.success is not None:
2109 
      return result.success
2110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2111 
 
2112 
  def getBannerDetails(self, bannerName):
2113 
    """
2114 
    Parameters:
2115 
     - bannerName
2116 
    """
2117 
    self.send_getBannerDetails(bannerName)
2118 
    return self.recv_getBannerDetails()
2119 
 
2120 
  def send_getBannerDetails(self, bannerName):
2121 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2122 
    args = getBannerDetails_args()
2123 
    args.bannerName = bannerName
2124 
    args.write(self._oprot)
2125 
    self._oprot.writeMessageEnd()
2126 
    self._oprot.trans.flush()
2127 
 
2128 
  def recv_getBannerDetails(self, ):
2129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2130 
    if mtype == TMessageType.EXCEPTION:
2131 
      x = TApplicationException()
2132 
      x.read(self._iprot)
2133 
      self._iprot.readMessageEnd()
2134 
      raise x
2135 
    result = getBannerDetails_result()
2136 
    result.read(self._iprot)
2137 
    self._iprot.readMessageEnd()
2138 
    if result.success is not None:
2139 
      return result.success
2140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2141 
 
2142 
  def getActiveBanners(self, ):
2143 
    self.send_getActiveBanners()
2144 
    return self.recv_getActiveBanners()
2145 
 
2146 
  def send_getActiveBanners(self, ):
2147 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2148 
    args = getActiveBanners_args()
2149 
    args.write(self._oprot)
2150 
    self._oprot.writeMessageEnd()
2151 
    self._oprot.trans.flush()
2152 
 
2153 
  def recv_getActiveBanners(self, ):
2154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2155 
    if mtype == TMessageType.EXCEPTION:
2156 
      x = TApplicationException()
2157 
      x.read(self._iprot)
2158 
      self._iprot.readMessageEnd()
2159 
      raise x
2160 
    result = getActiveBanners_result()
2161 
    result.read(self._iprot)
2162 
    self._iprot.readMessageEnd()
2163 
    if result.success is not None:
2164 
      return result.success
2165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2166 
 
6849 kshitij.so 2167 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2168 
    """
2169 
    Parameters:
2170 
     - bannerName
2171 
     - mapLink
2172 
     - coordinates
2173 
    """
2174 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2175 
    return self.recv_addBannerMap()
2176 
 
2177 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2178 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2179 
    args = addBannerMap_args()
2180 
    args.bannerName = bannerName
2181 
    args.mapLink = mapLink
2182 
    args.coordinates = coordinates
2183 
    args.write(self._oprot)
2184 
    self._oprot.writeMessageEnd()
2185 
    self._oprot.trans.flush()
2186 
 
2187 
  def recv_addBannerMap(self, ):
2188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2189 
    if mtype == TMessageType.EXCEPTION:
2190 
      x = TApplicationException()
2191 
      x.read(self._iprot)
2192 
      self._iprot.readMessageEnd()
2193 
      raise x
2194 
    result = addBannerMap_result()
2195 
    result.read(self._iprot)
2196 
    self._iprot.readMessageEnd()
2197 
    if result.success is not None:
2198 
      return result.success
2199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2200 
 
2201 
  def deleteBannerMap(self, bannerName):
2202 
    """
2203 
    Parameters:
2204 
     - bannerName
2205 
    """
2206 
    self.send_deleteBannerMap(bannerName)
2207 
    return self.recv_deleteBannerMap()
2208 
 
2209 
  def send_deleteBannerMap(self, bannerName):
2210 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2211 
    args = deleteBannerMap_args()
2212 
    args.bannerName = bannerName
2213 
    args.write(self._oprot)
2214 
    self._oprot.writeMessageEnd()
2215 
    self._oprot.trans.flush()
2216 
 
2217 
  def recv_deleteBannerMap(self, ):
2218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2219 
    if mtype == TMessageType.EXCEPTION:
2220 
      x = TApplicationException()
2221 
      x.read(self._iprot)
2222 
      self._iprot.readMessageEnd()
2223 
      raise x
2224 
    result = deleteBannerMap_result()
2225 
    result.read(self._iprot)
2226 
    self._iprot.readMessageEnd()
2227 
    if result.success is not None:
2228 
      return result.success
2229 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2230 
 
2231 
  def getBannerMapDetails(self, bannerName):
2232 
    """
2233 
    Parameters:
2234 
     - bannerName
2235 
    """
2236 
    self.send_getBannerMapDetails(bannerName)
2237 
    return self.recv_getBannerMapDetails()
2238 
 
2239 
  def send_getBannerMapDetails(self, bannerName):
2240 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2241 
    args = getBannerMapDetails_args()
2242 
    args.bannerName = bannerName
2243 
    args.write(self._oprot)
2244 
    self._oprot.writeMessageEnd()
2245 
    self._oprot.trans.flush()
2246 
 
2247 
  def recv_getBannerMapDetails(self, ):
2248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2249 
    if mtype == TMessageType.EXCEPTION:
2250 
      x = TApplicationException()
2251 
      x.read(self._iprot)
2252 
      self._iprot.readMessageEnd()
2253 
      raise x
2254 
    result = getBannerMapDetails_result()
2255 
    result.read(self._iprot)
2256 
    self._iprot.readMessageEnd()
2257 
    if result.success is not None:
2258 
      return result.success
2259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2260 
 
5944 mandeep.dh 2261 
  def deleteSimilarItem(self, itemId, catalogItemId):
2262 
    """
2263 
    Delete similar item.
2264 
 
2265 
    Parameters:
2266 
     - itemId
2267 
     - catalogItemId
2268 
    """
2269 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2270 
    return self.recv_deleteSimilarItem()
2271 
 
2272 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2273 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2274 
    args = deleteSimilarItem_args()
2275 
    args.itemId = itemId
2276 
    args.catalogItemId = catalogItemId
2277 
    args.write(self._oprot)
2278 
    self._oprot.writeMessageEnd()
2279 
    self._oprot.trans.flush()
2280 
 
2281 
  def recv_deleteSimilarItem(self, ):
2282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2283 
    if mtype == TMessageType.EXCEPTION:
2284 
      x = TApplicationException()
2285 
      x.read(self._iprot)
2286 
      self._iprot.readMessageEnd()
2287 
      raise x
2288 
    result = deleteSimilarItem_result()
2289 
    result.read(self._iprot)
2290 
    self._iprot.readMessageEnd()
2291 
    if result.success is not None:
2292 
      return result.success
2293 
    if result.cex is not None:
2294 
      raise result.cex
2295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2296 
 
2297 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2298 
    """
2299 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2300 
    If yes, returns the itemId else returns 0
2301 
 
2302 
    Parameters:
2303 
     - brand
2304 
     - modelNumber
2305 
     - modelName
2306 
     - color
2307 
    """
2308 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2309 
    return self.recv_checkSimilarItem()
2310 
 
2311 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2312 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2313 
    args = checkSimilarItem_args()
2314 
    args.brand = brand
2315 
    args.modelNumber = modelNumber
2316 
    args.modelName = modelName
2317 
    args.color = color
2318 
    args.write(self._oprot)
2319 
    self._oprot.writeMessageEnd()
2320 
    self._oprot.trans.flush()
2321 
 
2322 
  def recv_checkSimilarItem(self, ):
2323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2324 
    if mtype == TMessageType.EXCEPTION:
2325 
      x = TApplicationException()
2326 
      x.read(self._iprot)
2327 
      self._iprot.readMessageEnd()
2328 
      raise x
2329 
    result = checkSimilarItem_result()
2330 
    result.read(self._iprot)
2331 
    self._iprot.readMessageEnd()
2332 
    if result.success is not None:
2333 
      return result.success
2334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2335 
 
2336 
  def validateRiskyStatus(self, itemId):
2337 
    """
2338 
    Check wether item is risky and change status if inventory is not available for risky items
2339 
 
2340 
    Parameters:
2341 
     - itemId
2342 
    """
2343 
    self.send_validateRiskyStatus(itemId)
2344 
    self.recv_validateRiskyStatus()
2345 
 
2346 
  def send_validateRiskyStatus(self, itemId):
2347 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2348 
    args = validateRiskyStatus_args()
2349 
    args.itemId = itemId
2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
2354 
  def recv_validateRiskyStatus(self, ):
2355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2356 
    if mtype == TMessageType.EXCEPTION:
2357 
      x = TApplicationException()
2358 
      x.read(self._iprot)
2359 
      self._iprot.readMessageEnd()
2360 
      raise x
2361 
    result = validateRiskyStatus_result()
2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
2364 
    return
2365 
 
2366 
  def changeItemRiskyFlag(self, itemId, risky):
2367 
    """
2368 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2369 
 
2370 
    Parameters:
2371 
     - itemId
2372 
     - risky
2373 
    """
2374 
    self.send_changeItemRiskyFlag(itemId, risky)
2375 
    self.recv_changeItemRiskyFlag()
2376 
 
2377 
  def send_changeItemRiskyFlag(self, itemId, risky):
2378 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2379 
    args = changeItemRiskyFlag_args()
2380 
    args.itemId = itemId
2381 
    args.risky = risky
2382 
    args.write(self._oprot)
2383 
    self._oprot.writeMessageEnd()
2384 
    self._oprot.trans.flush()
2385 
 
2386 
  def recv_changeItemRiskyFlag(self, ):
2387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2388 
    if mtype == TMessageType.EXCEPTION:
2389 
      x = TApplicationException()
2390 
      x.read(self._iprot)
2391 
      self._iprot.readMessageEnd()
2392 
      raise x
2393 
    result = changeItemRiskyFlag_result()
2394 
    result.read(self._iprot)
2395 
    self._iprot.readMessageEnd()
2396 
    return
2397 
 
2398 
  def getItemsByRiskyFlag(self, ):
2399 
    """
2400 
    Returns list of items marked as risky.
2401 
    """
2402 
    self.send_getItemsByRiskyFlag()
2403 
    return self.recv_getItemsByRiskyFlag()
2404 
 
2405 
  def send_getItemsByRiskyFlag(self, ):
2406 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2407 
    args = getItemsByRiskyFlag_args()
2408 
    args.write(self._oprot)
2409 
    self._oprot.writeMessageEnd()
2410 
    self._oprot.trans.flush()
2411 
 
2412 
  def recv_getItemsByRiskyFlag(self, ):
2413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2414 
    if mtype == TMessageType.EXCEPTION:
2415 
      x = TApplicationException()
2416 
      x.read(self._iprot)
2417 
      self._iprot.readMessageEnd()
2418 
      raise x
2419 
    result = getItemsByRiskyFlag_result()
2420 
    result.read(self._iprot)
2421 
    self._iprot.readMessageEnd()
2422 
    if result.success is not None:
2423 
      return result.success
2424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2425 
 
2426 
  def getItemsForMasterSheet(self, category, brand):
2427 
    """
2428 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2429 
 
2430 
    Parameters:
2431 
     - category
2432 
     - brand
2433 
    """
2434 
    self.send_getItemsForMasterSheet(category, brand)
2435 
    return self.recv_getItemsForMasterSheet()
2436 
 
2437 
  def send_getItemsForMasterSheet(self, category, brand):
2438 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2439 
    args = getItemsForMasterSheet_args()
2440 
    args.category = category
2441 
    args.brand = brand
2442 
    args.write(self._oprot)
2443 
    self._oprot.writeMessageEnd()
2444 
    self._oprot.trans.flush()
2445 
 
2446 
  def recv_getItemsForMasterSheet(self, ):
2447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2448 
    if mtype == TMessageType.EXCEPTION:
2449 
      x = TApplicationException()
2450 
      x.read(self._iprot)
2451 
      self._iprot.readMessageEnd()
2452 
      raise x
2453 
    result = getItemsForMasterSheet_result()
2454 
    result.read(self._iprot)
2455 
    self._iprot.readMessageEnd()
2456 
    if result.success is not None:
2457 
      return result.success
2458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2459 
 
2460 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2461 
    """
2462 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2463 
 
2464 
    Parameters:
2465 
     - beginIndex
2466 
     - totalItems
2467 
     - itemId
2468 
    """
2469 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2470 
    return self.recv_getSimilarItemsCatalogIds()
2471 
 
2472 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2473 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2474 
    args = getSimilarItemsCatalogIds_args()
2475 
    args.beginIndex = beginIndex
2476 
    args.totalItems = totalItems
2477 
    args.itemId = itemId
2478 
    args.write(self._oprot)
2479 
    self._oprot.writeMessageEnd()
2480 
    self._oprot.trans.flush()
2481 
 
2482 
  def recv_getSimilarItemsCatalogIds(self, ):
2483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2484 
    if mtype == TMessageType.EXCEPTION:
2485 
      x = TApplicationException()
2486 
      x.read(self._iprot)
2487 
      self._iprot.readMessageEnd()
2488 
      raise x
2489 
    result = getSimilarItemsCatalogIds_result()
2490 
    result.read(self._iprot)
2491 
    self._iprot.readMessageEnd()
2492 
    if result.success is not None:
2493 
      return result.success
2494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2495 
 
2496 
  def addProductNotification(self, itemId, email):
2497 
    """
2498 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2499 
 
2500 
    Parameters:
2501 
     - itemId
2502 
     - email
2503 
    """
2504 
    self.send_addProductNotification(itemId, email)
2505 
    return self.recv_addProductNotification()
2506 
 
2507 
  def send_addProductNotification(self, itemId, email):
2508 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2509 
    args = addProductNotification_args()
2510 
    args.itemId = itemId
2511 
    args.email = email
2512 
    args.write(self._oprot)
2513 
    self._oprot.writeMessageEnd()
2514 
    self._oprot.trans.flush()
2515 
 
2516 
  def recv_addProductNotification(self, ):
2517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2518 
    if mtype == TMessageType.EXCEPTION:
2519 
      x = TApplicationException()
2520 
      x.read(self._iprot)
2521 
      self._iprot.readMessageEnd()
2522 
      raise x
2523 
    result = addProductNotification_result()
2524 
    result.read(self._iprot)
2525 
    self._iprot.readMessageEnd()
2526 
    if result.success is not None:
2527 
      return result.success
2528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2529 
 
2530 
  def sendProductNotifications(self, ):
2531 
    """
2532 
    Send the product notifications to the users for items which has stock.
2533 
    """
2534 
    self.send_sendProductNotifications()
2535 
    return self.recv_sendProductNotifications()
2536 
 
2537 
  def send_sendProductNotifications(self, ):
2538 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2539 
    args = sendProductNotifications_args()
2540 
    args.write(self._oprot)
2541 
    self._oprot.writeMessageEnd()
2542 
    self._oprot.trans.flush()
2543 
 
2544 
  def recv_sendProductNotifications(self, ):
2545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2546 
    if mtype == TMessageType.EXCEPTION:
2547 
      x = TApplicationException()
2548 
      x.read(self._iprot)
2549 
      self._iprot.readMessageEnd()
2550 
      raise x
2551 
    result = sendProductNotifications_result()
2552 
    result.read(self._iprot)
2553 
    self._iprot.readMessageEnd()
2554 
    if result.success is not None:
2555 
      return result.success
2556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2557 
 
2558 
  def getAllBrandsByCategory(self, categoryId):
2559 
    """
2560 
    Returns list of brand names for a given category Id
2561 
 
2562 
    Parameters:
2563 
     - categoryId
2564 
    """
2565 
    self.send_getAllBrandsByCategory(categoryId)
2566 
    return self.recv_getAllBrandsByCategory()
2567 
 
2568 
  def send_getAllBrandsByCategory(self, categoryId):
2569 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2570 
    args = getAllBrandsByCategory_args()
2571 
    args.categoryId = categoryId
2572 
    args.write(self._oprot)
2573 
    self._oprot.writeMessageEnd()
2574 
    self._oprot.trans.flush()
2575 
 
2576 
  def recv_getAllBrandsByCategory(self, ):
2577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2578 
    if mtype == TMessageType.EXCEPTION:
2579 
      x = TApplicationException()
2580 
      x.read(self._iprot)
2581 
      self._iprot.readMessageEnd()
2582 
      raise x
2583 
    result = getAllBrandsByCategory_result()
2584 
    result.read(self._iprot)
2585 
    self._iprot.readMessageEnd()
2586 
    if result.success is not None:
2587 
      return result.success
2588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2589 
 
2590 
  def getAllBrands(self, ):
2591 
    """
2592 
    Returns list of brand names
2593 
    """
2594 
    self.send_getAllBrands()
2595 
    return self.recv_getAllBrands()
2596 
 
2597 
  def send_getAllBrands(self, ):
2598 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2599 
    args = getAllBrands_args()
2600 
    args.write(self._oprot)
2601 
    self._oprot.writeMessageEnd()
2602 
    self._oprot.trans.flush()
2603 
 
2604 
  def recv_getAllBrands(self, ):
2605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2606 
    if mtype == TMessageType.EXCEPTION:
2607 
      x = TApplicationException()
2608 
      x.read(self._iprot)
2609 
      self._iprot.readMessageEnd()
2610 
      raise x
2611 
    result = getAllBrands_result()
2612 
    result.read(self._iprot)
2613 
    self._iprot.readMessageEnd()
2614 
    if result.success is not None:
2615 
      return result.success
2616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2617 
 
2618 
  def getAllSources(self, ):
2619 
    """
2620 
    Return list of all sources
2621 
    """
2622 
    self.send_getAllSources()
2623 
    return self.recv_getAllSources()
2624 
 
2625 
  def send_getAllSources(self, ):
2626 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2627 
    args = getAllSources_args()
2628 
    args.write(self._oprot)
2629 
    self._oprot.writeMessageEnd()
2630 
    self._oprot.trans.flush()
2631 
 
2632 
  def recv_getAllSources(self, ):
2633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2634 
    if mtype == TMessageType.EXCEPTION:
2635 
      x = TApplicationException()
2636 
      x.read(self._iprot)
2637 
      self._iprot.readMessageEnd()
2638 
      raise x
2639 
    result = getAllSources_result()
2640 
    result.read(self._iprot)
2641 
    self._iprot.readMessageEnd()
2642 
    if result.success is not None:
2643 
      return result.success
2644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2645 
 
2646 
  def getItemPricingBySource(self, itemId, sourceId):
2647 
    """
2648 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2649 
 
2650 
    Parameters:
2651 
     - itemId
2652 
     - sourceId
2653 
    """
2654 
    self.send_getItemPricingBySource(itemId, sourceId)
2655 
    return self.recv_getItemPricingBySource()
2656 
 
2657 
  def send_getItemPricingBySource(self, itemId, sourceId):
2658 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2659 
    args = getItemPricingBySource_args()
2660 
    args.itemId = itemId
2661 
    args.sourceId = sourceId
2662 
    args.write(self._oprot)
2663 
    self._oprot.writeMessageEnd()
2664 
    self._oprot.trans.flush()
2665 
 
2666 
  def recv_getItemPricingBySource(self, ):
2667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2668 
    if mtype == TMessageType.EXCEPTION:
2669 
      x = TApplicationException()
2670 
      x.read(self._iprot)
2671 
      self._iprot.readMessageEnd()
2672 
      raise x
2673 
    result = getItemPricingBySource_result()
2674 
    result.read(self._iprot)
2675 
    self._iprot.readMessageEnd()
2676 
    if result.success is not None:
2677 
      return result.success
2678 
    if result.cex is not None:
2679 
      raise result.cex
2680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2681 
 
2682 
  def addSourceItemPricing(self, sourceItemPricing):
2683 
    """
2684 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2685 
    If item is not found or source is not found, it will throw exception.
2686 
 
2687 
    Parameters:
2688 
     - sourceItemPricing
2689 
    """
2690 
    self.send_addSourceItemPricing(sourceItemPricing)
2691 
    self.recv_addSourceItemPricing()
2692 
 
2693 
  def send_addSourceItemPricing(self, sourceItemPricing):
2694 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2695 
    args = addSourceItemPricing_args()
2696 
    args.sourceItemPricing = sourceItemPricing
2697 
    args.write(self._oprot)
2698 
    self._oprot.writeMessageEnd()
2699 
    self._oprot.trans.flush()
2700 
 
2701 
  def recv_addSourceItemPricing(self, ):
2702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2703 
    if mtype == TMessageType.EXCEPTION:
2704 
      x = TApplicationException()
2705 
      x.read(self._iprot)
2706 
      self._iprot.readMessageEnd()
2707 
      raise x
2708 
    result = addSourceItemPricing_result()
2709 
    result.read(self._iprot)
2710 
    self._iprot.readMessageEnd()
2711 
    if result.cex is not None:
2712 
      raise result.cex
2713 
    return
2714 
 
2715 
  def getAllSourcePricing(self, itemId):
2716 
    """
2717 
    Returns the list of source pricing information of an item.
2718 
    Raises an exception if item not found corresponding to itemId
2719 
 
2720 
    Parameters:
2721 
     - itemId
2722 
    """
2723 
    self.send_getAllSourcePricing(itemId)
2724 
    return self.recv_getAllSourcePricing()
2725 
 
2726 
  def send_getAllSourcePricing(self, itemId):
2727 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2728 
    args = getAllSourcePricing_args()
2729 
    args.itemId = itemId
2730 
    args.write(self._oprot)
2731 
    self._oprot.writeMessageEnd()
2732 
    self._oprot.trans.flush()
2733 
 
2734 
  def recv_getAllSourcePricing(self, ):
2735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2736 
    if mtype == TMessageType.EXCEPTION:
2737 
      x = TApplicationException()
2738 
      x.read(self._iprot)
2739 
      self._iprot.readMessageEnd()
2740 
      raise x
2741 
    result = getAllSourcePricing_result()
2742 
    result.read(self._iprot)
2743 
    self._iprot.readMessageEnd()
2744 
    if result.success is not None:
2745 
      return result.success
2746 
    if result.cex is not None:
2747 
      raise result.cex
2748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2749 
 
2750 
  def getItemForSource(self, item_id, sourceId):
2751 
    """
2752 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2753 
 
2754 
    Parameters:
2755 
     - item_id
2756 
     - sourceId
2757 
    """
2758 
    self.send_getItemForSource(item_id, sourceId)
2759 
    return self.recv_getItemForSource()
2760 
 
2761 
  def send_getItemForSource(self, item_id, sourceId):
2762 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2763 
    args = getItemForSource_args()
2764 
    args.item_id = item_id
2765 
    args.sourceId = sourceId
2766 
    args.write(self._oprot)
2767 
    self._oprot.writeMessageEnd()
2768 
    self._oprot.trans.flush()
2769 
 
2770 
  def recv_getItemForSource(self, ):
2771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2772 
    if mtype == TMessageType.EXCEPTION:
2773 
      x = TApplicationException()
2774 
      x.read(self._iprot)
2775 
      self._iprot.readMessageEnd()
2776 
      raise x
2777 
    result = getItemForSource_result()
2778 
    result.read(self._iprot)
2779 
    self._iprot.readMessageEnd()
2780 
    if result.success is not None:
2781 
      return result.success
2782 
    if result.cex is not None:
2783 
      raise result.cex
2784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2785 
 
2786 
  def searchItemsInRange(self, searchTerms, offset, limit):
2787 
    """
2788 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2789 
 
2790 
    Parameters:
2791 
     - searchTerms
2792 
     - offset
2793 
     - limit
2794 
    """
2795 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2796 
    return self.recv_searchItemsInRange()
2797 
 
2798 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2799 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2800 
    args = searchItemsInRange_args()
2801 
    args.searchTerms = searchTerms
2802 
    args.offset = offset
2803 
    args.limit = limit
2804 
    args.write(self._oprot)
2805 
    self._oprot.writeMessageEnd()
2806 
    self._oprot.trans.flush()
2807 
 
2808 
  def recv_searchItemsInRange(self, ):
2809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2810 
    if mtype == TMessageType.EXCEPTION:
2811 
      x = TApplicationException()
2812 
      x.read(self._iprot)
2813 
      self._iprot.readMessageEnd()
2814 
      raise x
2815 
    result = searchItemsInRange_result()
2816 
    result.read(self._iprot)
2817 
    self._iprot.readMessageEnd()
2818 
    if result.success is not None:
2819 
      return result.success
2820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2821 
 
2822 
  def getSearchResultCount(self, searchTerms):
2823 
    """
2824 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2825 
 
2826 
    Parameters:
2827 
     - searchTerms
2828 
    """
2829 
    self.send_getSearchResultCount(searchTerms)
2830 
    return self.recv_getSearchResultCount()
2831 
 
2832 
  def send_getSearchResultCount(self, searchTerms):
2833 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2834 
    args = getSearchResultCount_args()
2835 
    args.searchTerms = searchTerms
2836 
    args.write(self._oprot)
2837 
    self._oprot.writeMessageEnd()
2838 
    self._oprot.trans.flush()
2839 
 
2840 
  def recv_getSearchResultCount(self, ):
2841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2842 
    if mtype == TMessageType.EXCEPTION:
2843 
      x = TApplicationException()
2844 
      x.read(self._iprot)
2845 
      self._iprot.readMessageEnd()
2846 
      raise x
2847 
    result = getSearchResultCount_result()
2848 
    result.read(self._iprot)
2849 
    self._iprot.readMessageEnd()
2850 
    if result.success is not None:
2851 
      return result.success
2852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2853 
 
2854 
  def getProductNotifications(self, startDateTime):
2855 
    """
2856 
    Returns a list of product notifications added after a supplied datetime
2857 
 
2858 
    Parameters:
2859 
     - startDateTime
2860 
    """
2861 
    self.send_getProductNotifications(startDateTime)
2862 
    return self.recv_getProductNotifications()
2863 
 
2864 
  def send_getProductNotifications(self, startDateTime):
2865 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2866 
    args = getProductNotifications_args()
2867 
    args.startDateTime = startDateTime
2868 
    args.write(self._oprot)
2869 
    self._oprot.writeMessageEnd()
2870 
    self._oprot.trans.flush()
2871 
 
2872 
  def recv_getProductNotifications(self, ):
2873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2874 
    if mtype == TMessageType.EXCEPTION:
2875 
      x = TApplicationException()
2876 
      x.read(self._iprot)
2877 
      self._iprot.readMessageEnd()
2878 
      raise x
2879 
    result = getProductNotifications_result()
2880 
    result.read(self._iprot)
2881 
    self._iprot.readMessageEnd()
2882 
    if result.success is not None:
2883 
      return result.success
2884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2885 
 
2886 
  def getProductNotificationRequestCount(self, startDateTime):
2887 
    """
2888 
    Returns a list of count of requests for product notification against each item
2889 
 
2890 
    Parameters:
2891 
     - startDateTime
2892 
    """
2893 
    self.send_getProductNotificationRequestCount(startDateTime)
2894 
    return self.recv_getProductNotificationRequestCount()
2895 
 
2896 
  def send_getProductNotificationRequestCount(self, startDateTime):
2897 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2898 
    args = getProductNotificationRequestCount_args()
2899 
    args.startDateTime = startDateTime
2900 
    args.write(self._oprot)
2901 
    self._oprot.writeMessageEnd()
2902 
    self._oprot.trans.flush()
2903 
 
2904 
  def recv_getProductNotificationRequestCount(self, ):
2905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2906 
    if mtype == TMessageType.EXCEPTION:
2907 
      x = TApplicationException()
2908 
      x.read(self._iprot)
2909 
      self._iprot.readMessageEnd()
2910 
      raise x
2911 
    result = getProductNotificationRequestCount_result()
2912 
    result.read(self._iprot)
2913 
    self._iprot.readMessageEnd()
2914 
    if result.success is not None:
2915 
      return result.success
2916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2917 
 
2918 
  def addAuthorizationLog(self, itemId, username, reason):
2919 
    """
2920 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2921 
 
2922 
    Parameters:
2923 
     - itemId
2924 
     - username
2925 
     - reason
2926 
    """
2927 
    self.send_addAuthorizationLog(itemId, username, reason)
2928 
    return self.recv_addAuthorizationLog()
2929 
 
2930 
  def send_addAuthorizationLog(self, itemId, username, reason):
2931 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2932 
    args = addAuthorizationLog_args()
2933 
    args.itemId = itemId
2934 
    args.username = username
2935 
    args.reason = reason
2936 
    args.write(self._oprot)
2937 
    self._oprot.writeMessageEnd()
2938 
    self._oprot.trans.flush()
2939 
 
2940 
  def recv_addAuthorizationLog(self, ):
2941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2942 
    if mtype == TMessageType.EXCEPTION:
2943 
      x = TApplicationException()
2944 
      x.read(self._iprot)
2945 
      self._iprot.readMessageEnd()
2946 
      raise x
2947 
    result = addAuthorizationLog_result()
2948 
    result.read(self._iprot)
2949 
    self._iprot.readMessageEnd()
2950 
    if result.success is not None:
2951 
      return result.success
2952 
    if result.cex is not None:
2953 
      raise result.cex
2954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2955 
 
2956 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2957 
    """
2958 
    Parameters:
2959 
     - catalog_item_id
2960 
     - voucherType
2961 
     - voucherAmount
2962 
    """
2963 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
2964 
    return self.recv_addupdateVoucherForItem()
2965 
 
2966 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2967 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
2968 
    args = addupdateVoucherForItem_args()
2969 
    args.catalog_item_id = catalog_item_id
2970 
    args.voucherType = voucherType
2971 
    args.voucherAmount = voucherAmount
2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
2976 
  def recv_addupdateVoucherForItem(self, ):
2977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2978 
    if mtype == TMessageType.EXCEPTION:
2979 
      x = TApplicationException()
2980 
      x.read(self._iprot)
2981 
      self._iprot.readMessageEnd()
2982 
      raise x
2983 
    result = addupdateVoucherForItem_result()
2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
2986 
    if result.success is not None:
2987 
      return result.success
2988 
    if result.cex is not None:
2989 
      raise result.cex
2990 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
2991 
 
2992 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
2993 
    """
2994 
    Parameters:
2995 
     - catalog_item_id
2996 
     - voucherType
2997 
    """
2998 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
2999 
    return self.recv_deleteVoucherForItem()
3000 
 
3001 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3002 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3003 
    args = deleteVoucherForItem_args()
3004 
    args.catalog_item_id = catalog_item_id
3005 
    args.voucherType = voucherType
3006 
    args.write(self._oprot)
3007 
    self._oprot.writeMessageEnd()
3008 
    self._oprot.trans.flush()
3009 
 
3010 
  def recv_deleteVoucherForItem(self, ):
3011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3012 
    if mtype == TMessageType.EXCEPTION:
3013 
      x = TApplicationException()
3014 
      x.read(self._iprot)
3015 
      self._iprot.readMessageEnd()
3016 
      raise x
3017 
    result = deleteVoucherForItem_result()
3018 
    result.read(self._iprot)
3019 
    self._iprot.readMessageEnd()
3020 
    if result.success is not None:
3021 
      return result.success
3022 
    if result.cex is not None:
3023 
      raise result.cex
3024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3025 
 
3026 
  def getVoucherAmount(self, itemId, voucherType):
3027 
    """
3028 
    Parameters:
3029 
     - itemId
3030 
     - voucherType
3031 
    """
3032 
    self.send_getVoucherAmount(itemId, voucherType)
3033 
    return self.recv_getVoucherAmount()
3034 
 
3035 
  def send_getVoucherAmount(self, itemId, voucherType):
3036 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3037 
    args = getVoucherAmount_args()
3038 
    args.itemId = itemId
3039 
    args.voucherType = voucherType
3040 
    args.write(self._oprot)
3041 
    self._oprot.writeMessageEnd()
3042 
    self._oprot.trans.flush()
3043 
 
3044 
  def recv_getVoucherAmount(self, ):
3045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3046 
    if mtype == TMessageType.EXCEPTION:
3047 
      x = TApplicationException()
3048 
      x.read(self._iprot)
3049 
      self._iprot.readMessageEnd()
3050 
      raise x
3051 
    result = getVoucherAmount_result()
3052 
    result.read(self._iprot)
3053 
    self._iprot.readMessageEnd()
3054 
    if result.success is not None:
3055 
      return result.success
3056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3057 
 
3058 
  def getAllItemVouchers(self, itemId):
3059 
    """
3060 
    Parameters:
3061 
     - itemId
3062 
    """
3063 
    self.send_getAllItemVouchers(itemId)
3064 
    return self.recv_getAllItemVouchers()
3065 
 
3066 
  def send_getAllItemVouchers(self, itemId):
3067 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3068 
    args = getAllItemVouchers_args()
3069 
    args.itemId = itemId
3070 
    args.write(self._oprot)
3071 
    self._oprot.writeMessageEnd()
3072 
    self._oprot.trans.flush()
3073 
 
3074 
  def recv_getAllItemVouchers(self, ):
3075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3076 
    if mtype == TMessageType.EXCEPTION:
3077 
      x = TApplicationException()
3078 
      x.read(self._iprot)
3079 
      self._iprot.readMessageEnd()
3080 
      raise x
3081 
    result = getAllItemVouchers_result()
3082 
    result.read(self._iprot)
3083 
    self._iprot.readMessageEnd()
3084 
    if result.success is not None:
3085 
      return result.success
3086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3087 
 
3088 
  def isValidCatalogItemId(self, catalog_item_id):
3089 
    """
3090 
    Parameters:
3091 
     - catalog_item_id
3092 
    """
3093 
    self.send_isValidCatalogItemId(catalog_item_id)
3094 
    return self.recv_isValidCatalogItemId()
3095 
 
3096 
  def send_isValidCatalogItemId(self, catalog_item_id):
3097 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3098 
    args = isValidCatalogItemId_args()
3099 
    args.catalog_item_id = catalog_item_id
3100 
    args.write(self._oprot)
3101 
    self._oprot.writeMessageEnd()
3102 
    self._oprot.trans.flush()
3103 
 
3104 
  def recv_isValidCatalogItemId(self, ):
3105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3106 
    if mtype == TMessageType.EXCEPTION:
3107 
      x = TApplicationException()
3108 
      x.read(self._iprot)
3109 
      self._iprot.readMessageEnd()
3110 
      raise x
3111 
    result = isValidCatalogItemId_result()
3112 
    result.read(self._iprot)
3113 
    self._iprot.readMessageEnd()
3114 
    if result.success is not None:
3115 
      return result.success
3116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3117 
 
6039 amit.gupta 3118 
  def getVatPercentageForItem(self, itemId, price):
3119 
    """
3120 
    Parameters:
3121 
     - itemId
3122 
     - price
3123 
    """
3124 
    self.send_getVatPercentageForItem(itemId, price)
3125 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3126 
 
6039 amit.gupta 3127 
  def send_getVatPercentageForItem(self, itemId, price):
3128 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3129 
    args = getVatPercentageForItem_args()
3130 
    args.itemId = itemId
3131 
    args.price = price
3132 
    args.write(self._oprot)
3133 
    self._oprot.writeMessageEnd()
3134 
    self._oprot.trans.flush()
3135 
 
3136 
  def recv_getVatPercentageForItem(self, ):
3137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3138 
    if mtype == TMessageType.EXCEPTION:
3139 
      x = TApplicationException()
3140 
      x.read(self._iprot)
3141 
      self._iprot.readMessageEnd()
3142 
      raise x
3143 
    result = getVatPercentageForItem_result()
3144 
    result.read(self._iprot)
3145 
    self._iprot.readMessageEnd()
3146 
    if result.success is not None:
3147 
      return result.success
3148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3149 
 
3150 
  def getVatAmountForItem(self, itemId, price):
3151 
    """
3152 
    Parameters:
3153 
     - itemId
3154 
     - price
3155 
    """
3156 
    self.send_getVatAmountForItem(itemId, price)
3157 
    return self.recv_getVatAmountForItem()
3158 
 
3159 
  def send_getVatAmountForItem(self, itemId, price):
3160 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3161 
    args = getVatAmountForItem_args()
3162 
    args.itemId = itemId
3163 
    args.price = price
3164 
    args.write(self._oprot)
3165 
    self._oprot.writeMessageEnd()
3166 
    self._oprot.trans.flush()
3167 
 
3168 
  def recv_getVatAmountForItem(self, ):
3169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3170 
    if mtype == TMessageType.EXCEPTION:
3171 
      x = TApplicationException()
3172 
      x.read(self._iprot)
3173 
      self._iprot.readMessageEnd()
3174 
      raise x
3175 
    result = getVatAmountForItem_result()
3176 
    result.read(self._iprot)
3177 
    self._iprot.readMessageEnd()
3178 
    if result.success is not None:
3179 
      return result.success
3180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3181 
 
6531 vikram.rag 3182 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3183 
    """
3184 
    Parameters:
3185 
     - offset
3186 
     - limit
3187 
    """
3188 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3189 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3190 
 
6531 vikram.rag 3191 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3192 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3193 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3194 
    args.offset = offset
3195 
    args.limit = limit
3196 
    args.write(self._oprot)
3197 
    self._oprot.writeMessageEnd()
3198 
    self._oprot.trans.flush()
3199 
 
3200 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3202 
    if mtype == TMessageType.EXCEPTION:
3203 
      x = TApplicationException()
3204 
      x.read(self._iprot)
3205 
      self._iprot.readMessageEnd()
3206 
      raise x
3207 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3208 
    result.read(self._iprot)
3209 
    self._iprot.readMessageEnd()
3210 
    if result.success is not None:
3211 
      return result.success
3212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3213 
 
6821 amar.kumar 3214 
  def getAllAliveItems(self, ):
3215 
    self.send_getAllAliveItems()
3216 
    return self.recv_getAllAliveItems()
3217 
 
3218 
  def send_getAllAliveItems(self, ):
3219 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3220 
    args = getAllAliveItems_args()
3221 
    args.write(self._oprot)
3222 
    self._oprot.writeMessageEnd()
3223 
    self._oprot.trans.flush()
3224 
 
3225 
  def recv_getAllAliveItems(self, ):
3226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3227 
    if mtype == TMessageType.EXCEPTION:
3228 
      x = TApplicationException()
3229 
      x.read(self._iprot)
3230 
      self._iprot.readMessageEnd()
3231 
      raise x
3232 
    result = getAllAliveItems_result()
3233 
    result.read(self._iprot)
3234 
    self._iprot.readMessageEnd()
3235 
    if result.success is not None:
3236 
      return result.success
3237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3238 
 
6921 anupam.sin 3239 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3240 
    """
3241 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3242 
 
6805 anupam.sin 3243 
    Parameters:
3244 
     - itemId
6921 anupam.sin 3245 
     - price
6805 anupam.sin 3246 
     - insurerId
3247 
     - quantity
3248 
    """
6921 anupam.sin 3249 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3250 
    return self.recv_getInsuranceAmount()
3251 
 
6921 anupam.sin 3252 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3253 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3254 
    args = getInsuranceAmount_args()
3255 
    args.itemId = itemId
6921 anupam.sin 3256 
    args.price = price
6805 anupam.sin 3257 
    args.insurerId = insurerId
3258 
    args.quantity = quantity
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_getInsuranceAmount(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = getInsuranceAmount_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.success is not None:
3274 
      return result.success
3275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3276 
 
3277 
  def getInsurer(self, insurerId):
3278 
    """
3279 
    Parameters:
3280 
     - insurerId
3281 
    """
3282 
    self.send_getInsurer(insurerId)
3283 
    return self.recv_getInsurer()
3284 
 
3285 
  def send_getInsurer(self, insurerId):
3286 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3287 
    args = getInsurer_args()
3288 
    args.insurerId = insurerId
3289 
    args.write(self._oprot)
3290 
    self._oprot.writeMessageEnd()
3291 
    self._oprot.trans.flush()
3292 
 
3293 
  def recv_getInsurer(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 = getInsurer_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, "getInsurer failed: unknown result");
3306 
 
6838 vikram.rag 3307 
  def getAllInsurers(self, ):
3308 
    self.send_getAllInsurers()
3309 
    return self.recv_getAllInsurers()
6805 anupam.sin 3310 
 
6838 vikram.rag 3311 
  def send_getAllInsurers(self, ):
3312 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3313 
    args = getAllInsurers_args()
3314 
    args.write(self._oprot)
3315 
    self._oprot.writeMessageEnd()
3316 
    self._oprot.trans.flush()
3317 
 
3318 
  def recv_getAllInsurers(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 = getAllInsurers_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, "getAllInsurers failed: unknown result");
3331 
 
6962 rajveer 3332 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3333 
    """
3334 
    Parameters:
3335 
     - insurerId
3336 
     - amount
3337 
    """
3338 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3339 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3340 
 
6962 rajveer 3341 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3342 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3343 
    args = updateInsuranceDeclaredAmount_args()
3344 
    args.insurerId = insurerId
3345 
    args.amount = amount
3346 
    args.write(self._oprot)
3347 
    self._oprot.writeMessageEnd()
3348 
    self._oprot.trans.flush()
3349 
 
3350 
  def recv_updateInsuranceDeclaredAmount(self, ):
3351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3352 
    if mtype == TMessageType.EXCEPTION:
3353 
      x = TApplicationException()
3354 
      x.read(self._iprot)
3355 
      self._iprot.readMessageEnd()
3356 
      raise x
3357 
    result = updateInsuranceDeclaredAmount_result()
3358 
    result.read(self._iprot)
3359 
    self._iprot.readMessageEnd()
3360 
    return
3361 
 
7190 amar.kumar 3362 
  def getFreebieForItem(self, itemId):
3363 
    """
3364 
    Parameters:
3365 
     - itemId
3366 
    """
3367 
    self.send_getFreebieForItem(itemId)
3368 
    return self.recv_getFreebieForItem()
6962 rajveer 3369 
 
7190 amar.kumar 3370 
  def send_getFreebieForItem(self, itemId):
3371 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3372 
    args = getFreebieForItem_args()
3373 
    args.itemId = itemId
3374 
    args.write(self._oprot)
3375 
    self._oprot.writeMessageEnd()
3376 
    self._oprot.trans.flush()
3377 
 
3378 
  def recv_getFreebieForItem(self, ):
3379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3380 
    if mtype == TMessageType.EXCEPTION:
3381 
      x = TApplicationException()
3382 
      x.read(self._iprot)
3383 
      self._iprot.readMessageEnd()
3384 
      raise x
3385 
    result = getFreebieForItem_result()
3386 
    result.read(self._iprot)
3387 
    self._iprot.readMessageEnd()
3388 
    if result.success is not None:
3389 
      return result.success
3390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3391 
 
3392 
  def addOrUpdateFreebieForItem(self, freebieItem):
3393 
    """
3394 
    Parameters:
3395 
     - freebieItem
3396 
    """
3397 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3398 
    self.recv_addOrUpdateFreebieForItem()
3399 
 
3400 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3401 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3402 
    args = addOrUpdateFreebieForItem_args()
3403 
    args.freebieItem = freebieItem
3404 
    args.write(self._oprot)
3405 
    self._oprot.writeMessageEnd()
3406 
    self._oprot.trans.flush()
3407 
 
3408 
  def recv_addOrUpdateFreebieForItem(self, ):
3409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3410 
    if mtype == TMessageType.EXCEPTION:
3411 
      x = TApplicationException()
3412 
      x.read(self._iprot)
3413 
      self._iprot.readMessageEnd()
3414 
      raise x
3415 
    result = addOrUpdateFreebieForItem_result()
3416 
    result.read(self._iprot)
3417 
    self._iprot.readMessageEnd()
3418 
    return
3419 
 
7272 amit.gupta 3420 
  def addOrUpdateBrandInfo(self, brandInfo):
3421 
    """
3422 
    Parameters:
3423 
     - brandInfo
3424 
    """
3425 
    self.send_addOrUpdateBrandInfo(brandInfo)
3426 
    self.recv_addOrUpdateBrandInfo()
3427 
 
3428 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3429 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3430 
    args = addOrUpdateBrandInfo_args()
3431 
    args.brandInfo = brandInfo
3432 
    args.write(self._oprot)
3433 
    self._oprot.writeMessageEnd()
3434 
    self._oprot.trans.flush()
3435 
 
3436 
  def recv_addOrUpdateBrandInfo(self, ):
3437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3438 
    if mtype == TMessageType.EXCEPTION:
3439 
      x = TApplicationException()
3440 
      x.read(self._iprot)
3441 
      self._iprot.readMessageEnd()
3442 
      raise x
3443 
    result = addOrUpdateBrandInfo_result()
3444 
    result.read(self._iprot)
3445 
    self._iprot.readMessageEnd()
3446 
    return
3447 
 
3448 
  def getBrandInfo(self, ):
3449 
    self.send_getBrandInfo()
3450 
    return self.recv_getBrandInfo()
3451 
 
3452 
  def send_getBrandInfo(self, ):
3453 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3454 
    args = getBrandInfo_args()
3455 
    args.write(self._oprot)
3456 
    self._oprot.writeMessageEnd()
3457 
    self._oprot.trans.flush()
3458 
 
3459 
  def recv_getBrandInfo(self, ):
3460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3461 
    if mtype == TMessageType.EXCEPTION:
3462 
      x = TApplicationException()
3463 
      x.read(self._iprot)
3464 
      self._iprot.readMessageEnd()
3465 
      raise x
3466 
    result = getBrandInfo_result()
3467 
    result.read(self._iprot)
3468 
    self._iprot.readMessageEnd()
3469 
    if result.success is not None:
3470 
      return result.success
3471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3472 
 
7256 rajveer 3473 
  def getStorePricing(self, itemId):
3474 
    """
3475 
    Parameters:
3476 
     - itemId
3477 
    """
3478 
    self.send_getStorePricing(itemId)
3479 
    return self.recv_getStorePricing()
7190 amar.kumar 3480 
 
7256 rajveer 3481 
  def send_getStorePricing(self, itemId):
3482 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3483 
    args = getStorePricing_args()
3484 
    args.itemId = itemId
3485 
    args.write(self._oprot)
3486 
    self._oprot.writeMessageEnd()
3487 
    self._oprot.trans.flush()
3488 
 
3489 
  def recv_getStorePricing(self, ):
3490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3491 
    if mtype == TMessageType.EXCEPTION:
3492 
      x = TApplicationException()
3493 
      x.read(self._iprot)
3494 
      self._iprot.readMessageEnd()
3495 
      raise x
3496 
    result = getStorePricing_result()
3497 
    result.read(self._iprot)
3498 
    self._iprot.readMessageEnd()
3499 
    if result.success is not None:
3500 
      return result.success
3501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3502 
 
7306 rajveer 3503 
  def getStorePricings(self, itemIds):
3504 
    """
3505 
    Parameters:
3506 
     - itemIds
3507 
    """
3508 
    self.send_getStorePricings(itemIds)
3509 
    return self.recv_getStorePricings()
3510 
 
3511 
  def send_getStorePricings(self, itemIds):
3512 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3513 
    args = getStorePricings_args()
3514 
    args.itemIds = itemIds
3515 
    args.write(self._oprot)
3516 
    self._oprot.writeMessageEnd()
3517 
    self._oprot.trans.flush()
3518 
 
3519 
  def recv_getStorePricings(self, ):
3520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3521 
    if mtype == TMessageType.EXCEPTION:
3522 
      x = TApplicationException()
3523 
      x.read(self._iprot)
3524 
      self._iprot.readMessageEnd()
3525 
      raise x
3526 
    result = getStorePricings_result()
3527 
    result.read(self._iprot)
3528 
    self._iprot.readMessageEnd()
3529 
    if result.success is not None:
3530 
      return result.success
3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3532 
 
7265 rajveer 3533 
  def updateStorePricing(self, sp):
3534 
    """
3535 
    Parameters:
3536 
     - sp
3537 
    """
3538 
    self.send_updateStorePricing(sp)
3539 
    self.recv_updateStorePricing()
7256 rajveer 3540 
 
7265 rajveer 3541 
  def send_updateStorePricing(self, sp):
3542 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3543 
    args = updateStorePricing_args()
3544 
    args.sp = sp
3545 
    args.write(self._oprot)
3546 
    self._oprot.writeMessageEnd()
3547 
    self._oprot.trans.flush()
3548 
 
3549 
  def recv_updateStorePricing(self, ):
3550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3551 
    if mtype == TMessageType.EXCEPTION:
3552 
      x = TApplicationException()
3553 
      x.read(self._iprot)
3554 
      self._iprot.readMessageEnd()
3555 
      raise x
3556 
    result = updateStorePricing_result()
3557 
    result.read(self._iprot)
3558 
    self._iprot.readMessageEnd()
3559 
    return
3560 
 
7281 kshitij.so 3561 
  def getAllAmazonListedItems(self, ):
3562 
    self.send_getAllAmazonListedItems()
3563 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3564 
 
7281 kshitij.so 3565 
  def send_getAllAmazonListedItems(self, ):
3566 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3567 
    args = getAllAmazonListedItems_args()
3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_getAllAmazonListedItems(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = getAllAmazonListedItems_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
3582 
    if result.success is not None:
3583 
      return result.success
3584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3585 
 
3586 
  def getAmazonItemDetails(self, itemId):
3587 
    """
3588 
    Parameters:
3589 
     - itemId
3590 
    """
3591 
    self.send_getAmazonItemDetails(itemId)
3592 
    return self.recv_getAmazonItemDetails()
3593 
 
3594 
  def send_getAmazonItemDetails(self, itemId):
3595 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3596 
    args = getAmazonItemDetails_args()
3597 
    args.itemId = itemId
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_getAmazonItemDetails(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = getAmazonItemDetails_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3612 
    if result.success is not None:
3613 
      return result.success
3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3615 
 
3616 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3617 
    """
3618 
    Parameters:
3619 
     - itemId
3620 
     - fbaPrice
3621 
     - sellingPrice
3622 
     - isFba
3623 
     - isNonFba
3624 
     - isInventoryOverride
3625 
    """
3626 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride)
3627 
    self.recv_updateAmazonItemDetails()
3628 
 
3629 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3630 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3631 
    args = updateAmazonItemDetails_args()
3632 
    args.itemId = itemId
3633 
    args.fbaPrice = fbaPrice
3634 
    args.sellingPrice = sellingPrice
3635 
    args.isFba = isFba
3636 
    args.isNonFba = isNonFba
3637 
    args.isInventoryOverride = isInventoryOverride
3638 
    args.write(self._oprot)
3639 
    self._oprot.writeMessageEnd()
3640 
    self._oprot.trans.flush()
3641 
 
3642 
  def recv_updateAmazonItemDetails(self, ):
3643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3644 
    if mtype == TMessageType.EXCEPTION:
3645 
      x = TApplicationException()
3646 
      x.read(self._iprot)
3647 
      self._iprot.readMessageEnd()
3648 
      raise x
3649 
    result = updateAmazonItemDetails_result()
3650 
    result.read(self._iprot)
3651 
    self._iprot.readMessageEnd()
3652 
    return
3653 
 
3654 
  def addAmazonItem(self, amazonlisted):
3655 
    """
3656 
    Parameters:
3657 
     - amazonlisted
3658 
    """
3659 
    self.send_addAmazonItem(amazonlisted)
3660 
    self.recv_addAmazonItem()
3661 
 
3662 
  def send_addAmazonItem(self, amazonlisted):
3663 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3664 
    args = addAmazonItem_args()
3665 
    args.amazonlisted = amazonlisted
3666 
    args.write(self._oprot)
3667 
    self._oprot.writeMessageEnd()
3668 
    self._oprot.trans.flush()
3669 
 
3670 
  def recv_addAmazonItem(self, ):
3671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3672 
    if mtype == TMessageType.EXCEPTION:
3673 
      x = TApplicationException()
3674 
      x.read(self._iprot)
3675 
      self._iprot.readMessageEnd()
3676 
      raise x
3677 
    result = addAmazonItem_result()
3678 
    result.read(self._iprot)
3679 
    self._iprot.readMessageEnd()
3680 
    return
3681 
 
7291 vikram.rag 3682 
  def getAsinItems(self, ):
3683 
    self.send_getAsinItems()
3684 
    return self.recv_getAsinItems()
7281 kshitij.so 3685 
 
7291 vikram.rag 3686 
  def send_getAsinItems(self, ):
3687 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3688 
    args = getAsinItems_args()
3689 
    args.write(self._oprot)
3690 
    self._oprot.writeMessageEnd()
3691 
    self._oprot.trans.flush()
3692 
 
3693 
  def recv_getAsinItems(self, ):
3694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3695 
    if mtype == TMessageType.EXCEPTION:
3696 
      x = TApplicationException()
3697 
      x.read(self._iprot)
3698 
      self._iprot.readMessageEnd()
3699 
      raise x
3700 
    result = getAsinItems_result()
3701 
    result.read(self._iprot)
3702 
    self._iprot.readMessageEnd()
3703 
    if result.success is not None:
3704 
      return result.success
3705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3706 
 
3707 
  def getAllFbaListedItems(self, ):
3708 
    self.send_getAllFbaListedItems()
3709 
    return self.recv_getAllFbaListedItems()
3710 
 
3711 
  def send_getAllFbaListedItems(self, ):
3712 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3713 
    args = getAllFbaListedItems_args()
3714 
    args.write(self._oprot)
3715 
    self._oprot.writeMessageEnd()
3716 
    self._oprot.trans.flush()
3717 
 
3718 
  def recv_getAllFbaListedItems(self, ):
3719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3720 
    if mtype == TMessageType.EXCEPTION:
3721 
      x = TApplicationException()
3722 
      x.read(self._iprot)
3723 
      self._iprot.readMessageEnd()
3724 
      raise x
3725 
    result = getAllFbaListedItems_result()
3726 
    result.read(self._iprot)
3727 
    self._iprot.readMessageEnd()
3728 
    if result.success is not None:
3729 
      return result.success
3730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3731 
 
3732 
  def getAllNonFbaListedItems(self, ):
3733 
    self.send_getAllNonFbaListedItems()
3734 
    return self.recv_getAllNonFbaListedItems()
3735 
 
3736 
  def send_getAllNonFbaListedItems(self, ):
3737 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3738 
    args = getAllNonFbaListedItems_args()
3739 
    args.write(self._oprot)
3740 
    self._oprot.writeMessageEnd()
3741 
    self._oprot.trans.flush()
3742 
 
3743 
  def recv_getAllNonFbaListedItems(self, ):
3744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3745 
    if mtype == TMessageType.EXCEPTION:
3746 
      x = TApplicationException()
3747 
      x.read(self._iprot)
3748 
      self._iprot.readMessageEnd()
3749 
      raise x
3750 
    result = getAllNonFbaListedItems_result()
3751 
    result.read(self._iprot)
3752 
    self._iprot.readMessageEnd()
3753 
    if result.success is not None:
3754 
      return result.success
3755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3756 
 
3757 
 
5944 mandeep.dh 3758 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3759 
  def __init__(self, handler):
3760 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3761 
    self._processMap["addItem"] = Processor.process_addItem
3762 
    self._processMap["updateItem"] = Processor.process_updateItem
3763 
    self._processMap["isActive"] = Processor.process_isActive
3764 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3765 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3766 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3767 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3768 
    self._processMap["getItem"] = Processor.process_getItem
3769 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3770 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3771 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3772 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3773 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3774 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3775 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3776 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3777 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3778 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3779 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3780 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3781 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3782 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3783 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3784 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3785 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3786 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3787 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3788 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3789 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3790 
    self._processMap["addCategory"] = Processor.process_addCategory
3791 
    self._processMap["getCategory"] = Processor.process_getCategory
3792 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3793 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3794 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3795 
    self._processMap["addTag"] = Processor.process_addTag
3796 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3797 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3798 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3799 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3800 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3801 
    self._processMap["addBanner"] = Processor.process_addBanner
3802 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3803 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3804 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3805 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3806 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3807 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3808 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3809 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3810 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3811 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3812 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3813 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3814 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3815 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3816 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3817 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3818 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3819 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3820 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3821 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3822 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3823 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3824 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3825 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3826 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3827 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3828 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3829 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3830 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3831 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3832 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3833 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3834 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3835 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3836 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3837 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3838 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3839 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3840 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3841 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3842 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3843 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3844 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3845 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3846 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3847 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3848 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3849 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3850 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3851 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3852 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3853 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3854 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3855 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3856 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
5944 mandeep.dh 3857 
 
3858 
  def process(self, iprot, oprot):
3859 
    (name, type, seqid) = iprot.readMessageBegin()
3860 
    if name not in self._processMap:
3861 
      iprot.skip(TType.STRUCT)
3862 
      iprot.readMessageEnd()
3863 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3864 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3865 
      x.write(oprot)
3866 
      oprot.writeMessageEnd()
3867 
      oprot.trans.flush()
3868 
      return
3869 
    else:
3870 
      self._processMap[name](self, seqid, iprot, oprot)
3871 
    return True
3872 
 
3873 
  def process_addItem(self, seqid, iprot, oprot):
3874 
    args = addItem_args()
3875 
    args.read(iprot)
3876 
    iprot.readMessageEnd()
3877 
    result = addItem_result()
3878 
    try:
3879 
      result.success = self._handler.addItem(args.item)
3880 
    except CatalogServiceException, cex:
3881 
      result.cex = cex
3882 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3883 
    result.write(oprot)
3884 
    oprot.writeMessageEnd()
3885 
    oprot.trans.flush()
3886 
 
3887 
  def process_updateItem(self, seqid, iprot, oprot):
3888 
    args = updateItem_args()
3889 
    args.read(iprot)
3890 
    iprot.readMessageEnd()
3891 
    result = updateItem_result()
3892 
    try:
3893 
      result.success = self._handler.updateItem(args.item)
3894 
    except CatalogServiceException, cex:
3895 
      result.cex = cex
3896 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3897 
    result.write(oprot)
3898 
    oprot.writeMessageEnd()
3899 
    oprot.trans.flush()
3900 
 
3901 
  def process_isActive(self, seqid, iprot, oprot):
3902 
    args = isActive_args()
3903 
    args.read(iprot)
3904 
    iprot.readMessageEnd()
3905 
    result = isActive_result()
3906 
    try:
3907 
      result.success = self._handler.isActive(args.itemId)
3908 
    except CatalogServiceException, isex:
3909 
      result.isex = isex
3910 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3911 
    result.write(oprot)
3912 
    oprot.writeMessageEnd()
3913 
    oprot.trans.flush()
3914 
 
3915 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3916 
    args = getItemStatusDescription_args()
3917 
    args.read(iprot)
3918 
    iprot.readMessageEnd()
3919 
    result = getItemStatusDescription_result()
3920 
    try:
3921 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3922 
    except CatalogServiceException, isex:
3923 
      result.isex = isex
3924 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3925 
    result.write(oprot)
3926 
    oprot.writeMessageEnd()
3927 
    oprot.trans.flush()
3928 
 
3929 
  def process_startItemOn(self, seqid, iprot, oprot):
3930 
    args = startItemOn_args()
3931 
    args.read(iprot)
3932 
    iprot.readMessageEnd()
3933 
    result = startItemOn_result()
3934 
    try:
3935 
      self._handler.startItemOn(args.item_id, args.timestamp)
3936 
    except CatalogServiceException, cex:
3937 
      result.cex = cex
3938 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
3939 
    result.write(oprot)
3940 
    oprot.writeMessageEnd()
3941 
    oprot.trans.flush()
3942 
 
3943 
  def process_retireItemOn(self, seqid, iprot, oprot):
3944 
    args = retireItemOn_args()
3945 
    args.read(iprot)
3946 
    iprot.readMessageEnd()
3947 
    result = retireItemOn_result()
3948 
    try:
3949 
      self._handler.retireItemOn(args.item_id, args.timestamp)
3950 
    except CatalogServiceException, cex:
3951 
      result.cex = cex
3952 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
3953 
    result.write(oprot)
3954 
    oprot.writeMessageEnd()
3955 
    oprot.trans.flush()
3956 
 
3957 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3958 
    args = changeItemStatus_args()
3959 
    args.read(iprot)
3960 
    iprot.readMessageEnd()
3961 
    result = changeItemStatus_result()
3962 
    try:
3963 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
3964 
    except CatalogServiceException, cex:
3965 
      result.cex = cex
3966 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3967 
    result.write(oprot)
3968 
    oprot.writeMessageEnd()
3969 
    oprot.trans.flush()
3970 
 
3971 
  def process_getItem(self, seqid, iprot, oprot):
3972 
    args = getItem_args()
3973 
    args.read(iprot)
3974 
    iprot.readMessageEnd()
3975 
    result = getItem_result()
3976 
    try:
3977 
      result.success = self._handler.getItem(args.item_id)
3978 
    except CatalogServiceException, cex:
3979 
      result.cex = cex
3980 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
3981 
    result.write(oprot)
3982 
    oprot.writeMessageEnd()
3983 
    oprot.trans.flush()
3984 
 
3985 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
3986 
    args = getItemsByCatalogId_args()
3987 
    args.read(iprot)
3988 
    iprot.readMessageEnd()
3989 
    result = getItemsByCatalogId_result()
3990 
    try:
3991 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
3992 
    except CatalogServiceException, cex:
3993 
      result.cex = cex
3994 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
3995 
    result.write(oprot)
3996 
    oprot.writeMessageEnd()
3997 
    oprot.trans.flush()
3998 
 
3999 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4000 
    args = getValidItemsByCatalogId_args()
4001 
    args.read(iprot)
4002 
    iprot.readMessageEnd()
4003 
    result = getValidItemsByCatalogId_result()
4004 
    try:
4005 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4006 
    except CatalogServiceException, cex:
4007 
      result.cex = cex
4008 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4009 
    result.write(oprot)
4010 
    oprot.writeMessageEnd()
4011 
    oprot.trans.flush()
4012 
 
4013 
  def process_getAllItems(self, seqid, iprot, oprot):
4014 
    args = getAllItems_args()
4015 
    args.read(iprot)
4016 
    iprot.readMessageEnd()
4017 
    result = getAllItems_result()
4018 
    try:
4019 
      result.success = self._handler.getAllItems(args.isActive)
4020 
    except CatalogServiceException, cex:
4021 
      result.cex = cex
4022 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4023 
    result.write(oprot)
4024 
    oprot.writeMessageEnd()
4025 
    oprot.trans.flush()
4026 
 
4027 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4028 
    args = getAllItemsByStatus_args()
4029 
    args.read(iprot)
4030 
    iprot.readMessageEnd()
4031 
    result = getAllItemsByStatus_result()
4032 
    try:
4033 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4034 
    except CatalogServiceException, cex:
4035 
      result.cex = cex
4036 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4037 
    result.write(oprot)
4038 
    oprot.writeMessageEnd()
4039 
    oprot.trans.flush()
4040 
 
4041 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4042 
    args = markItemAsContentComplete_args()
4043 
    args.read(iprot)
4044 
    iprot.readMessageEnd()
4045 
    result = markItemAsContentComplete_result()
4046 
    try:
4047 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4048 
    except CatalogServiceException, cex:
4049 
      result.cex = cex
4050 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4051 
    result.write(oprot)
4052 
    oprot.writeMessageEnd()
4053 
    oprot.trans.flush()
4054 
 
4055 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4056 
    args = getAllItemsInRange_args()
4057 
    args.read(iprot)
4058 
    iprot.readMessageEnd()
4059 
    result = getAllItemsInRange_result()
4060 
    try:
4061 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4062 
    except CatalogServiceException, cex:
4063 
      result.cex = cex
4064 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
4068 
 
4069 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4070 
    args = getAllItemsByStatusInRange_args()
4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
4073 
    result = getAllItemsByStatusInRange_result()
4074 
    try:
4075 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4076 
    except CatalogServiceException, cex:
4077 
      result.cex = cex
4078 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
4083 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4084 
    args = getItemCountByStatus_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = getItemCountByStatus_result()
4088 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4089 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4090 
    result.write(oprot)
4091 
    oprot.writeMessageEnd()
4092 
    oprot.trans.flush()
4093 
 
4094 
  def process_getBestSellers(self, seqid, iprot, oprot):
4095 
    args = getBestSellers_args()
4096 
    args.read(iprot)
4097 
    iprot.readMessageEnd()
4098 
    result = getBestSellers_result()
4099 
    try:
4100 
      result.success = self._handler.getBestSellers()
4101 
    except CatalogServiceException, isex:
4102 
      result.isex = isex
4103 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4104 
    result.write(oprot)
4105 
    oprot.writeMessageEnd()
4106 
    oprot.trans.flush()
4107 
 
4108 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4109 
    args = getBestSellersCatalogIds_args()
4110 
    args.read(iprot)
4111 
    iprot.readMessageEnd()
4112 
    result = getBestSellersCatalogIds_result()
4113 
    try:
4114 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4115 
    except CatalogServiceException, cex:
4116 
      result.cex = cex
4117 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4118 
    result.write(oprot)
4119 
    oprot.writeMessageEnd()
4120 
    oprot.trans.flush()
4121 
 
4122 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4123 
    args = getBestSellersCount_args()
4124 
    args.read(iprot)
4125 
    iprot.readMessageEnd()
4126 
    result = getBestSellersCount_result()
4127 
    try:
4128 
      result.success = self._handler.getBestSellersCount()
4129 
    except CatalogServiceException, cex:
4130 
      result.cex = cex
4131 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4132 
    result.write(oprot)
4133 
    oprot.writeMessageEnd()
4134 
    oprot.trans.flush()
4135 
 
4136 
  def process_getBestDeals(self, seqid, iprot, oprot):
4137 
    args = getBestDeals_args()
4138 
    args.read(iprot)
4139 
    iprot.readMessageEnd()
4140 
    result = getBestDeals_result()
4141 
    try:
4142 
      result.success = self._handler.getBestDeals()
4143 
    except CatalogServiceException, isex:
4144 
      result.isex = isex
4145 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4146 
    result.write(oprot)
4147 
    oprot.writeMessageEnd()
4148 
    oprot.trans.flush()
4149 
 
4150 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4151 
    args = getBestDealsCatalogIds_args()
4152 
    args.read(iprot)
4153 
    iprot.readMessageEnd()
4154 
    result = getBestDealsCatalogIds_result()
4155 
    try:
4156 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4157 
    except CatalogServiceException, cex:
4158 
      result.cex = cex
4159 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4160 
    result.write(oprot)
4161 
    oprot.writeMessageEnd()
4162 
    oprot.trans.flush()
4163 
 
4164 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4165 
    args = getBestDealsCount_args()
4166 
    args.read(iprot)
4167 
    iprot.readMessageEnd()
4168 
    result = getBestDealsCount_result()
4169 
    try:
4170 
      result.success = self._handler.getBestDealsCount()
4171 
    except CatalogServiceException, cex:
4172 
      result.cex = cex
4173 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4174 
    result.write(oprot)
4175 
    oprot.writeMessageEnd()
4176 
    oprot.trans.flush()
4177 
 
4178 
  def process_getComingSoon(self, seqid, iprot, oprot):
4179 
    args = getComingSoon_args()
4180 
    args.read(iprot)
4181 
    iprot.readMessageEnd()
4182 
    result = getComingSoon_result()
4183 
    try:
4184 
      result.success = self._handler.getComingSoon()
4185 
    except CatalogServiceException, isex:
4186 
      result.isex = isex
4187 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4188 
    result.write(oprot)
4189 
    oprot.writeMessageEnd()
4190 
    oprot.trans.flush()
4191 
 
4192 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4193 
    args = getComingSoonCatalogIds_args()
4194 
    args.read(iprot)
4195 
    iprot.readMessageEnd()
4196 
    result = getComingSoonCatalogIds_result()
4197 
    try:
4198 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4199 
    except CatalogServiceException, cex:
4200 
      result.cex = cex
4201 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4202 
    result.write(oprot)
4203 
    oprot.writeMessageEnd()
4204 
    oprot.trans.flush()
4205 
 
4206 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4207 
    args = getComingSoonCount_args()
4208 
    args.read(iprot)
4209 
    iprot.readMessageEnd()
4210 
    result = getComingSoonCount_result()
4211 
    try:
4212 
      result.success = self._handler.getComingSoonCount()
4213 
    except CatalogServiceException, cex:
4214 
      result.cex = cex
4215 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4216 
    result.write(oprot)
4217 
    oprot.writeMessageEnd()
4218 
    oprot.trans.flush()
4219 
 
4220 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4221 
    args = getLatestArrivals_args()
4222 
    args.read(iprot)
4223 
    iprot.readMessageEnd()
4224 
    result = getLatestArrivals_result()
4225 
    try:
4226 
      result.success = self._handler.getLatestArrivals()
4227 
    except CatalogServiceException, isex:
4228 
      result.isex = isex
4229 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4230 
    result.write(oprot)
4231 
    oprot.writeMessageEnd()
4232 
    oprot.trans.flush()
4233 
 
4234 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4235 
    args = getLatestArrivalsCatalogIds_args()
4236 
    args.read(iprot)
4237 
    iprot.readMessageEnd()
4238 
    result = getLatestArrivalsCatalogIds_result()
4239 
    try:
4240 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4241 
    except CatalogServiceException, cex:
4242 
      result.cex = cex
4243 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4244 
    result.write(oprot)
4245 
    oprot.writeMessageEnd()
4246 
    oprot.trans.flush()
4247 
 
4248 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4249 
    args = getLatestArrivalsCount_args()
4250 
    args.read(iprot)
4251 
    iprot.readMessageEnd()
4252 
    result = getLatestArrivalsCount_result()
4253 
    try:
4254 
      result.success = self._handler.getLatestArrivalsCount()
4255 
    except CatalogServiceException, cex:
4256 
      result.cex = cex
4257 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4258 
    result.write(oprot)
4259 
    oprot.writeMessageEnd()
4260 
    oprot.trans.flush()
4261 
 
4262 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4263 
    args = generateNewEntityID_args()
4264 
    args.read(iprot)
4265 
    iprot.readMessageEnd()
4266 
    result = generateNewEntityID_result()
4267 
    result.success = self._handler.generateNewEntityID()
4268 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4269 
    result.write(oprot)
4270 
    oprot.writeMessageEnd()
4271 
    oprot.trans.flush()
4272 
 
4273 
  def process_addCategory(self, seqid, iprot, oprot):
4274 
    args = addCategory_args()
4275 
    args.read(iprot)
4276 
    iprot.readMessageEnd()
4277 
    result = addCategory_result()
4278 
    result.success = self._handler.addCategory(args.category)
4279 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4280 
    result.write(oprot)
4281 
    oprot.writeMessageEnd()
4282 
    oprot.trans.flush()
4283 
 
4284 
  def process_getCategory(self, seqid, iprot, oprot):
4285 
    args = getCategory_args()
4286 
    args.read(iprot)
4287 
    iprot.readMessageEnd()
4288 
    result = getCategory_result()
4289 
    result.success = self._handler.getCategory(args.id)
4290 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4291 
    result.write(oprot)
4292 
    oprot.writeMessageEnd()
4293 
    oprot.trans.flush()
4294 
 
4295 
  def process_getAllCategories(self, seqid, iprot, oprot):
4296 
    args = getAllCategories_args()
4297 
    args.read(iprot)
4298 
    iprot.readMessageEnd()
4299 
    result = getAllCategories_result()
4300 
    result.success = self._handler.getAllCategories()
4301 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4302 
    result.write(oprot)
4303 
    oprot.writeMessageEnd()
4304 
    oprot.trans.flush()
4305 
 
4306 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4307 
    args = getAllSimilarItems_args()
4308 
    args.read(iprot)
4309 
    iprot.readMessageEnd()
4310 
    result = getAllSimilarItems_result()
4311 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4312 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4313 
    result.write(oprot)
4314 
    oprot.writeMessageEnd()
4315 
    oprot.trans.flush()
4316 
 
4317 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4318 
    args = addSimilarItem_args()
4319 
    args.read(iprot)
4320 
    iprot.readMessageEnd()
4321 
    result = addSimilarItem_result()
4322 
    try:
4323 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4324 
    except CatalogServiceException, cex:
4325 
      result.cex = cex
4326 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4327 
    result.write(oprot)
4328 
    oprot.writeMessageEnd()
4329 
    oprot.trans.flush()
4330 
 
6512 kshitij.so 4331 
  def process_addTag(self, seqid, iprot, oprot):
4332 
    args = addTag_args()
4333 
    args.read(iprot)
4334 
    iprot.readMessageEnd()
4335 
    result = addTag_result()
4336 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4337 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4338 
    result.write(oprot)
4339 
    oprot.writeMessageEnd()
4340 
    oprot.trans.flush()
4341 
 
4342 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4343 
    args = deleteEntityTag_args()
4344 
    args.read(iprot)
4345 
    iprot.readMessageEnd()
4346 
    result = deleteEntityTag_result()
4347 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4348 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4349 
    result.write(oprot)
4350 
    oprot.writeMessageEnd()
4351 
    oprot.trans.flush()
4352 
 
4353 
  def process_deleteTag(self, seqid, iprot, oprot):
4354 
    args = deleteTag_args()
4355 
    args.read(iprot)
4356 
    iprot.readMessageEnd()
4357 
    result = deleteTag_result()
4358 
    result.success = self._handler.deleteTag(args.displayName)
4359 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4360 
    result.write(oprot)
4361 
    oprot.writeMessageEnd()
4362 
    oprot.trans.flush()
4363 
 
4364 
  def process_getAllTags(self, seqid, iprot, oprot):
4365 
    args = getAllTags_args()
4366 
    args.read(iprot)
4367 
    iprot.readMessageEnd()
4368 
    result = getAllTags_result()
4369 
    result.success = self._handler.getAllTags()
4370 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4371 
    result.write(oprot)
4372 
    oprot.writeMessageEnd()
4373 
    oprot.trans.flush()
4374 
 
4375 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4376 
    args = getAllEntitiesByTagName_args()
4377 
    args.read(iprot)
4378 
    iprot.readMessageEnd()
4379 
    result = getAllEntitiesByTagName_result()
4380 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4381 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4382 
    result.write(oprot)
4383 
    oprot.writeMessageEnd()
4384 
    oprot.trans.flush()
4385 
 
6845 amit.gupta 4386 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4387 
    args = getAllEntityTags_args()
4388 
    args.read(iprot)
4389 
    iprot.readMessageEnd()
4390 
    result = getAllEntityTags_result()
4391 
    result.success = self._handler.getAllEntityTags()
4392 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4393 
    result.write(oprot)
4394 
    oprot.writeMessageEnd()
4395 
    oprot.trans.flush()
4396 
 
6850 kshitij.so 4397 
  def process_addBanner(self, seqid, iprot, oprot):
4398 
    args = addBanner_args()
4399 
    args.read(iprot)
4400 
    iprot.readMessageEnd()
4401 
    result = addBanner_result()
4402 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4403 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4404 
    result.write(oprot)
4405 
    oprot.writeMessageEnd()
4406 
    oprot.trans.flush()
4407 
 
4408 
  def process_getAllBanners(self, seqid, iprot, oprot):
4409 
    args = getAllBanners_args()
4410 
    args.read(iprot)
4411 
    iprot.readMessageEnd()
4412 
    result = getAllBanners_result()
4413 
    result.success = self._handler.getAllBanners()
4414 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4415 
    result.write(oprot)
4416 
    oprot.writeMessageEnd()
4417 
    oprot.trans.flush()
4418 
 
4419 
  def process_deleteBanner(self, seqid, iprot, oprot):
4420 
    args = deleteBanner_args()
4421 
    args.read(iprot)
4422 
    iprot.readMessageEnd()
4423 
    result = deleteBanner_result()
4424 
    result.success = self._handler.deleteBanner(args.bannerName)
4425 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4426 
    result.write(oprot)
4427 
    oprot.writeMessageEnd()
4428 
    oprot.trans.flush()
4429 
 
4430 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4431 
    args = getBannerDetails_args()
4432 
    args.read(iprot)
4433 
    iprot.readMessageEnd()
4434 
    result = getBannerDetails_result()
4435 
    result.success = self._handler.getBannerDetails(args.bannerName)
4436 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4437 
    result.write(oprot)
4438 
    oprot.writeMessageEnd()
4439 
    oprot.trans.flush()
4440 
 
4441 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4442 
    args = getActiveBanners_args()
4443 
    args.read(iprot)
4444 
    iprot.readMessageEnd()
4445 
    result = getActiveBanners_result()
4446 
    result.success = self._handler.getActiveBanners()
4447 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4448 
    result.write(oprot)
4449 
    oprot.writeMessageEnd()
4450 
    oprot.trans.flush()
4451 
 
6849 kshitij.so 4452 
  def process_addBannerMap(self, seqid, iprot, oprot):
4453 
    args = addBannerMap_args()
4454 
    args.read(iprot)
4455 
    iprot.readMessageEnd()
4456 
    result = addBannerMap_result()
4457 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4458 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4459 
    result.write(oprot)
4460 
    oprot.writeMessageEnd()
4461 
    oprot.trans.flush()
4462 
 
4463 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4464 
    args = deleteBannerMap_args()
4465 
    args.read(iprot)
4466 
    iprot.readMessageEnd()
4467 
    result = deleteBannerMap_result()
4468 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4469 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4470 
    result.write(oprot)
4471 
    oprot.writeMessageEnd()
4472 
    oprot.trans.flush()
4473 
 
4474 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4475 
    args = getBannerMapDetails_args()
4476 
    args.read(iprot)
4477 
    iprot.readMessageEnd()
4478 
    result = getBannerMapDetails_result()
4479 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4480 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
4484 
 
5944 mandeep.dh 4485 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4486 
    args = deleteSimilarItem_args()
4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
4489 
    result = deleteSimilarItem_result()
4490 
    try:
4491 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4492 
    except CatalogServiceException, cex:
4493 
      result.cex = cex
4494 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
4499 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4500 
    args = checkSimilarItem_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = checkSimilarItem_result()
4504 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4505 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4506 
    result.write(oprot)
4507 
    oprot.writeMessageEnd()
4508 
    oprot.trans.flush()
4509 
 
4510 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4511 
    args = validateRiskyStatus_args()
4512 
    args.read(iprot)
4513 
    iprot.readMessageEnd()
4514 
    result = validateRiskyStatus_result()
4515 
    self._handler.validateRiskyStatus(args.itemId)
4516 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4517 
    result.write(oprot)
4518 
    oprot.writeMessageEnd()
4519 
    oprot.trans.flush()
4520 
 
4521 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4522 
    args = changeItemRiskyFlag_args()
4523 
    args.read(iprot)
4524 
    iprot.readMessageEnd()
4525 
    result = changeItemRiskyFlag_result()
4526 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4527 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4528 
    result.write(oprot)
4529 
    oprot.writeMessageEnd()
4530 
    oprot.trans.flush()
4531 
 
4532 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4533 
    args = getItemsByRiskyFlag_args()
4534 
    args.read(iprot)
4535 
    iprot.readMessageEnd()
4536 
    result = getItemsByRiskyFlag_result()
4537 
    result.success = self._handler.getItemsByRiskyFlag()
4538 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4539 
    result.write(oprot)
4540 
    oprot.writeMessageEnd()
4541 
    oprot.trans.flush()
4542 
 
4543 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4544 
    args = getItemsForMasterSheet_args()
4545 
    args.read(iprot)
4546 
    iprot.readMessageEnd()
4547 
    result = getItemsForMasterSheet_result()
4548 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4549 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4550 
    result.write(oprot)
4551 
    oprot.writeMessageEnd()
4552 
    oprot.trans.flush()
4553 
 
4554 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4555 
    args = getSimilarItemsCatalogIds_args()
4556 
    args.read(iprot)
4557 
    iprot.readMessageEnd()
4558 
    result = getSimilarItemsCatalogIds_result()
4559 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4560 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4561 
    result.write(oprot)
4562 
    oprot.writeMessageEnd()
4563 
    oprot.trans.flush()
4564 
 
4565 
  def process_addProductNotification(self, seqid, iprot, oprot):
4566 
    args = addProductNotification_args()
4567 
    args.read(iprot)
4568 
    iprot.readMessageEnd()
4569 
    result = addProductNotification_result()
4570 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4571 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4572 
    result.write(oprot)
4573 
    oprot.writeMessageEnd()
4574 
    oprot.trans.flush()
4575 
 
4576 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4577 
    args = sendProductNotifications_args()
4578 
    args.read(iprot)
4579 
    iprot.readMessageEnd()
4580 
    result = sendProductNotifications_result()
4581 
    result.success = self._handler.sendProductNotifications()
4582 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4583 
    result.write(oprot)
4584 
    oprot.writeMessageEnd()
4585 
    oprot.trans.flush()
4586 
 
4587 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4588 
    args = getAllBrandsByCategory_args()
4589 
    args.read(iprot)
4590 
    iprot.readMessageEnd()
4591 
    result = getAllBrandsByCategory_result()
4592 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4593 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4594 
    result.write(oprot)
4595 
    oprot.writeMessageEnd()
4596 
    oprot.trans.flush()
4597 
 
4598 
  def process_getAllBrands(self, seqid, iprot, oprot):
4599 
    args = getAllBrands_args()
4600 
    args.read(iprot)
4601 
    iprot.readMessageEnd()
4602 
    result = getAllBrands_result()
4603 
    result.success = self._handler.getAllBrands()
4604 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4605 
    result.write(oprot)
4606 
    oprot.writeMessageEnd()
4607 
    oprot.trans.flush()
4608 
 
4609 
  def process_getAllSources(self, seqid, iprot, oprot):
4610 
    args = getAllSources_args()
4611 
    args.read(iprot)
4612 
    iprot.readMessageEnd()
4613 
    result = getAllSources_result()
4614 
    result.success = self._handler.getAllSources()
4615 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4616 
    result.write(oprot)
4617 
    oprot.writeMessageEnd()
4618 
    oprot.trans.flush()
4619 
 
4620 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4621 
    args = getItemPricingBySource_args()
4622 
    args.read(iprot)
4623 
    iprot.readMessageEnd()
4624 
    result = getItemPricingBySource_result()
4625 
    try:
4626 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4627 
    except CatalogServiceException, cex:
4628 
      result.cex = cex
4629 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4630 
    result.write(oprot)
4631 
    oprot.writeMessageEnd()
4632 
    oprot.trans.flush()
4633 
 
4634 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4635 
    args = addSourceItemPricing_args()
4636 
    args.read(iprot)
4637 
    iprot.readMessageEnd()
4638 
    result = addSourceItemPricing_result()
4639 
    try:
4640 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4641 
    except CatalogServiceException, cex:
4642 
      result.cex = cex
4643 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4644 
    result.write(oprot)
4645 
    oprot.writeMessageEnd()
4646 
    oprot.trans.flush()
4647 
 
4648 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4649 
    args = getAllSourcePricing_args()
4650 
    args.read(iprot)
4651 
    iprot.readMessageEnd()
4652 
    result = getAllSourcePricing_result()
4653 
    try:
4654 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4655 
    except CatalogServiceException, cex:
4656 
      result.cex = cex
4657 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4658 
    result.write(oprot)
4659 
    oprot.writeMessageEnd()
4660 
    oprot.trans.flush()
4661 
 
4662 
  def process_getItemForSource(self, seqid, iprot, oprot):
4663 
    args = getItemForSource_args()
4664 
    args.read(iprot)
4665 
    iprot.readMessageEnd()
4666 
    result = getItemForSource_result()
4667 
    try:
4668 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4669 
    except CatalogServiceException, cex:
4670 
      result.cex = cex
4671 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4672 
    result.write(oprot)
4673 
    oprot.writeMessageEnd()
4674 
    oprot.trans.flush()
4675 
 
4676 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4677 
    args = searchItemsInRange_args()
4678 
    args.read(iprot)
4679 
    iprot.readMessageEnd()
4680 
    result = searchItemsInRange_result()
4681 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4682 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
4687 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4688 
    args = getSearchResultCount_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = getSearchResultCount_result()
4692 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4693 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4694 
    result.write(oprot)
4695 
    oprot.writeMessageEnd()
4696 
    oprot.trans.flush()
4697 
 
4698 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4699 
    args = getProductNotifications_args()
4700 
    args.read(iprot)
4701 
    iprot.readMessageEnd()
4702 
    result = getProductNotifications_result()
4703 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4704 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
4709 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4710 
    args = getProductNotificationRequestCount_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = getProductNotificationRequestCount_result()
4714 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4715 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
4720 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4721 
    args = addAuthorizationLog_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = addAuthorizationLog_result()
4725 
    try:
4726 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4727 
    except CatalogServiceException, cex:
4728 
      result.cex = cex
4729 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
4734 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4735 
    args = addupdateVoucherForItem_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = addupdateVoucherForItem_result()
4739 
    try:
4740 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4741 
    except CatalogServiceException, cex:
4742 
      result.cex = cex
4743 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
4748 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4749 
    args = deleteVoucherForItem_args()
4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
4752 
    result = deleteVoucherForItem_result()
4753 
    try:
4754 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4755 
    except CatalogServiceException, cex:
4756 
      result.cex = cex
4757 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4758 
    result.write(oprot)
4759 
    oprot.writeMessageEnd()
4760 
    oprot.trans.flush()
4761 
 
4762 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4763 
    args = getVoucherAmount_args()
4764 
    args.read(iprot)
4765 
    iprot.readMessageEnd()
4766 
    result = getVoucherAmount_result()
4767 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4768 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4769 
    result.write(oprot)
4770 
    oprot.writeMessageEnd()
4771 
    oprot.trans.flush()
4772 
 
4773 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4774 
    args = getAllItemVouchers_args()
4775 
    args.read(iprot)
4776 
    iprot.readMessageEnd()
4777 
    result = getAllItemVouchers_result()
4778 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4779 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4780 
    result.write(oprot)
4781 
    oprot.writeMessageEnd()
4782 
    oprot.trans.flush()
4783 
 
4784 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4785 
    args = isValidCatalogItemId_args()
4786 
    args.read(iprot)
4787 
    iprot.readMessageEnd()
4788 
    result = isValidCatalogItemId_result()
4789 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4790 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4791 
    result.write(oprot)
4792 
    oprot.writeMessageEnd()
4793 
    oprot.trans.flush()
4794 
 
6039 amit.gupta 4795 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4796 
    args = getVatPercentageForItem_args()
4797 
    args.read(iprot)
4798 
    iprot.readMessageEnd()
4799 
    result = getVatPercentageForItem_result()
4800 
    result.success = self._handler.getVatPercentageForItem(args.itemId, args.price)
4801 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4802 
    result.write(oprot)
4803 
    oprot.writeMessageEnd()
4804 
    oprot.trans.flush()
5944 mandeep.dh 4805 
 
6039 amit.gupta 4806 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4807 
    args = getVatAmountForItem_args()
4808 
    args.read(iprot)
4809 
    iprot.readMessageEnd()
4810 
    result = getVatAmountForItem_result()
4811 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4812 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4813 
    result.write(oprot)
4814 
    oprot.writeMessageEnd()
4815 
    oprot.trans.flush()
4816 
 
6531 vikram.rag 4817 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4818 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4819 
    args.read(iprot)
4820 
    iprot.readMessageEnd()
4821 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4822 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4823 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4824 
    result.write(oprot)
4825 
    oprot.writeMessageEnd()
4826 
    oprot.trans.flush()
6039 amit.gupta 4827 
 
6821 amar.kumar 4828 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4829 
    args = getAllAliveItems_args()
4830 
    args.read(iprot)
4831 
    iprot.readMessageEnd()
4832 
    result = getAllAliveItems_result()
4833 
    result.success = self._handler.getAllAliveItems()
4834 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4835 
    result.write(oprot)
4836 
    oprot.writeMessageEnd()
4837 
    oprot.trans.flush()
4838 
 
6805 anupam.sin 4839 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4840 
    args = getInsuranceAmount_args()
4841 
    args.read(iprot)
4842 
    iprot.readMessageEnd()
4843 
    result = getInsuranceAmount_result()
6921 anupam.sin 4844 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4845 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4846 
    result.write(oprot)
4847 
    oprot.writeMessageEnd()
4848 
    oprot.trans.flush()
6531 vikram.rag 4849 
 
6805 anupam.sin 4850 
  def process_getInsurer(self, seqid, iprot, oprot):
4851 
    args = getInsurer_args()
4852 
    args.read(iprot)
4853 
    iprot.readMessageEnd()
4854 
    result = getInsurer_result()
4855 
    result.success = self._handler.getInsurer(args.insurerId)
4856 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4857 
    result.write(oprot)
4858 
    oprot.writeMessageEnd()
4859 
    oprot.trans.flush()
4860 
 
6838 vikram.rag 4861 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4862 
    args = getAllInsurers_args()
4863 
    args.read(iprot)
4864 
    iprot.readMessageEnd()
4865 
    result = getAllInsurers_result()
4866 
    result.success = self._handler.getAllInsurers()
4867 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4868 
    result.write(oprot)
4869 
    oprot.writeMessageEnd()
4870 
    oprot.trans.flush()
6805 anupam.sin 4871 
 
6962 rajveer 4872 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4873 
    args = updateInsuranceDeclaredAmount_args()
4874 
    args.read(iprot)
4875 
    iprot.readMessageEnd()
4876 
    result = updateInsuranceDeclaredAmount_result()
4877 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4878 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4879 
    result.write(oprot)
4880 
    oprot.writeMessageEnd()
4881 
    oprot.trans.flush()
6838 vikram.rag 4882 
 
7190 amar.kumar 4883 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4884 
    args = getFreebieForItem_args()
4885 
    args.read(iprot)
4886 
    iprot.readMessageEnd()
4887 
    result = getFreebieForItem_result()
4888 
    result.success = self._handler.getFreebieForItem(args.itemId)
4889 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4890 
    result.write(oprot)
4891 
    oprot.writeMessageEnd()
4892 
    oprot.trans.flush()
6962 rajveer 4893 
 
7190 amar.kumar 4894 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4895 
    args = addOrUpdateFreebieForItem_args()
4896 
    args.read(iprot)
4897 
    iprot.readMessageEnd()
4898 
    result = addOrUpdateFreebieForItem_result()
4899 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4900 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4901 
    result.write(oprot)
4902 
    oprot.writeMessageEnd()
4903 
    oprot.trans.flush()
4904 
 
7272 amit.gupta 4905 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4906 
    args = addOrUpdateBrandInfo_args()
4907 
    args.read(iprot)
4908 
    iprot.readMessageEnd()
4909 
    result = addOrUpdateBrandInfo_result()
4910 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4911 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4912 
    result.write(oprot)
4913 
    oprot.writeMessageEnd()
4914 
    oprot.trans.flush()
4915 
 
4916 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4917 
    args = getBrandInfo_args()
4918 
    args.read(iprot)
4919 
    iprot.readMessageEnd()
4920 
    result = getBrandInfo_result()
4921 
    result.success = self._handler.getBrandInfo()
4922 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4923 
    result.write(oprot)
4924 
    oprot.writeMessageEnd()
4925 
    oprot.trans.flush()
4926 
 
7256 rajveer 4927 
  def process_getStorePricing(self, seqid, iprot, oprot):
4928 
    args = getStorePricing_args()
4929 
    args.read(iprot)
4930 
    iprot.readMessageEnd()
4931 
    result = getStorePricing_result()
4932 
    result.success = self._handler.getStorePricing(args.itemId)
4933 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
4934 
    result.write(oprot)
4935 
    oprot.writeMessageEnd()
4936 
    oprot.trans.flush()
7190 amar.kumar 4937 
 
7306 rajveer 4938 
  def process_getStorePricings(self, seqid, iprot, oprot):
4939 
    args = getStorePricings_args()
4940 
    args.read(iprot)
4941 
    iprot.readMessageEnd()
4942 
    result = getStorePricings_result()
4943 
    result.success = self._handler.getStorePricings(args.itemIds)
4944 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
4945 
    result.write(oprot)
4946 
    oprot.writeMessageEnd()
4947 
    oprot.trans.flush()
4948 
 
7265 rajveer 4949 
  def process_updateStorePricing(self, seqid, iprot, oprot):
4950 
    args = updateStorePricing_args()
4951 
    args.read(iprot)
4952 
    iprot.readMessageEnd()
4953 
    result = updateStorePricing_result()
4954 
    self._handler.updateStorePricing(args.sp)
4955 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
4956 
    result.write(oprot)
4957 
    oprot.writeMessageEnd()
4958 
    oprot.trans.flush()
7256 rajveer 4959 
 
7281 kshitij.so 4960 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
4961 
    args = getAllAmazonListedItems_args()
4962 
    args.read(iprot)
4963 
    iprot.readMessageEnd()
4964 
    result = getAllAmazonListedItems_result()
4965 
    result.success = self._handler.getAllAmazonListedItems()
4966 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
4967 
    result.write(oprot)
4968 
    oprot.writeMessageEnd()
4969 
    oprot.trans.flush()
7265 rajveer 4970 
 
7281 kshitij.so 4971 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
4972 
    args = getAmazonItemDetails_args()
4973 
    args.read(iprot)
4974 
    iprot.readMessageEnd()
4975 
    result = getAmazonItemDetails_result()
4976 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
4977 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
4978 
    result.write(oprot)
4979 
    oprot.writeMessageEnd()
4980 
    oprot.trans.flush()
4981 
 
4982 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
4983 
    args = updateAmazonItemDetails_args()
4984 
    args.read(iprot)
4985 
    iprot.readMessageEnd()
4986 
    result = updateAmazonItemDetails_result()
4987 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride)
4988 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
4989 
    result.write(oprot)
4990 
    oprot.writeMessageEnd()
4991 
    oprot.trans.flush()
4992 
 
4993 
  def process_addAmazonItem(self, seqid, iprot, oprot):
4994 
    args = addAmazonItem_args()
4995 
    args.read(iprot)
4996 
    iprot.readMessageEnd()
4997 
    result = addAmazonItem_result()
4998 
    self._handler.addAmazonItem(args.amazonlisted)
4999 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5000 
    result.write(oprot)
5001 
    oprot.writeMessageEnd()
5002 
    oprot.trans.flush()
5003 
 
7291 vikram.rag 5004 
  def process_getAsinItems(self, seqid, iprot, oprot):
5005 
    args = getAsinItems_args()
5006 
    args.read(iprot)
5007 
    iprot.readMessageEnd()
5008 
    result = getAsinItems_result()
5009 
    result.success = self._handler.getAsinItems()
5010 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5011 
    result.write(oprot)
5012 
    oprot.writeMessageEnd()
5013 
    oprot.trans.flush()
7281 kshitij.so 5014 
 
7291 vikram.rag 5015 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5016 
    args = getAllFbaListedItems_args()
5017 
    args.read(iprot)
5018 
    iprot.readMessageEnd()
5019 
    result = getAllFbaListedItems_result()
5020 
    result.success = self._handler.getAllFbaListedItems()
5021 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5022 
    result.write(oprot)
5023 
    oprot.writeMessageEnd()
5024 
    oprot.trans.flush()
5025 
 
5026 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5027 
    args = getAllNonFbaListedItems_args()
5028 
    args.read(iprot)
5029 
    iprot.readMessageEnd()
5030 
    result = getAllNonFbaListedItems_result()
5031 
    result.success = self._handler.getAllNonFbaListedItems()
5032 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5033 
    result.write(oprot)
5034 
    oprot.writeMessageEnd()
5035 
    oprot.trans.flush()
5036 
 
5037 
 
5944 mandeep.dh 5038 
# HELPER FUNCTIONS AND STRUCTURES
5039 
 
5040 
class addItem_args:
5041 
  """
5042 
  Attributes:
5043 
   - item
5044 
  """
5045 
 
5046 
  thrift_spec = (
5047 
    None, # 0
5048 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5049 
  )
5050 
 
5051 
  def __init__(self, item=None,):
5052 
    self.item = item
5053 
 
5054 
  def read(self, iprot):
5055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5057 
      return
5058 
    iprot.readStructBegin()
5059 
    while True:
5060 
      (fname, ftype, fid) = iprot.readFieldBegin()
5061 
      if ftype == TType.STOP:
5062 
        break
5063 
      if fid == 1:
5064 
        if ftype == TType.STRUCT:
5065 
          self.item = Item()
5066 
          self.item.read(iprot)
5067 
        else:
5068 
          iprot.skip(ftype)
5069 
      else:
5070 
        iprot.skip(ftype)
5071 
      iprot.readFieldEnd()
5072 
    iprot.readStructEnd()
5073 
 
5074 
  def write(self, oprot):
5075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5077 
      return
5078 
    oprot.writeStructBegin('addItem_args')
5079 
    if self.item is not None:
5080 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5081 
      self.item.write(oprot)
5082 
      oprot.writeFieldEnd()
5083 
    oprot.writeFieldStop()
5084 
    oprot.writeStructEnd()
5085 
 
5086 
  def validate(self):
5087 
    return
5088 
 
5089 
 
5090 
  def __repr__(self):
5091 
    L = ['%s=%r' % (key, value)
5092 
      for key, value in self.__dict__.iteritems()]
5093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5094 
 
5095 
  def __eq__(self, other):
5096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5097 
 
5098 
  def __ne__(self, other):
5099 
    return not (self == other)
5100 
 
5101 
class addItem_result:
5102 
  """
5103 
  Attributes:
5104 
   - success
5105 
   - cex
5106 
  """
5107 
 
5108 
  thrift_spec = (
5109 
    (0, TType.I64, 'success', None, None, ), # 0
5110 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5111 
  )
5112 
 
5113 
  def __init__(self, success=None, cex=None,):
5114 
    self.success = success
5115 
    self.cex = cex
5116 
 
5117 
  def read(self, iprot):
5118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5120 
      return
5121 
    iprot.readStructBegin()
5122 
    while True:
5123 
      (fname, ftype, fid) = iprot.readFieldBegin()
5124 
      if ftype == TType.STOP:
5125 
        break
5126 
      if fid == 0:
5127 
        if ftype == TType.I64:
5128 
          self.success = iprot.readI64();
5129 
        else:
5130 
          iprot.skip(ftype)
5131 
      elif fid == 1:
5132 
        if ftype == TType.STRUCT:
5133 
          self.cex = CatalogServiceException()
5134 
          self.cex.read(iprot)
5135 
        else:
5136 
          iprot.skip(ftype)
5137 
      else:
5138 
        iprot.skip(ftype)
5139 
      iprot.readFieldEnd()
5140 
    iprot.readStructEnd()
5141 
 
5142 
  def write(self, oprot):
5143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5145 
      return
5146 
    oprot.writeStructBegin('addItem_result')
5147 
    if self.success is not None:
5148 
      oprot.writeFieldBegin('success', TType.I64, 0)
5149 
      oprot.writeI64(self.success)
5150 
      oprot.writeFieldEnd()
5151 
    if self.cex is not None:
5152 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5153 
      self.cex.write(oprot)
5154 
      oprot.writeFieldEnd()
5155 
    oprot.writeFieldStop()
5156 
    oprot.writeStructEnd()
5157 
 
5158 
  def validate(self):
5159 
    return
5160 
 
5161 
 
5162 
  def __repr__(self):
5163 
    L = ['%s=%r' % (key, value)
5164 
      for key, value in self.__dict__.iteritems()]
5165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5166 
 
5167 
  def __eq__(self, other):
5168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5169 
 
5170 
  def __ne__(self, other):
5171 
    return not (self == other)
5172 
 
5173 
class updateItem_args:
5174 
  """
5175 
  Attributes:
5176 
   - item
5177 
  """
5178 
 
5179 
  thrift_spec = (
5180 
    None, # 0
5181 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5182 
  )
5183 
 
5184 
  def __init__(self, item=None,):
5185 
    self.item = item
5186 
 
5187 
  def read(self, iprot):
5188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5190 
      return
5191 
    iprot.readStructBegin()
5192 
    while True:
5193 
      (fname, ftype, fid) = iprot.readFieldBegin()
5194 
      if ftype == TType.STOP:
5195 
        break
5196 
      if fid == 1:
5197 
        if ftype == TType.STRUCT:
5198 
          self.item = Item()
5199 
          self.item.read(iprot)
5200 
        else:
5201 
          iprot.skip(ftype)
5202 
      else:
5203 
        iprot.skip(ftype)
5204 
      iprot.readFieldEnd()
5205 
    iprot.readStructEnd()
5206 
 
5207 
  def write(self, oprot):
5208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5210 
      return
5211 
    oprot.writeStructBegin('updateItem_args')
5212 
    if self.item is not None:
5213 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5214 
      self.item.write(oprot)
5215 
      oprot.writeFieldEnd()
5216 
    oprot.writeFieldStop()
5217 
    oprot.writeStructEnd()
5218 
 
5219 
  def validate(self):
5220 
    return
5221 
 
5222 
 
5223 
  def __repr__(self):
5224 
    L = ['%s=%r' % (key, value)
5225 
      for key, value in self.__dict__.iteritems()]
5226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5227 
 
5228 
  def __eq__(self, other):
5229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5230 
 
5231 
  def __ne__(self, other):
5232 
    return not (self == other)
5233 
 
5234 
class updateItem_result:
5235 
  """
5236 
  Attributes:
5237 
   - success
5238 
   - cex
5239 
  """
5240 
 
5241 
  thrift_spec = (
5242 
    (0, TType.I64, 'success', None, None, ), # 0
5243 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5244 
  )
5245 
 
5246 
  def __init__(self, success=None, cex=None,):
5247 
    self.success = success
5248 
    self.cex = cex
5249 
 
5250 
  def read(self, iprot):
5251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5253 
      return
5254 
    iprot.readStructBegin()
5255 
    while True:
5256 
      (fname, ftype, fid) = iprot.readFieldBegin()
5257 
      if ftype == TType.STOP:
5258 
        break
5259 
      if fid == 0:
5260 
        if ftype == TType.I64:
5261 
          self.success = iprot.readI64();
5262 
        else:
5263 
          iprot.skip(ftype)
5264 
      elif fid == 1:
5265 
        if ftype == TType.STRUCT:
5266 
          self.cex = CatalogServiceException()
5267 
          self.cex.read(iprot)
5268 
        else:
5269 
          iprot.skip(ftype)
5270 
      else:
5271 
        iprot.skip(ftype)
5272 
      iprot.readFieldEnd()
5273 
    iprot.readStructEnd()
5274 
 
5275 
  def write(self, oprot):
5276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5278 
      return
5279 
    oprot.writeStructBegin('updateItem_result')
5280 
    if self.success is not None:
5281 
      oprot.writeFieldBegin('success', TType.I64, 0)
5282 
      oprot.writeI64(self.success)
5283 
      oprot.writeFieldEnd()
5284 
    if self.cex is not None:
5285 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5286 
      self.cex.write(oprot)
5287 
      oprot.writeFieldEnd()
5288 
    oprot.writeFieldStop()
5289 
    oprot.writeStructEnd()
5290 
 
5291 
  def validate(self):
5292 
    return
5293 
 
5294 
 
5295 
  def __repr__(self):
5296 
    L = ['%s=%r' % (key, value)
5297 
      for key, value in self.__dict__.iteritems()]
5298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5299 
 
5300 
  def __eq__(self, other):
5301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5302 
 
5303 
  def __ne__(self, other):
5304 
    return not (self == other)
5305 
 
5306 
class isActive_args:
5307 
  """
5308 
  Attributes:
5309 
   - itemId
5310 
  """
5311 
 
5312 
  thrift_spec = (
5313 
    None, # 0
5314 
    (1, TType.I64, 'itemId', None, None, ), # 1
5315 
  )
5316 
 
5317 
  def __init__(self, itemId=None,):
5318 
    self.itemId = itemId
5319 
 
5320 
  def read(self, iprot):
5321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5323 
      return
5324 
    iprot.readStructBegin()
5325 
    while True:
5326 
      (fname, ftype, fid) = iprot.readFieldBegin()
5327 
      if ftype == TType.STOP:
5328 
        break
5329 
      if fid == 1:
5330 
        if ftype == TType.I64:
5331 
          self.itemId = iprot.readI64();
5332 
        else:
5333 
          iprot.skip(ftype)
5334 
      else:
5335 
        iprot.skip(ftype)
5336 
      iprot.readFieldEnd()
5337 
    iprot.readStructEnd()
5338 
 
5339 
  def write(self, oprot):
5340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5342 
      return
5343 
    oprot.writeStructBegin('isActive_args')
5344 
    if self.itemId is not None:
5345 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5346 
      oprot.writeI64(self.itemId)
5347 
      oprot.writeFieldEnd()
5348 
    oprot.writeFieldStop()
5349 
    oprot.writeStructEnd()
5350 
 
5351 
  def validate(self):
5352 
    return
5353 
 
5354 
 
5355 
  def __repr__(self):
5356 
    L = ['%s=%r' % (key, value)
5357 
      for key, value in self.__dict__.iteritems()]
5358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5359 
 
5360 
  def __eq__(self, other):
5361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5362 
 
5363 
  def __ne__(self, other):
5364 
    return not (self == other)
5365 
 
5366 
class isActive_result:
5367 
  """
5368 
  Attributes:
5369 
   - success
5370 
   - isex
5371 
  """
5372 
 
5373 
  thrift_spec = (
5374 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5375 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5376 
  )
5377 
 
5378 
  def __init__(self, success=None, isex=None,):
5379 
    self.success = success
5380 
    self.isex = isex
5381 
 
5382 
  def read(self, iprot):
5383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5385 
      return
5386 
    iprot.readStructBegin()
5387 
    while True:
5388 
      (fname, ftype, fid) = iprot.readFieldBegin()
5389 
      if ftype == TType.STOP:
5390 
        break
5391 
      if fid == 0:
5392 
        if ftype == TType.STRUCT:
5393 
          self.success = ItemShippingInfo()
5394 
          self.success.read(iprot)
5395 
        else:
5396 
          iprot.skip(ftype)
5397 
      elif fid == 1:
5398 
        if ftype == TType.STRUCT:
5399 
          self.isex = CatalogServiceException()
5400 
          self.isex.read(iprot)
5401 
        else:
5402 
          iprot.skip(ftype)
5403 
      else:
5404 
        iprot.skip(ftype)
5405 
      iprot.readFieldEnd()
5406 
    iprot.readStructEnd()
5407 
 
5408 
  def write(self, oprot):
5409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5411 
      return
5412 
    oprot.writeStructBegin('isActive_result')
5413 
    if self.success is not None:
5414 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5415 
      self.success.write(oprot)
5416 
      oprot.writeFieldEnd()
5417 
    if self.isex is not None:
5418 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5419 
      self.isex.write(oprot)
5420 
      oprot.writeFieldEnd()
5421 
    oprot.writeFieldStop()
5422 
    oprot.writeStructEnd()
5423 
 
5424 
  def validate(self):
5425 
    return
5426 
 
5427 
 
5428 
  def __repr__(self):
5429 
    L = ['%s=%r' % (key, value)
5430 
      for key, value in self.__dict__.iteritems()]
5431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5432 
 
5433 
  def __eq__(self, other):
5434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5435 
 
5436 
  def __ne__(self, other):
5437 
    return not (self == other)
5438 
 
5439 
class getItemStatusDescription_args:
5440 
  """
5441 
  Attributes:
5442 
   - itemId
5443 
  """
5444 
 
5445 
  thrift_spec = (
5446 
    None, # 0
5447 
    (1, TType.I64, 'itemId', None, None, ), # 1
5448 
  )
5449 
 
5450 
  def __init__(self, itemId=None,):
5451 
    self.itemId = itemId
5452 
 
5453 
  def read(self, iprot):
5454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5456 
      return
5457 
    iprot.readStructBegin()
5458 
    while True:
5459 
      (fname, ftype, fid) = iprot.readFieldBegin()
5460 
      if ftype == TType.STOP:
5461 
        break
5462 
      if fid == 1:
5463 
        if ftype == TType.I64:
5464 
          self.itemId = iprot.readI64();
5465 
        else:
5466 
          iprot.skip(ftype)
5467 
      else:
5468 
        iprot.skip(ftype)
5469 
      iprot.readFieldEnd()
5470 
    iprot.readStructEnd()
5471 
 
5472 
  def write(self, oprot):
5473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5475 
      return
5476 
    oprot.writeStructBegin('getItemStatusDescription_args')
5477 
    if self.itemId is not None:
5478 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5479 
      oprot.writeI64(self.itemId)
5480 
      oprot.writeFieldEnd()
5481 
    oprot.writeFieldStop()
5482 
    oprot.writeStructEnd()
5483 
 
5484 
  def validate(self):
5485 
    return
5486 
 
5487 
 
5488 
  def __repr__(self):
5489 
    L = ['%s=%r' % (key, value)
5490 
      for key, value in self.__dict__.iteritems()]
5491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5492 
 
5493 
  def __eq__(self, other):
5494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5495 
 
5496 
  def __ne__(self, other):
5497 
    return not (self == other)
5498 
 
5499 
class getItemStatusDescription_result:
5500 
  """
5501 
  Attributes:
5502 
   - success
5503 
   - isex
5504 
  """
5505 
 
5506 
  thrift_spec = (
5507 
    (0, TType.STRING, 'success', None, None, ), # 0
5508 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5509 
  )
5510 
 
5511 
  def __init__(self, success=None, isex=None,):
5512 
    self.success = success
5513 
    self.isex = isex
5514 
 
5515 
  def read(self, iprot):
5516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5518 
      return
5519 
    iprot.readStructBegin()
5520 
    while True:
5521 
      (fname, ftype, fid) = iprot.readFieldBegin()
5522 
      if ftype == TType.STOP:
5523 
        break
5524 
      if fid == 0:
5525 
        if ftype == TType.STRING:
5526 
          self.success = iprot.readString();
5527 
        else:
5528 
          iprot.skip(ftype)
5529 
      elif fid == 1:
5530 
        if ftype == TType.STRUCT:
5531 
          self.isex = CatalogServiceException()
5532 
          self.isex.read(iprot)
5533 
        else:
5534 
          iprot.skip(ftype)
5535 
      else:
5536 
        iprot.skip(ftype)
5537 
      iprot.readFieldEnd()
5538 
    iprot.readStructEnd()
5539 
 
5540 
  def write(self, oprot):
5541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5543 
      return
5544 
    oprot.writeStructBegin('getItemStatusDescription_result')
5545 
    if self.success is not None:
5546 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5547 
      oprot.writeString(self.success)
5548 
      oprot.writeFieldEnd()
5549 
    if self.isex is not None:
5550 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5551 
      self.isex.write(oprot)
5552 
      oprot.writeFieldEnd()
5553 
    oprot.writeFieldStop()
5554 
    oprot.writeStructEnd()
5555 
 
5556 
  def validate(self):
5557 
    return
5558 
 
5559 
 
5560 
  def __repr__(self):
5561 
    L = ['%s=%r' % (key, value)
5562 
      for key, value in self.__dict__.iteritems()]
5563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5564 
 
5565 
  def __eq__(self, other):
5566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5567 
 
5568 
  def __ne__(self, other):
5569 
    return not (self == other)
5570 
 
5571 
class startItemOn_args:
5572 
  """
5573 
  Attributes:
5574 
   - item_id
5575 
   - timestamp
5576 
  """
5577 
 
5578 
  thrift_spec = (
5579 
    None, # 0
5580 
    (1, TType.I64, 'item_id', None, None, ), # 1
5581 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5582 
  )
5583 
 
5584 
  def __init__(self, item_id=None, timestamp=None,):
5585 
    self.item_id = item_id
5586 
    self.timestamp = timestamp
5587 
 
5588 
  def read(self, iprot):
5589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5591 
      return
5592 
    iprot.readStructBegin()
5593 
    while True:
5594 
      (fname, ftype, fid) = iprot.readFieldBegin()
5595 
      if ftype == TType.STOP:
5596 
        break
5597 
      if fid == 1:
5598 
        if ftype == TType.I64:
5599 
          self.item_id = iprot.readI64();
5600 
        else:
5601 
          iprot.skip(ftype)
5602 
      elif fid == 2:
5603 
        if ftype == TType.I64:
5604 
          self.timestamp = iprot.readI64();
5605 
        else:
5606 
          iprot.skip(ftype)
5607 
      else:
5608 
        iprot.skip(ftype)
5609 
      iprot.readFieldEnd()
5610 
    iprot.readStructEnd()
5611 
 
5612 
  def write(self, oprot):
5613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5615 
      return
5616 
    oprot.writeStructBegin('startItemOn_args')
5617 
    if self.item_id is not None:
5618 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5619 
      oprot.writeI64(self.item_id)
5620 
      oprot.writeFieldEnd()
5621 
    if self.timestamp is not None:
5622 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5623 
      oprot.writeI64(self.timestamp)
5624 
      oprot.writeFieldEnd()
5625 
    oprot.writeFieldStop()
5626 
    oprot.writeStructEnd()
5627 
 
5628 
  def validate(self):
5629 
    return
5630 
 
5631 
 
5632 
  def __repr__(self):
5633 
    L = ['%s=%r' % (key, value)
5634 
      for key, value in self.__dict__.iteritems()]
5635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5636 
 
5637 
  def __eq__(self, other):
5638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5639 
 
5640 
  def __ne__(self, other):
5641 
    return not (self == other)
5642 
 
5643 
class startItemOn_result:
5644 
  """
5645 
  Attributes:
5646 
   - cex
5647 
  """
5648 
 
5649 
  thrift_spec = (
5650 
    None, # 0
5651 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5652 
  )
5653 
 
5654 
  def __init__(self, cex=None,):
5655 
    self.cex = cex
5656 
 
5657 
  def read(self, iprot):
5658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5660 
      return
5661 
    iprot.readStructBegin()
5662 
    while True:
5663 
      (fname, ftype, fid) = iprot.readFieldBegin()
5664 
      if ftype == TType.STOP:
5665 
        break
5666 
      if fid == 1:
5667 
        if ftype == TType.STRUCT:
5668 
          self.cex = CatalogServiceException()
5669 
          self.cex.read(iprot)
5670 
        else:
5671 
          iprot.skip(ftype)
5672 
      else:
5673 
        iprot.skip(ftype)
5674 
      iprot.readFieldEnd()
5675 
    iprot.readStructEnd()
5676 
 
5677 
  def write(self, oprot):
5678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5680 
      return
5681 
    oprot.writeStructBegin('startItemOn_result')
5682 
    if self.cex is not None:
5683 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5684 
      self.cex.write(oprot)
5685 
      oprot.writeFieldEnd()
5686 
    oprot.writeFieldStop()
5687 
    oprot.writeStructEnd()
5688 
 
5689 
  def validate(self):
5690 
    return
5691 
 
5692 
 
5693 
  def __repr__(self):
5694 
    L = ['%s=%r' % (key, value)
5695 
      for key, value in self.__dict__.iteritems()]
5696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5697 
 
5698 
  def __eq__(self, other):
5699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5700 
 
5701 
  def __ne__(self, other):
5702 
    return not (self == other)
5703 
 
5704 
class retireItemOn_args:
5705 
  """
5706 
  Attributes:
5707 
   - item_id
5708 
   - timestamp
5709 
  """
5710 
 
5711 
  thrift_spec = (
5712 
    None, # 0
5713 
    (1, TType.I64, 'item_id', None, None, ), # 1
5714 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5715 
  )
5716 
 
5717 
  def __init__(self, item_id=None, timestamp=None,):
5718 
    self.item_id = item_id
5719 
    self.timestamp = timestamp
5720 
 
5721 
  def read(self, iprot):
5722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5724 
      return
5725 
    iprot.readStructBegin()
5726 
    while True:
5727 
      (fname, ftype, fid) = iprot.readFieldBegin()
5728 
      if ftype == TType.STOP:
5729 
        break
5730 
      if fid == 1:
5731 
        if ftype == TType.I64:
5732 
          self.item_id = iprot.readI64();
5733 
        else:
5734 
          iprot.skip(ftype)
5735 
      elif fid == 2:
5736 
        if ftype == TType.I64:
5737 
          self.timestamp = iprot.readI64();
5738 
        else:
5739 
          iprot.skip(ftype)
5740 
      else:
5741 
        iprot.skip(ftype)
5742 
      iprot.readFieldEnd()
5743 
    iprot.readStructEnd()
5744 
 
5745 
  def write(self, oprot):
5746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5748 
      return
5749 
    oprot.writeStructBegin('retireItemOn_args')
5750 
    if self.item_id is not None:
5751 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5752 
      oprot.writeI64(self.item_id)
5753 
      oprot.writeFieldEnd()
5754 
    if self.timestamp is not None:
5755 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5756 
      oprot.writeI64(self.timestamp)
5757 
      oprot.writeFieldEnd()
5758 
    oprot.writeFieldStop()
5759 
    oprot.writeStructEnd()
5760 
 
5761 
  def validate(self):
5762 
    return
5763 
 
5764 
 
5765 
  def __repr__(self):
5766 
    L = ['%s=%r' % (key, value)
5767 
      for key, value in self.__dict__.iteritems()]
5768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5769 
 
5770 
  def __eq__(self, other):
5771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5772 
 
5773 
  def __ne__(self, other):
5774 
    return not (self == other)
5775 
 
5776 
class retireItemOn_result:
5777 
  """
5778 
  Attributes:
5779 
   - cex
5780 
  """
5781 
 
5782 
  thrift_spec = (
5783 
    None, # 0
5784 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5785 
  )
5786 
 
5787 
  def __init__(self, cex=None,):
5788 
    self.cex = cex
5789 
 
5790 
  def read(self, iprot):
5791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5793 
      return
5794 
    iprot.readStructBegin()
5795 
    while True:
5796 
      (fname, ftype, fid) = iprot.readFieldBegin()
5797 
      if ftype == TType.STOP:
5798 
        break
5799 
      if fid == 1:
5800 
        if ftype == TType.STRUCT:
5801 
          self.cex = CatalogServiceException()
5802 
          self.cex.read(iprot)
5803 
        else:
5804 
          iprot.skip(ftype)
5805 
      else:
5806 
        iprot.skip(ftype)
5807 
      iprot.readFieldEnd()
5808 
    iprot.readStructEnd()
5809 
 
5810 
  def write(self, oprot):
5811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5813 
      return
5814 
    oprot.writeStructBegin('retireItemOn_result')
5815 
    if self.cex is not None:
5816 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5817 
      self.cex.write(oprot)
5818 
      oprot.writeFieldEnd()
5819 
    oprot.writeFieldStop()
5820 
    oprot.writeStructEnd()
5821 
 
5822 
  def validate(self):
5823 
    return
5824 
 
5825 
 
5826 
  def __repr__(self):
5827 
    L = ['%s=%r' % (key, value)
5828 
      for key, value in self.__dict__.iteritems()]
5829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5830 
 
5831 
  def __eq__(self, other):
5832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5833 
 
5834 
  def __ne__(self, other):
5835 
    return not (self == other)
5836 
 
5837 
class changeItemStatus_args:
5838 
  """
5839 
  Attributes:
5840 
   - item_id
5841 
   - timestamp
5842 
   - newstatus
5843 
  """
5844 
 
5845 
  thrift_spec = (
5846 
    None, # 0
5847 
    (1, TType.I64, 'item_id', None, None, ), # 1
5848 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5849 
    (3, TType.I32, 'newstatus', None, None, ), # 3
5850 
  )
5851 
 
5852 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
5853 
    self.item_id = item_id
5854 
    self.timestamp = timestamp
5855 
    self.newstatus = newstatus
5856 
 
5857 
  def read(self, iprot):
5858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5860 
      return
5861 
    iprot.readStructBegin()
5862 
    while True:
5863 
      (fname, ftype, fid) = iprot.readFieldBegin()
5864 
      if ftype == TType.STOP:
5865 
        break
5866 
      if fid == 1:
5867 
        if ftype == TType.I64:
5868 
          self.item_id = iprot.readI64();
5869 
        else:
5870 
          iprot.skip(ftype)
5871 
      elif fid == 2:
5872 
        if ftype == TType.I64:
5873 
          self.timestamp = iprot.readI64();
5874 
        else:
5875 
          iprot.skip(ftype)
5876 
      elif fid == 3:
5877 
        if ftype == TType.I32:
5878 
          self.newstatus = iprot.readI32();
5879 
        else:
5880 
          iprot.skip(ftype)
5881 
      else:
5882 
        iprot.skip(ftype)
5883 
      iprot.readFieldEnd()
5884 
    iprot.readStructEnd()
5885 
 
5886 
  def write(self, oprot):
5887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5889 
      return
5890 
    oprot.writeStructBegin('changeItemStatus_args')
5891 
    if self.item_id is not None:
5892 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5893 
      oprot.writeI64(self.item_id)
5894 
      oprot.writeFieldEnd()
5895 
    if self.timestamp is not None:
5896 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5897 
      oprot.writeI64(self.timestamp)
5898 
      oprot.writeFieldEnd()
5899 
    if self.newstatus is not None:
5900 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
5901 
      oprot.writeI32(self.newstatus)
5902 
      oprot.writeFieldEnd()
5903 
    oprot.writeFieldStop()
5904 
    oprot.writeStructEnd()
5905 
 
5906 
  def validate(self):
5907 
    return
5908 
 
5909 
 
5910 
  def __repr__(self):
5911 
    L = ['%s=%r' % (key, value)
5912 
      for key, value in self.__dict__.iteritems()]
5913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5914 
 
5915 
  def __eq__(self, other):
5916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5917 
 
5918 
  def __ne__(self, other):
5919 
    return not (self == other)
5920 
 
5921 
class changeItemStatus_result:
5922 
  """
5923 
  Attributes:
5924 
   - cex
5925 
  """
5926 
 
5927 
  thrift_spec = (
5928 
    None, # 0
5929 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5930 
  )
5931 
 
5932 
  def __init__(self, cex=None,):
5933 
    self.cex = cex
5934 
 
5935 
  def read(self, iprot):
5936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5938 
      return
5939 
    iprot.readStructBegin()
5940 
    while True:
5941 
      (fname, ftype, fid) = iprot.readFieldBegin()
5942 
      if ftype == TType.STOP:
5943 
        break
5944 
      if fid == 1:
5945 
        if ftype == TType.STRUCT:
5946 
          self.cex = CatalogServiceException()
5947 
          self.cex.read(iprot)
5948 
        else:
5949 
          iprot.skip(ftype)
5950 
      else:
5951 
        iprot.skip(ftype)
5952 
      iprot.readFieldEnd()
5953 
    iprot.readStructEnd()
5954 
 
5955 
  def write(self, oprot):
5956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5958 
      return
5959 
    oprot.writeStructBegin('changeItemStatus_result')
5960 
    if self.cex is not None:
5961 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5962 
      self.cex.write(oprot)
5963 
      oprot.writeFieldEnd()
5964 
    oprot.writeFieldStop()
5965 
    oprot.writeStructEnd()
5966 
 
5967 
  def validate(self):
5968 
    return
5969 
 
5970 
 
5971 
  def __repr__(self):
5972 
    L = ['%s=%r' % (key, value)
5973 
      for key, value in self.__dict__.iteritems()]
5974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5975 
 
5976 
  def __eq__(self, other):
5977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5978 
 
5979 
  def __ne__(self, other):
5980 
    return not (self == other)
5981 
 
5982 
class getItem_args:
5983 
  """
5984 
  Attributes:
5985 
   - item_id
5986 
  """
5987 
 
5988 
  thrift_spec = (
5989 
    None, # 0
5990 
    (1, TType.I64, 'item_id', None, None, ), # 1
5991 
  )
5992 
 
5993 
  def __init__(self, item_id=None,):
5994 
    self.item_id = item_id
5995 
 
5996 
  def read(self, iprot):
5997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5999 
      return
6000 
    iprot.readStructBegin()
6001 
    while True:
6002 
      (fname, ftype, fid) = iprot.readFieldBegin()
6003 
      if ftype == TType.STOP:
6004 
        break
6005 
      if fid == 1:
6006 
        if ftype == TType.I64:
6007 
          self.item_id = iprot.readI64();
6008 
        else:
6009 
          iprot.skip(ftype)
6010 
      else:
6011 
        iprot.skip(ftype)
6012 
      iprot.readFieldEnd()
6013 
    iprot.readStructEnd()
6014 
 
6015 
  def write(self, oprot):
6016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6018 
      return
6019 
    oprot.writeStructBegin('getItem_args')
6020 
    if self.item_id is not None:
6021 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6022 
      oprot.writeI64(self.item_id)
6023 
      oprot.writeFieldEnd()
6024 
    oprot.writeFieldStop()
6025 
    oprot.writeStructEnd()
6026 
 
6027 
  def validate(self):
6028 
    return
6029 
 
6030 
 
6031 
  def __repr__(self):
6032 
    L = ['%s=%r' % (key, value)
6033 
      for key, value in self.__dict__.iteritems()]
6034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6035 
 
6036 
  def __eq__(self, other):
6037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6038 
 
6039 
  def __ne__(self, other):
6040 
    return not (self == other)
6041 
 
6042 
class getItem_result:
6043 
  """
6044 
  Attributes:
6045 
   - success
6046 
   - cex
6047 
  """
6048 
 
6049 
  thrift_spec = (
6050 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6051 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6052 
  )
6053 
 
6054 
  def __init__(self, success=None, cex=None,):
6055 
    self.success = success
6056 
    self.cex = cex
6057 
 
6058 
  def read(self, iprot):
6059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6061 
      return
6062 
    iprot.readStructBegin()
6063 
    while True:
6064 
      (fname, ftype, fid) = iprot.readFieldBegin()
6065 
      if ftype == TType.STOP:
6066 
        break
6067 
      if fid == 0:
6068 
        if ftype == TType.STRUCT:
6069 
          self.success = Item()
6070 
          self.success.read(iprot)
6071 
        else:
6072 
          iprot.skip(ftype)
6073 
      elif fid == 1:
6074 
        if ftype == TType.STRUCT:
6075 
          self.cex = CatalogServiceException()
6076 
          self.cex.read(iprot)
6077 
        else:
6078 
          iprot.skip(ftype)
6079 
      else:
6080 
        iprot.skip(ftype)
6081 
      iprot.readFieldEnd()
6082 
    iprot.readStructEnd()
6083 
 
6084 
  def write(self, oprot):
6085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6087 
      return
6088 
    oprot.writeStructBegin('getItem_result')
6089 
    if self.success is not None:
6090 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6091 
      self.success.write(oprot)
6092 
      oprot.writeFieldEnd()
6093 
    if self.cex is not None:
6094 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6095 
      self.cex.write(oprot)
6096 
      oprot.writeFieldEnd()
6097 
    oprot.writeFieldStop()
6098 
    oprot.writeStructEnd()
6099 
 
6100 
  def validate(self):
6101 
    return
6102 
 
6103 
 
6104 
  def __repr__(self):
6105 
    L = ['%s=%r' % (key, value)
6106 
      for key, value in self.__dict__.iteritems()]
6107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6108 
 
6109 
  def __eq__(self, other):
6110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6111 
 
6112 
  def __ne__(self, other):
6113 
    return not (self == other)
6114 
 
6115 
class getItemsByCatalogId_args:
6116 
  """
6117 
  Attributes:
6118 
   - catalog_item_id
6119 
  """
6120 
 
6121 
  thrift_spec = (
6122 
    None, # 0
6123 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6124 
  )
6125 
 
6126 
  def __init__(self, catalog_item_id=None,):
6127 
    self.catalog_item_id = catalog_item_id
6128 
 
6129 
  def read(self, iprot):
6130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6132 
      return
6133 
    iprot.readStructBegin()
6134 
    while True:
6135 
      (fname, ftype, fid) = iprot.readFieldBegin()
6136 
      if ftype == TType.STOP:
6137 
        break
6138 
      if fid == 1:
6139 
        if ftype == TType.I64:
6140 
          self.catalog_item_id = iprot.readI64();
6141 
        else:
6142 
          iprot.skip(ftype)
6143 
      else:
6144 
        iprot.skip(ftype)
6145 
      iprot.readFieldEnd()
6146 
    iprot.readStructEnd()
6147 
 
6148 
  def write(self, oprot):
6149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6151 
      return
6152 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6153 
    if self.catalog_item_id is not None:
6154 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6155 
      oprot.writeI64(self.catalog_item_id)
6156 
      oprot.writeFieldEnd()
6157 
    oprot.writeFieldStop()
6158 
    oprot.writeStructEnd()
6159 
 
6160 
  def validate(self):
6161 
    return
6162 
 
6163 
 
6164 
  def __repr__(self):
6165 
    L = ['%s=%r' % (key, value)
6166 
      for key, value in self.__dict__.iteritems()]
6167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6168 
 
6169 
  def __eq__(self, other):
6170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6171 
 
6172 
  def __ne__(self, other):
6173 
    return not (self == other)
6174 
 
6175 
class getItemsByCatalogId_result:
6176 
  """
6177 
  Attributes:
6178 
   - success
6179 
   - cex
6180 
  """
6181 
 
6182 
  thrift_spec = (
6183 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6184 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6185 
  )
6186 
 
6187 
  def __init__(self, success=None, cex=None,):
6188 
    self.success = success
6189 
    self.cex = cex
6190 
 
6191 
  def read(self, iprot):
6192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6194 
      return
6195 
    iprot.readStructBegin()
6196 
    while True:
6197 
      (fname, ftype, fid) = iprot.readFieldBegin()
6198 
      if ftype == TType.STOP:
6199 
        break
6200 
      if fid == 0:
6201 
        if ftype == TType.LIST:
6202 
          self.success = []
6203 
          (_etype19, _size16) = iprot.readListBegin()
6204 
          for _i20 in xrange(_size16):
6205 
            _elem21 = Item()
6206 
            _elem21.read(iprot)
6207 
            self.success.append(_elem21)
6208 
          iprot.readListEnd()
6209 
        else:
6210 
          iprot.skip(ftype)
6211 
      elif fid == 1:
6212 
        if ftype == TType.STRUCT:
6213 
          self.cex = CatalogServiceException()
6214 
          self.cex.read(iprot)
6215 
        else:
6216 
          iprot.skip(ftype)
6217 
      else:
6218 
        iprot.skip(ftype)
6219 
      iprot.readFieldEnd()
6220 
    iprot.readStructEnd()
6221 
 
6222 
  def write(self, oprot):
6223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6225 
      return
6226 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6227 
    if self.success is not None:
6228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6229 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6230 
      for iter22 in self.success:
6231 
        iter22.write(oprot)
6232 
      oprot.writeListEnd()
6233 
      oprot.writeFieldEnd()
6234 
    if self.cex is not None:
6235 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6236 
      self.cex.write(oprot)
6237 
      oprot.writeFieldEnd()
6238 
    oprot.writeFieldStop()
6239 
    oprot.writeStructEnd()
6240 
 
6241 
  def validate(self):
6242 
    return
6243 
 
6244 
 
6245 
  def __repr__(self):
6246 
    L = ['%s=%r' % (key, value)
6247 
      for key, value in self.__dict__.iteritems()]
6248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6249 
 
6250 
  def __eq__(self, other):
6251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6252 
 
6253 
  def __ne__(self, other):
6254 
    return not (self == other)
6255 
 
6256 
class getValidItemsByCatalogId_args:
6257 
  """
6258 
  Attributes:
6259 
   - catalog_item_id
6260 
  """
6261 
 
6262 
  thrift_spec = (
6263 
    None, # 0
6264 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6265 
  )
6266 
 
6267 
  def __init__(self, catalog_item_id=None,):
6268 
    self.catalog_item_id = catalog_item_id
6269 
 
6270 
  def read(self, iprot):
6271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6273 
      return
6274 
    iprot.readStructBegin()
6275 
    while True:
6276 
      (fname, ftype, fid) = iprot.readFieldBegin()
6277 
      if ftype == TType.STOP:
6278 
        break
6279 
      if fid == 1:
6280 
        if ftype == TType.I64:
6281 
          self.catalog_item_id = iprot.readI64();
6282 
        else:
6283 
          iprot.skip(ftype)
6284 
      else:
6285 
        iprot.skip(ftype)
6286 
      iprot.readFieldEnd()
6287 
    iprot.readStructEnd()
6288 
 
6289 
  def write(self, oprot):
6290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6292 
      return
6293 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6294 
    if self.catalog_item_id is not None:
6295 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6296 
      oprot.writeI64(self.catalog_item_id)
6297 
      oprot.writeFieldEnd()
6298 
    oprot.writeFieldStop()
6299 
    oprot.writeStructEnd()
6300 
 
6301 
  def validate(self):
6302 
    return
6303 
 
6304 
 
6305 
  def __repr__(self):
6306 
    L = ['%s=%r' % (key, value)
6307 
      for key, value in self.__dict__.iteritems()]
6308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6309 
 
6310 
  def __eq__(self, other):
6311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6312 
 
6313 
  def __ne__(self, other):
6314 
    return not (self == other)
6315 
 
6316 
class getValidItemsByCatalogId_result:
6317 
  """
6318 
  Attributes:
6319 
   - success
6320 
   - cex
6321 
  """
6322 
 
6323 
  thrift_spec = (
6324 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6325 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6326 
  )
6327 
 
6328 
  def __init__(self, success=None, cex=None,):
6329 
    self.success = success
6330 
    self.cex = cex
6331 
 
6332 
  def read(self, iprot):
6333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6335 
      return
6336 
    iprot.readStructBegin()
6337 
    while True:
6338 
      (fname, ftype, fid) = iprot.readFieldBegin()
6339 
      if ftype == TType.STOP:
6340 
        break
6341 
      if fid == 0:
6342 
        if ftype == TType.LIST:
6343 
          self.success = []
6344 
          (_etype26, _size23) = iprot.readListBegin()
6345 
          for _i27 in xrange(_size23):
6346 
            _elem28 = Item()
6347 
            _elem28.read(iprot)
6348 
            self.success.append(_elem28)
6349 
          iprot.readListEnd()
6350 
        else:
6351 
          iprot.skip(ftype)
6352 
      elif fid == 1:
6353 
        if ftype == TType.STRUCT:
6354 
          self.cex = CatalogServiceException()
6355 
          self.cex.read(iprot)
6356 
        else:
6357 
          iprot.skip(ftype)
6358 
      else:
6359 
        iprot.skip(ftype)
6360 
      iprot.readFieldEnd()
6361 
    iprot.readStructEnd()
6362 
 
6363 
  def write(self, oprot):
6364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6366 
      return
6367 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6368 
    if self.success is not None:
6369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6370 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6371 
      for iter29 in self.success:
6372 
        iter29.write(oprot)
6373 
      oprot.writeListEnd()
6374 
      oprot.writeFieldEnd()
6375 
    if self.cex is not None:
6376 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6377 
      self.cex.write(oprot)
6378 
      oprot.writeFieldEnd()
6379 
    oprot.writeFieldStop()
6380 
    oprot.writeStructEnd()
6381 
 
6382 
  def validate(self):
6383 
    return
6384 
 
6385 
 
6386 
  def __repr__(self):
6387 
    L = ['%s=%r' % (key, value)
6388 
      for key, value in self.__dict__.iteritems()]
6389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6390 
 
6391 
  def __eq__(self, other):
6392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6393 
 
6394 
  def __ne__(self, other):
6395 
    return not (self == other)
6396 
 
6397 
class getAllItems_args:
6398 
  """
6399 
  Attributes:
6400 
   - isActive
6401 
  """
6402 
 
6403 
  thrift_spec = (
6404 
    None, # 0
6405 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6406 
  )
6407 
 
6408 
  def __init__(self, isActive=None,):
6409 
    self.isActive = isActive
6410 
 
6411 
  def read(self, iprot):
6412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6414 
      return
6415 
    iprot.readStructBegin()
6416 
    while True:
6417 
      (fname, ftype, fid) = iprot.readFieldBegin()
6418 
      if ftype == TType.STOP:
6419 
        break
6420 
      if fid == 1:
6421 
        if ftype == TType.BOOL:
6422 
          self.isActive = iprot.readBool();
6423 
        else:
6424 
          iprot.skip(ftype)
6425 
      else:
6426 
        iprot.skip(ftype)
6427 
      iprot.readFieldEnd()
6428 
    iprot.readStructEnd()
6429 
 
6430 
  def write(self, oprot):
6431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6433 
      return
6434 
    oprot.writeStructBegin('getAllItems_args')
6435 
    if self.isActive is not None:
6436 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6437 
      oprot.writeBool(self.isActive)
6438 
      oprot.writeFieldEnd()
6439 
    oprot.writeFieldStop()
6440 
    oprot.writeStructEnd()
6441 
 
6442 
  def validate(self):
6443 
    return
6444 
 
6445 
 
6446 
  def __repr__(self):
6447 
    L = ['%s=%r' % (key, value)
6448 
      for key, value in self.__dict__.iteritems()]
6449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6450 
 
6451 
  def __eq__(self, other):
6452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6453 
 
6454 
  def __ne__(self, other):
6455 
    return not (self == other)
6456 
 
6457 
class getAllItems_result:
6458 
  """
6459 
  Attributes:
6460 
   - success
6461 
   - cex
6462 
  """
6463 
 
6464 
  thrift_spec = (
6465 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6466 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6467 
  )
6468 
 
6469 
  def __init__(self, success=None, cex=None,):
6470 
    self.success = success
6471 
    self.cex = cex
6472 
 
6473 
  def read(self, iprot):
6474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6476 
      return
6477 
    iprot.readStructBegin()
6478 
    while True:
6479 
      (fname, ftype, fid) = iprot.readFieldBegin()
6480 
      if ftype == TType.STOP:
6481 
        break
6482 
      if fid == 0:
6483 
        if ftype == TType.LIST:
6484 
          self.success = []
6485 
          (_etype33, _size30) = iprot.readListBegin()
6486 
          for _i34 in xrange(_size30):
6487 
            _elem35 = Item()
6488 
            _elem35.read(iprot)
6489 
            self.success.append(_elem35)
6490 
          iprot.readListEnd()
6491 
        else:
6492 
          iprot.skip(ftype)
6493 
      elif fid == 1:
6494 
        if ftype == TType.STRUCT:
6495 
          self.cex = CatalogServiceException()
6496 
          self.cex.read(iprot)
6497 
        else:
6498 
          iprot.skip(ftype)
6499 
      else:
6500 
        iprot.skip(ftype)
6501 
      iprot.readFieldEnd()
6502 
    iprot.readStructEnd()
6503 
 
6504 
  def write(self, oprot):
6505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6507 
      return
6508 
    oprot.writeStructBegin('getAllItems_result')
6509 
    if self.success is not None:
6510 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6511 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6512 
      for iter36 in self.success:
6513 
        iter36.write(oprot)
6514 
      oprot.writeListEnd()
6515 
      oprot.writeFieldEnd()
6516 
    if self.cex is not None:
6517 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6518 
      self.cex.write(oprot)
6519 
      oprot.writeFieldEnd()
6520 
    oprot.writeFieldStop()
6521 
    oprot.writeStructEnd()
6522 
 
6523 
  def validate(self):
6524 
    return
6525 
 
6526 
 
6527 
  def __repr__(self):
6528 
    L = ['%s=%r' % (key, value)
6529 
      for key, value in self.__dict__.iteritems()]
6530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6531 
 
6532 
  def __eq__(self, other):
6533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6534 
 
6535 
  def __ne__(self, other):
6536 
    return not (self == other)
6537 
 
6538 
class getAllItemsByStatus_args:
6539 
  """
6540 
  Attributes:
6541 
   - itemStatus
6542 
  """
6543 
 
6544 
  thrift_spec = (
6545 
    None, # 0
6546 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6547 
  )
6548 
 
6549 
  def __init__(self, itemStatus=None,):
6550 
    self.itemStatus = itemStatus
6551 
 
6552 
  def read(self, iprot):
6553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6555 
      return
6556 
    iprot.readStructBegin()
6557 
    while True:
6558 
      (fname, ftype, fid) = iprot.readFieldBegin()
6559 
      if ftype == TType.STOP:
6560 
        break
6561 
      if fid == 1:
6562 
        if ftype == TType.I32:
6563 
          self.itemStatus = iprot.readI32();
6564 
        else:
6565 
          iprot.skip(ftype)
6566 
      else:
6567 
        iprot.skip(ftype)
6568 
      iprot.readFieldEnd()
6569 
    iprot.readStructEnd()
6570 
 
6571 
  def write(self, oprot):
6572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6574 
      return
6575 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6576 
    if self.itemStatus is not None:
6577 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6578 
      oprot.writeI32(self.itemStatus)
6579 
      oprot.writeFieldEnd()
6580 
    oprot.writeFieldStop()
6581 
    oprot.writeStructEnd()
6582 
 
6583 
  def validate(self):
6584 
    return
6585 
 
6586 
 
6587 
  def __repr__(self):
6588 
    L = ['%s=%r' % (key, value)
6589 
      for key, value in self.__dict__.iteritems()]
6590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6591 
 
6592 
  def __eq__(self, other):
6593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6594 
 
6595 
  def __ne__(self, other):
6596 
    return not (self == other)
6597 
 
6598 
class getAllItemsByStatus_result:
6599 
  """
6600 
  Attributes:
6601 
   - success
6602 
   - cex
6603 
  """
6604 
 
6605 
  thrift_spec = (
6606 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6607 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6608 
  )
6609 
 
6610 
  def __init__(self, success=None, cex=None,):
6611 
    self.success = success
6612 
    self.cex = cex
6613 
 
6614 
  def read(self, iprot):
6615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6617 
      return
6618 
    iprot.readStructBegin()
6619 
    while True:
6620 
      (fname, ftype, fid) = iprot.readFieldBegin()
6621 
      if ftype == TType.STOP:
6622 
        break
6623 
      if fid == 0:
6624 
        if ftype == TType.LIST:
6625 
          self.success = []
6626 
          (_etype40, _size37) = iprot.readListBegin()
6627 
          for _i41 in xrange(_size37):
6628 
            _elem42 = Item()
6629 
            _elem42.read(iprot)
6630 
            self.success.append(_elem42)
6631 
          iprot.readListEnd()
6632 
        else:
6633 
          iprot.skip(ftype)
6634 
      elif fid == 1:
6635 
        if ftype == TType.STRUCT:
6636 
          self.cex = CatalogServiceException()
6637 
          self.cex.read(iprot)
6638 
        else:
6639 
          iprot.skip(ftype)
6640 
      else:
6641 
        iprot.skip(ftype)
6642 
      iprot.readFieldEnd()
6643 
    iprot.readStructEnd()
6644 
 
6645 
  def write(self, oprot):
6646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6648 
      return
6649 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6650 
    if self.success is not None:
6651 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6652 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6653 
      for iter43 in self.success:
6654 
        iter43.write(oprot)
6655 
      oprot.writeListEnd()
6656 
      oprot.writeFieldEnd()
6657 
    if self.cex is not None:
6658 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6659 
      self.cex.write(oprot)
6660 
      oprot.writeFieldEnd()
6661 
    oprot.writeFieldStop()
6662 
    oprot.writeStructEnd()
6663 
 
6664 
  def validate(self):
6665 
    return
6666 
 
6667 
 
6668 
  def __repr__(self):
6669 
    L = ['%s=%r' % (key, value)
6670 
      for key, value in self.__dict__.iteritems()]
6671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6672 
 
6673 
  def __eq__(self, other):
6674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6675 
 
6676 
  def __ne__(self, other):
6677 
    return not (self == other)
6678 
 
6679 
class markItemAsContentComplete_args:
6680 
  """
6681 
  Attributes:
6682 
   - entityId
6683 
   - category
6684 
   - brand
6685 
   - modelName
6686 
   - modelNumber
6687 
  """
6688 
 
6689 
  thrift_spec = (
6690 
    None, # 0
6691 
    (1, TType.I64, 'entityId', None, None, ), # 1
6692 
    (2, TType.I64, 'category', None, None, ), # 2
6693 
    (3, TType.STRING, 'brand', None, None, ), # 3
6694 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6695 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6696 
  )
6697 
 
6698 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6699 
    self.entityId = entityId
6700 
    self.category = category
6701 
    self.brand = brand
6702 
    self.modelName = modelName
6703 
    self.modelNumber = modelNumber
6704 
 
6705 
  def read(self, iprot):
6706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6708 
      return
6709 
    iprot.readStructBegin()
6710 
    while True:
6711 
      (fname, ftype, fid) = iprot.readFieldBegin()
6712 
      if ftype == TType.STOP:
6713 
        break
6714 
      if fid == 1:
6715 
        if ftype == TType.I64:
6716 
          self.entityId = iprot.readI64();
6717 
        else:
6718 
          iprot.skip(ftype)
6719 
      elif fid == 2:
6720 
        if ftype == TType.I64:
6721 
          self.category = iprot.readI64();
6722 
        else:
6723 
          iprot.skip(ftype)
6724 
      elif fid == 3:
6725 
        if ftype == TType.STRING:
6726 
          self.brand = iprot.readString();
6727 
        else:
6728 
          iprot.skip(ftype)
6729 
      elif fid == 4:
6730 
        if ftype == TType.STRING:
6731 
          self.modelName = iprot.readString();
6732 
        else:
6733 
          iprot.skip(ftype)
6734 
      elif fid == 5:
6735 
        if ftype == TType.STRING:
6736 
          self.modelNumber = iprot.readString();
6737 
        else:
6738 
          iprot.skip(ftype)
6739 
      else:
6740 
        iprot.skip(ftype)
6741 
      iprot.readFieldEnd()
6742 
    iprot.readStructEnd()
6743 
 
6744 
  def write(self, oprot):
6745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6747 
      return
6748 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6749 
    if self.entityId is not None:
6750 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6751 
      oprot.writeI64(self.entityId)
6752 
      oprot.writeFieldEnd()
6753 
    if self.category is not None:
6754 
      oprot.writeFieldBegin('category', TType.I64, 2)
6755 
      oprot.writeI64(self.category)
6756 
      oprot.writeFieldEnd()
6757 
    if self.brand is not None:
6758 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6759 
      oprot.writeString(self.brand)
6760 
      oprot.writeFieldEnd()
6761 
    if self.modelName is not None:
6762 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6763 
      oprot.writeString(self.modelName)
6764 
      oprot.writeFieldEnd()
6765 
    if self.modelNumber is not None:
6766 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6767 
      oprot.writeString(self.modelNumber)
6768 
      oprot.writeFieldEnd()
6769 
    oprot.writeFieldStop()
6770 
    oprot.writeStructEnd()
6771 
 
6772 
  def validate(self):
6773 
    return
6774 
 
6775 
 
6776 
  def __repr__(self):
6777 
    L = ['%s=%r' % (key, value)
6778 
      for key, value in self.__dict__.iteritems()]
6779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6780 
 
6781 
  def __eq__(self, other):
6782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6783 
 
6784 
  def __ne__(self, other):
6785 
    return not (self == other)
6786 
 
6787 
class markItemAsContentComplete_result:
6788 
  """
6789 
  Attributes:
6790 
   - success
6791 
   - cex
6792 
  """
6793 
 
6794 
  thrift_spec = (
6795 
    (0, TType.BOOL, 'success', None, None, ), # 0
6796 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6797 
  )
6798 
 
6799 
  def __init__(self, success=None, cex=None,):
6800 
    self.success = success
6801 
    self.cex = cex
6802 
 
6803 
  def read(self, iprot):
6804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6806 
      return
6807 
    iprot.readStructBegin()
6808 
    while True:
6809 
      (fname, ftype, fid) = iprot.readFieldBegin()
6810 
      if ftype == TType.STOP:
6811 
        break
6812 
      if fid == 0:
6813 
        if ftype == TType.BOOL:
6814 
          self.success = iprot.readBool();
6815 
        else:
6816 
          iprot.skip(ftype)
6817 
      elif fid == 1:
6818 
        if ftype == TType.STRUCT:
6819 
          self.cex = CatalogServiceException()
6820 
          self.cex.read(iprot)
6821 
        else:
6822 
          iprot.skip(ftype)
6823 
      else:
6824 
        iprot.skip(ftype)
6825 
      iprot.readFieldEnd()
6826 
    iprot.readStructEnd()
6827 
 
6828 
  def write(self, oprot):
6829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6831 
      return
6832 
    oprot.writeStructBegin('markItemAsContentComplete_result')
6833 
    if self.success is not None:
6834 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6835 
      oprot.writeBool(self.success)
6836 
      oprot.writeFieldEnd()
6837 
    if self.cex is not None:
6838 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6839 
      self.cex.write(oprot)
6840 
      oprot.writeFieldEnd()
6841 
    oprot.writeFieldStop()
6842 
    oprot.writeStructEnd()
6843 
 
6844 
  def validate(self):
6845 
    return
6846 
 
6847 
 
6848 
  def __repr__(self):
6849 
    L = ['%s=%r' % (key, value)
6850 
      for key, value in self.__dict__.iteritems()]
6851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6852 
 
6853 
  def __eq__(self, other):
6854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6855 
 
6856 
  def __ne__(self, other):
6857 
    return not (self == other)
6858 
 
6859 
class getAllItemsInRange_args:
6860 
  """
6861 
  Attributes:
6862 
   - offset
6863 
   - limit
6864 
  """
6865 
 
6866 
  thrift_spec = (
6867 
    None, # 0
6868 
    (1, TType.I64, 'offset', None, None, ), # 1
6869 
    (2, TType.I64, 'limit', None, None, ), # 2
6870 
  )
6871 
 
6872 
  def __init__(self, offset=None, limit=None,):
6873 
    self.offset = offset
6874 
    self.limit = limit
6875 
 
6876 
  def read(self, iprot):
6877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6879 
      return
6880 
    iprot.readStructBegin()
6881 
    while True:
6882 
      (fname, ftype, fid) = iprot.readFieldBegin()
6883 
      if ftype == TType.STOP:
6884 
        break
6885 
      if fid == 1:
6886 
        if ftype == TType.I64:
6887 
          self.offset = iprot.readI64();
6888 
        else:
6889 
          iprot.skip(ftype)
6890 
      elif fid == 2:
6891 
        if ftype == TType.I64:
6892 
          self.limit = iprot.readI64();
6893 
        else:
6894 
          iprot.skip(ftype)
6895 
      else:
6896 
        iprot.skip(ftype)
6897 
      iprot.readFieldEnd()
6898 
    iprot.readStructEnd()
6899 
 
6900 
  def write(self, oprot):
6901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6903 
      return
6904 
    oprot.writeStructBegin('getAllItemsInRange_args')
6905 
    if self.offset is not None:
6906 
      oprot.writeFieldBegin('offset', TType.I64, 1)
6907 
      oprot.writeI64(self.offset)
6908 
      oprot.writeFieldEnd()
6909 
    if self.limit is not None:
6910 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6911 
      oprot.writeI64(self.limit)
6912 
      oprot.writeFieldEnd()
6913 
    oprot.writeFieldStop()
6914 
    oprot.writeStructEnd()
6915 
 
6916 
  def validate(self):
6917 
    return
6918 
 
6919 
 
6920 
  def __repr__(self):
6921 
    L = ['%s=%r' % (key, value)
6922 
      for key, value in self.__dict__.iteritems()]
6923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6924 
 
6925 
  def __eq__(self, other):
6926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6927 
 
6928 
  def __ne__(self, other):
6929 
    return not (self == other)
6930 
 
6931 
class getAllItemsInRange_result:
6932 
  """
6933 
  Attributes:
6934 
   - success
6935 
   - cex
6936 
  """
6937 
 
6938 
  thrift_spec = (
6939 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6940 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6941 
  )
6942 
 
6943 
  def __init__(self, success=None, cex=None,):
6944 
    self.success = success
6945 
    self.cex = cex
6946 
 
6947 
  def read(self, iprot):
6948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6950 
      return
6951 
    iprot.readStructBegin()
6952 
    while True:
6953 
      (fname, ftype, fid) = iprot.readFieldBegin()
6954 
      if ftype == TType.STOP:
6955 
        break
6956 
      if fid == 0:
6957 
        if ftype == TType.LIST:
6958 
          self.success = []
6959 
          (_etype47, _size44) = iprot.readListBegin()
6960 
          for _i48 in xrange(_size44):
6961 
            _elem49 = Item()
6962 
            _elem49.read(iprot)
6963 
            self.success.append(_elem49)
6964 
          iprot.readListEnd()
6965 
        else:
6966 
          iprot.skip(ftype)
6967 
      elif fid == 1:
6968 
        if ftype == TType.STRUCT:
6969 
          self.cex = CatalogServiceException()
6970 
          self.cex.read(iprot)
6971 
        else:
6972 
          iprot.skip(ftype)
6973 
      else:
6974 
        iprot.skip(ftype)
6975 
      iprot.readFieldEnd()
6976 
    iprot.readStructEnd()
6977 
 
6978 
  def write(self, oprot):
6979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6981 
      return
6982 
    oprot.writeStructBegin('getAllItemsInRange_result')
6983 
    if self.success is not None:
6984 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6985 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6986 
      for iter50 in self.success:
6987 
        iter50.write(oprot)
6988 
      oprot.writeListEnd()
6989 
      oprot.writeFieldEnd()
6990 
    if self.cex is not None:
6991 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6992 
      self.cex.write(oprot)
6993 
      oprot.writeFieldEnd()
6994 
    oprot.writeFieldStop()
6995 
    oprot.writeStructEnd()
6996 
 
6997 
  def validate(self):
6998 
    return
6999 
 
7000 
 
7001 
  def __repr__(self):
7002 
    L = ['%s=%r' % (key, value)
7003 
      for key, value in self.__dict__.iteritems()]
7004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7005 
 
7006 
  def __eq__(self, other):
7007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7008 
 
7009 
  def __ne__(self, other):
7010 
    return not (self == other)
7011 
 
7012 
class getAllItemsByStatusInRange_args:
7013 
  """
7014 
  Attributes:
7015 
   - itemStatus
7016 
   - offset
7017 
   - limit
7018 
  """
7019 
 
7020 
  thrift_spec = (
7021 
    None, # 0
7022 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7023 
    (2, TType.I64, 'offset', None, None, ), # 2
7024 
    (3, TType.I64, 'limit', None, None, ), # 3
7025 
  )
7026 
 
7027 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7028 
    self.itemStatus = itemStatus
7029 
    self.offset = offset
7030 
    self.limit = limit
7031 
 
7032 
  def read(self, iprot):
7033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7035 
      return
7036 
    iprot.readStructBegin()
7037 
    while True:
7038 
      (fname, ftype, fid) = iprot.readFieldBegin()
7039 
      if ftype == TType.STOP:
7040 
        break
7041 
      if fid == 1:
7042 
        if ftype == TType.I32:
7043 
          self.itemStatus = iprot.readI32();
7044 
        else:
7045 
          iprot.skip(ftype)
7046 
      elif fid == 2:
7047 
        if ftype == TType.I64:
7048 
          self.offset = iprot.readI64();
7049 
        else:
7050 
          iprot.skip(ftype)
7051 
      elif fid == 3:
7052 
        if ftype == TType.I64:
7053 
          self.limit = iprot.readI64();
7054 
        else:
7055 
          iprot.skip(ftype)
7056 
      else:
7057 
        iprot.skip(ftype)
7058 
      iprot.readFieldEnd()
7059 
    iprot.readStructEnd()
7060 
 
7061 
  def write(self, oprot):
7062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7064 
      return
7065 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7066 
    if self.itemStatus is not None:
7067 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7068 
      oprot.writeI32(self.itemStatus)
7069 
      oprot.writeFieldEnd()
7070 
    if self.offset is not None:
7071 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7072 
      oprot.writeI64(self.offset)
7073 
      oprot.writeFieldEnd()
7074 
    if self.limit is not None:
7075 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7076 
      oprot.writeI64(self.limit)
7077 
      oprot.writeFieldEnd()
7078 
    oprot.writeFieldStop()
7079 
    oprot.writeStructEnd()
7080 
 
7081 
  def validate(self):
7082 
    return
7083 
 
7084 
 
7085 
  def __repr__(self):
7086 
    L = ['%s=%r' % (key, value)
7087 
      for key, value in self.__dict__.iteritems()]
7088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7089 
 
7090 
  def __eq__(self, other):
7091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7092 
 
7093 
  def __ne__(self, other):
7094 
    return not (self == other)
7095 
 
7096 
class getAllItemsByStatusInRange_result:
7097 
  """
7098 
  Attributes:
7099 
   - success
7100 
   - cex
7101 
  """
7102 
 
7103 
  thrift_spec = (
7104 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7105 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7106 
  )
7107 
 
7108 
  def __init__(self, success=None, cex=None,):
7109 
    self.success = success
7110 
    self.cex = cex
7111 
 
7112 
  def read(self, iprot):
7113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7115 
      return
7116 
    iprot.readStructBegin()
7117 
    while True:
7118 
      (fname, ftype, fid) = iprot.readFieldBegin()
7119 
      if ftype == TType.STOP:
7120 
        break
7121 
      if fid == 0:
7122 
        if ftype == TType.LIST:
7123 
          self.success = []
7124 
          (_etype54, _size51) = iprot.readListBegin()
7125 
          for _i55 in xrange(_size51):
7126 
            _elem56 = Item()
7127 
            _elem56.read(iprot)
7128 
            self.success.append(_elem56)
7129 
          iprot.readListEnd()
7130 
        else:
7131 
          iprot.skip(ftype)
7132 
      elif fid == 1:
7133 
        if ftype == TType.STRUCT:
7134 
          self.cex = CatalogServiceException()
7135 
          self.cex.read(iprot)
7136 
        else:
7137 
          iprot.skip(ftype)
7138 
      else:
7139 
        iprot.skip(ftype)
7140 
      iprot.readFieldEnd()
7141 
    iprot.readStructEnd()
7142 
 
7143 
  def write(self, oprot):
7144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7146 
      return
7147 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7148 
    if self.success is not None:
7149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7150 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 
      for iter57 in self.success:
7152 
        iter57.write(oprot)
7153 
      oprot.writeListEnd()
7154 
      oprot.writeFieldEnd()
7155 
    if self.cex is not None:
7156 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7157 
      self.cex.write(oprot)
7158 
      oprot.writeFieldEnd()
7159 
    oprot.writeFieldStop()
7160 
    oprot.writeStructEnd()
7161 
 
7162 
  def validate(self):
7163 
    return
7164 
 
7165 
 
7166 
  def __repr__(self):
7167 
    L = ['%s=%r' % (key, value)
7168 
      for key, value in self.__dict__.iteritems()]
7169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7170 
 
7171 
  def __eq__(self, other):
7172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7173 
 
7174 
  def __ne__(self, other):
7175 
    return not (self == other)
7176 
 
7177 
class getItemCountByStatus_args:
7178 
  """
7179 
  Attributes:
7180 
   - useStatus
7181 
   - itemStatus
7182 
  """
7183 
 
7184 
  thrift_spec = (
7185 
    None, # 0
7186 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7187 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7188 
  )
7189 
 
7190 
  def __init__(self, useStatus=None, itemStatus=None,):
7191 
    self.useStatus = useStatus
7192 
    self.itemStatus = itemStatus
7193 
 
7194 
  def read(self, iprot):
7195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7197 
      return
7198 
    iprot.readStructBegin()
7199 
    while True:
7200 
      (fname, ftype, fid) = iprot.readFieldBegin()
7201 
      if ftype == TType.STOP:
7202 
        break
7203 
      if fid == 1:
7204 
        if ftype == TType.BOOL:
7205 
          self.useStatus = iprot.readBool();
7206 
        else:
7207 
          iprot.skip(ftype)
7208 
      elif fid == 2:
7209 
        if ftype == TType.I32:
7210 
          self.itemStatus = iprot.readI32();
7211 
        else:
7212 
          iprot.skip(ftype)
7213 
      else:
7214 
        iprot.skip(ftype)
7215 
      iprot.readFieldEnd()
7216 
    iprot.readStructEnd()
7217 
 
7218 
  def write(self, oprot):
7219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7221 
      return
7222 
    oprot.writeStructBegin('getItemCountByStatus_args')
7223 
    if self.useStatus is not None:
7224 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7225 
      oprot.writeBool(self.useStatus)
7226 
      oprot.writeFieldEnd()
7227 
    if self.itemStatus is not None:
7228 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7229 
      oprot.writeI32(self.itemStatus)
7230 
      oprot.writeFieldEnd()
7231 
    oprot.writeFieldStop()
7232 
    oprot.writeStructEnd()
7233 
 
7234 
  def validate(self):
7235 
    return
7236 
 
7237 
 
7238 
  def __repr__(self):
7239 
    L = ['%s=%r' % (key, value)
7240 
      for key, value in self.__dict__.iteritems()]
7241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7242 
 
7243 
  def __eq__(self, other):
7244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7245 
 
7246 
  def __ne__(self, other):
7247 
    return not (self == other)
7248 
 
7249 
class getItemCountByStatus_result:
7250 
  """
7251 
  Attributes:
7252 
   - success
7253 
  """
7254 
 
7255 
  thrift_spec = (
7256 
    (0, TType.I32, 'success', None, None, ), # 0
7257 
  )
7258 
 
7259 
  def __init__(self, success=None,):
7260 
    self.success = success
7261 
 
7262 
  def read(self, iprot):
7263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7265 
      return
7266 
    iprot.readStructBegin()
7267 
    while True:
7268 
      (fname, ftype, fid) = iprot.readFieldBegin()
7269 
      if ftype == TType.STOP:
7270 
        break
7271 
      if fid == 0:
7272 
        if ftype == TType.I32:
7273 
          self.success = iprot.readI32();
7274 
        else:
7275 
          iprot.skip(ftype)
7276 
      else:
7277 
        iprot.skip(ftype)
7278 
      iprot.readFieldEnd()
7279 
    iprot.readStructEnd()
7280 
 
7281 
  def write(self, oprot):
7282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7284 
      return
7285 
    oprot.writeStructBegin('getItemCountByStatus_result')
7286 
    if self.success is not None:
7287 
      oprot.writeFieldBegin('success', TType.I32, 0)
7288 
      oprot.writeI32(self.success)
7289 
      oprot.writeFieldEnd()
7290 
    oprot.writeFieldStop()
7291 
    oprot.writeStructEnd()
7292 
 
7293 
  def validate(self):
7294 
    return
7295 
 
7296 
 
7297 
  def __repr__(self):
7298 
    L = ['%s=%r' % (key, value)
7299 
      for key, value in self.__dict__.iteritems()]
7300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7301 
 
7302 
  def __eq__(self, other):
7303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7304 
 
7305 
  def __ne__(self, other):
7306 
    return not (self == other)
7307 
 
7308 
class getBestSellers_args:
7309 
 
7310 
  thrift_spec = (
7311 
  )
7312 
 
7313 
  def read(self, iprot):
7314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7316 
      return
7317 
    iprot.readStructBegin()
7318 
    while True:
7319 
      (fname, ftype, fid) = iprot.readFieldBegin()
7320 
      if ftype == TType.STOP:
7321 
        break
7322 
      else:
7323 
        iprot.skip(ftype)
7324 
      iprot.readFieldEnd()
7325 
    iprot.readStructEnd()
7326 
 
7327 
  def write(self, oprot):
7328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7330 
      return
7331 
    oprot.writeStructBegin('getBestSellers_args')
7332 
    oprot.writeFieldStop()
7333 
    oprot.writeStructEnd()
7334 
 
7335 
  def validate(self):
7336 
    return
7337 
 
7338 
 
7339 
  def __repr__(self):
7340 
    L = ['%s=%r' % (key, value)
7341 
      for key, value in self.__dict__.iteritems()]
7342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7343 
 
7344 
  def __eq__(self, other):
7345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7346 
 
7347 
  def __ne__(self, other):
7348 
    return not (self == other)
7349 
 
7350 
class getBestSellers_result:
7351 
  """
7352 
  Attributes:
7353 
   - success
7354 
   - isex
7355 
  """
7356 
 
7357 
  thrift_spec = (
7358 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7359 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7360 
  )
7361 
 
7362 
  def __init__(self, success=None, isex=None,):
7363 
    self.success = success
7364 
    self.isex = isex
7365 
 
7366 
  def read(self, iprot):
7367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7369 
      return
7370 
    iprot.readStructBegin()
7371 
    while True:
7372 
      (fname, ftype, fid) = iprot.readFieldBegin()
7373 
      if ftype == TType.STOP:
7374 
        break
7375 
      if fid == 0:
7376 
        if ftype == TType.LIST:
7377 
          self.success = []
7378 
          (_etype61, _size58) = iprot.readListBegin()
7379 
          for _i62 in xrange(_size58):
7380 
            _elem63 = Item()
7381 
            _elem63.read(iprot)
7382 
            self.success.append(_elem63)
7383 
          iprot.readListEnd()
7384 
        else:
7385 
          iprot.skip(ftype)
7386 
      elif fid == 1:
7387 
        if ftype == TType.STRUCT:
7388 
          self.isex = CatalogServiceException()
7389 
          self.isex.read(iprot)
7390 
        else:
7391 
          iprot.skip(ftype)
7392 
      else:
7393 
        iprot.skip(ftype)
7394 
      iprot.readFieldEnd()
7395 
    iprot.readStructEnd()
7396 
 
7397 
  def write(self, oprot):
7398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7400 
      return
7401 
    oprot.writeStructBegin('getBestSellers_result')
7402 
    if self.success is not None:
7403 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7404 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7405 
      for iter64 in self.success:
7406 
        iter64.write(oprot)
7407 
      oprot.writeListEnd()
7408 
      oprot.writeFieldEnd()
7409 
    if self.isex is not None:
7410 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7411 
      self.isex.write(oprot)
7412 
      oprot.writeFieldEnd()
7413 
    oprot.writeFieldStop()
7414 
    oprot.writeStructEnd()
7415 
 
7416 
  def validate(self):
7417 
    return
7418 
 
7419 
 
7420 
  def __repr__(self):
7421 
    L = ['%s=%r' % (key, value)
7422 
      for key, value in self.__dict__.iteritems()]
7423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7424 
 
7425 
  def __eq__(self, other):
7426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7427 
 
7428 
  def __ne__(self, other):
7429 
    return not (self == other)
7430 
 
7431 
class getBestSellersCatalogIds_args:
7432 
  """
7433 
  Attributes:
7434 
   - beginIndex
7435 
   - totalItems
7436 
   - brand
7437 
   - category
7438 
  """
7439 
 
7440 
  thrift_spec = (
7441 
    None, # 0
7442 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7443 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7444 
    (3, TType.STRING, 'brand', None, None, ), # 3
7445 
    (4, TType.I64, 'category', None, None, ), # 4
7446 
  )
7447 
 
7448 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7449 
    self.beginIndex = beginIndex
7450 
    self.totalItems = totalItems
7451 
    self.brand = brand
7452 
    self.category = category
7453 
 
7454 
  def read(self, iprot):
7455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7457 
      return
7458 
    iprot.readStructBegin()
7459 
    while True:
7460 
      (fname, ftype, fid) = iprot.readFieldBegin()
7461 
      if ftype == TType.STOP:
7462 
        break
7463 
      if fid == 1:
7464 
        if ftype == TType.I64:
7465 
          self.beginIndex = iprot.readI64();
7466 
        else:
7467 
          iprot.skip(ftype)
7468 
      elif fid == 2:
7469 
        if ftype == TType.I64:
7470 
          self.totalItems = iprot.readI64();
7471 
        else:
7472 
          iprot.skip(ftype)
7473 
      elif fid == 3:
7474 
        if ftype == TType.STRING:
7475 
          self.brand = iprot.readString();
7476 
        else:
7477 
          iprot.skip(ftype)
7478 
      elif fid == 4:
7479 
        if ftype == TType.I64:
7480 
          self.category = iprot.readI64();
7481 
        else:
7482 
          iprot.skip(ftype)
7483 
      else:
7484 
        iprot.skip(ftype)
7485 
      iprot.readFieldEnd()
7486 
    iprot.readStructEnd()
7487 
 
7488 
  def write(self, oprot):
7489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7491 
      return
7492 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7493 
    if self.beginIndex is not None:
7494 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7495 
      oprot.writeI64(self.beginIndex)
7496 
      oprot.writeFieldEnd()
7497 
    if self.totalItems is not None:
7498 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7499 
      oprot.writeI64(self.totalItems)
7500 
      oprot.writeFieldEnd()
7501 
    if self.brand is not None:
7502 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7503 
      oprot.writeString(self.brand)
7504 
      oprot.writeFieldEnd()
7505 
    if self.category is not None:
7506 
      oprot.writeFieldBegin('category', TType.I64, 4)
7507 
      oprot.writeI64(self.category)
7508 
      oprot.writeFieldEnd()
7509 
    oprot.writeFieldStop()
7510 
    oprot.writeStructEnd()
7511 
 
7512 
  def validate(self):
7513 
    return
7514 
 
7515 
 
7516 
  def __repr__(self):
7517 
    L = ['%s=%r' % (key, value)
7518 
      for key, value in self.__dict__.iteritems()]
7519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7520 
 
7521 
  def __eq__(self, other):
7522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7523 
 
7524 
  def __ne__(self, other):
7525 
    return not (self == other)
7526 
 
7527 
class getBestSellersCatalogIds_result:
7528 
  """
7529 
  Attributes:
7530 
   - success
7531 
   - cex
7532 
  """
7533 
 
7534 
  thrift_spec = (
7535 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7536 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7537 
  )
7538 
 
7539 
  def __init__(self, success=None, cex=None,):
7540 
    self.success = success
7541 
    self.cex = cex
7542 
 
7543 
  def read(self, iprot):
7544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7546 
      return
7547 
    iprot.readStructBegin()
7548 
    while True:
7549 
      (fname, ftype, fid) = iprot.readFieldBegin()
7550 
      if ftype == TType.STOP:
7551 
        break
7552 
      if fid == 0:
7553 
        if ftype == TType.LIST:
7554 
          self.success = []
7555 
          (_etype68, _size65) = iprot.readListBegin()
7556 
          for _i69 in xrange(_size65):
7557 
            _elem70 = iprot.readI64();
7558 
            self.success.append(_elem70)
7559 
          iprot.readListEnd()
7560 
        else:
7561 
          iprot.skip(ftype)
7562 
      elif fid == 1:
7563 
        if ftype == TType.STRUCT:
7564 
          self.cex = CatalogServiceException()
7565 
          self.cex.read(iprot)
7566 
        else:
7567 
          iprot.skip(ftype)
7568 
      else:
7569 
        iprot.skip(ftype)
7570 
      iprot.readFieldEnd()
7571 
    iprot.readStructEnd()
7572 
 
7573 
  def write(self, oprot):
7574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7576 
      return
7577 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7578 
    if self.success is not None:
7579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7580 
      oprot.writeListBegin(TType.I64, len(self.success))
7581 
      for iter71 in self.success:
7582 
        oprot.writeI64(iter71)
7583 
      oprot.writeListEnd()
7584 
      oprot.writeFieldEnd()
7585 
    if self.cex is not None:
7586 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7587 
      self.cex.write(oprot)
7588 
      oprot.writeFieldEnd()
7589 
    oprot.writeFieldStop()
7590 
    oprot.writeStructEnd()
7591 
 
7592 
  def validate(self):
7593 
    return
7594 
 
7595 
 
7596 
  def __repr__(self):
7597 
    L = ['%s=%r' % (key, value)
7598 
      for key, value in self.__dict__.iteritems()]
7599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7600 
 
7601 
  def __eq__(self, other):
7602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7603 
 
7604 
  def __ne__(self, other):
7605 
    return not (self == other)
7606 
 
7607 
class getBestSellersCount_args:
7608 
 
7609 
  thrift_spec = (
7610 
  )
7611 
 
7612 
  def read(self, iprot):
7613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7615 
      return
7616 
    iprot.readStructBegin()
7617 
    while True:
7618 
      (fname, ftype, fid) = iprot.readFieldBegin()
7619 
      if ftype == TType.STOP:
7620 
        break
7621 
      else:
7622 
        iprot.skip(ftype)
7623 
      iprot.readFieldEnd()
7624 
    iprot.readStructEnd()
7625 
 
7626 
  def write(self, oprot):
7627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7629 
      return
7630 
    oprot.writeStructBegin('getBestSellersCount_args')
7631 
    oprot.writeFieldStop()
7632 
    oprot.writeStructEnd()
7633 
 
7634 
  def validate(self):
7635 
    return
7636 
 
7637 
 
7638 
  def __repr__(self):
7639 
    L = ['%s=%r' % (key, value)
7640 
      for key, value in self.__dict__.iteritems()]
7641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7642 
 
7643 
  def __eq__(self, other):
7644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7645 
 
7646 
  def __ne__(self, other):
7647 
    return not (self == other)
7648 
 
7649 
class getBestSellersCount_result:
7650 
  """
7651 
  Attributes:
7652 
   - success
7653 
   - cex
7654 
  """
7655 
 
7656 
  thrift_spec = (
7657 
    (0, TType.I64, 'success', None, None, ), # 0
7658 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7659 
  )
7660 
 
7661 
  def __init__(self, success=None, cex=None,):
7662 
    self.success = success
7663 
    self.cex = cex
7664 
 
7665 
  def read(self, iprot):
7666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7668 
      return
7669 
    iprot.readStructBegin()
7670 
    while True:
7671 
      (fname, ftype, fid) = iprot.readFieldBegin()
7672 
      if ftype == TType.STOP:
7673 
        break
7674 
      if fid == 0:
7675 
        if ftype == TType.I64:
7676 
          self.success = iprot.readI64();
7677 
        else:
7678 
          iprot.skip(ftype)
7679 
      elif fid == 1:
7680 
        if ftype == TType.STRUCT:
7681 
          self.cex = CatalogServiceException()
7682 
          self.cex.read(iprot)
7683 
        else:
7684 
          iprot.skip(ftype)
7685 
      else:
7686 
        iprot.skip(ftype)
7687 
      iprot.readFieldEnd()
7688 
    iprot.readStructEnd()
7689 
 
7690 
  def write(self, oprot):
7691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7693 
      return
7694 
    oprot.writeStructBegin('getBestSellersCount_result')
7695 
    if self.success is not None:
7696 
      oprot.writeFieldBegin('success', TType.I64, 0)
7697 
      oprot.writeI64(self.success)
7698 
      oprot.writeFieldEnd()
7699 
    if self.cex is not None:
7700 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7701 
      self.cex.write(oprot)
7702 
      oprot.writeFieldEnd()
7703 
    oprot.writeFieldStop()
7704 
    oprot.writeStructEnd()
7705 
 
7706 
  def validate(self):
7707 
    return
7708 
 
7709 
 
7710 
  def __repr__(self):
7711 
    L = ['%s=%r' % (key, value)
7712 
      for key, value in self.__dict__.iteritems()]
7713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7714 
 
7715 
  def __eq__(self, other):
7716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7717 
 
7718 
  def __ne__(self, other):
7719 
    return not (self == other)
7720 
 
7721 
class getBestDeals_args:
7722 
 
7723 
  thrift_spec = (
7724 
  )
7725 
 
7726 
  def read(self, iprot):
7727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7729 
      return
7730 
    iprot.readStructBegin()
7731 
    while True:
7732 
      (fname, ftype, fid) = iprot.readFieldBegin()
7733 
      if ftype == TType.STOP:
7734 
        break
7735 
      else:
7736 
        iprot.skip(ftype)
7737 
      iprot.readFieldEnd()
7738 
    iprot.readStructEnd()
7739 
 
7740 
  def write(self, oprot):
7741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7743 
      return
7744 
    oprot.writeStructBegin('getBestDeals_args')
7745 
    oprot.writeFieldStop()
7746 
    oprot.writeStructEnd()
7747 
 
7748 
  def validate(self):
7749 
    return
7750 
 
7751 
 
7752 
  def __repr__(self):
7753 
    L = ['%s=%r' % (key, value)
7754 
      for key, value in self.__dict__.iteritems()]
7755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7756 
 
7757 
  def __eq__(self, other):
7758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7759 
 
7760 
  def __ne__(self, other):
7761 
    return not (self == other)
7762 
 
7763 
class getBestDeals_result:
7764 
  """
7765 
  Attributes:
7766 
   - success
7767 
   - isex
7768 
  """
7769 
 
7770 
  thrift_spec = (
7771 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7772 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7773 
  )
7774 
 
7775 
  def __init__(self, success=None, isex=None,):
7776 
    self.success = success
7777 
    self.isex = isex
7778 
 
7779 
  def read(self, iprot):
7780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7782 
      return
7783 
    iprot.readStructBegin()
7784 
    while True:
7785 
      (fname, ftype, fid) = iprot.readFieldBegin()
7786 
      if ftype == TType.STOP:
7787 
        break
7788 
      if fid == 0:
7789 
        if ftype == TType.LIST:
7790 
          self.success = []
7791 
          (_etype75, _size72) = iprot.readListBegin()
7792 
          for _i76 in xrange(_size72):
7793 
            _elem77 = Item()
7794 
            _elem77.read(iprot)
7795 
            self.success.append(_elem77)
7796 
          iprot.readListEnd()
7797 
        else:
7798 
          iprot.skip(ftype)
7799 
      elif fid == 1:
7800 
        if ftype == TType.STRUCT:
7801 
          self.isex = CatalogServiceException()
7802 
          self.isex.read(iprot)
7803 
        else:
7804 
          iprot.skip(ftype)
7805 
      else:
7806 
        iprot.skip(ftype)
7807 
      iprot.readFieldEnd()
7808 
    iprot.readStructEnd()
7809 
 
7810 
  def write(self, oprot):
7811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7813 
      return
7814 
    oprot.writeStructBegin('getBestDeals_result')
7815 
    if self.success is not None:
7816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7817 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7818 
      for iter78 in self.success:
7819 
        iter78.write(oprot)
7820 
      oprot.writeListEnd()
7821 
      oprot.writeFieldEnd()
7822 
    if self.isex is not None:
7823 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7824 
      self.isex.write(oprot)
7825 
      oprot.writeFieldEnd()
7826 
    oprot.writeFieldStop()
7827 
    oprot.writeStructEnd()
7828 
 
7829 
  def validate(self):
7830 
    return
7831 
 
7832 
 
7833 
  def __repr__(self):
7834 
    L = ['%s=%r' % (key, value)
7835 
      for key, value in self.__dict__.iteritems()]
7836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7837 
 
7838 
  def __eq__(self, other):
7839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7840 
 
7841 
  def __ne__(self, other):
7842 
    return not (self == other)
7843 
 
7844 
class getBestDealsCatalogIds_args:
7845 
  """
7846 
  Attributes:
7847 
   - beginIndex
7848 
   - totalItems
7849 
   - brand
7850 
   - category
7851 
  """
7852 
 
7853 
  thrift_spec = (
7854 
    None, # 0
7855 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7856 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7857 
    (3, TType.STRING, 'brand', None, None, ), # 3
7858 
    (4, TType.I64, 'category', None, None, ), # 4
7859 
  )
7860 
 
7861 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7862 
    self.beginIndex = beginIndex
7863 
    self.totalItems = totalItems
7864 
    self.brand = brand
7865 
    self.category = category
7866 
 
7867 
  def read(self, iprot):
7868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7870 
      return
7871 
    iprot.readStructBegin()
7872 
    while True:
7873 
      (fname, ftype, fid) = iprot.readFieldBegin()
7874 
      if ftype == TType.STOP:
7875 
        break
7876 
      if fid == 1:
7877 
        if ftype == TType.I64:
7878 
          self.beginIndex = iprot.readI64();
7879 
        else:
7880 
          iprot.skip(ftype)
7881 
      elif fid == 2:
7882 
        if ftype == TType.I64:
7883 
          self.totalItems = iprot.readI64();
7884 
        else:
7885 
          iprot.skip(ftype)
7886 
      elif fid == 3:
7887 
        if ftype == TType.STRING:
7888 
          self.brand = iprot.readString();
7889 
        else:
7890 
          iprot.skip(ftype)
7891 
      elif fid == 4:
7892 
        if ftype == TType.I64:
7893 
          self.category = iprot.readI64();
7894 
        else:
7895 
          iprot.skip(ftype)
7896 
      else:
7897 
        iprot.skip(ftype)
7898 
      iprot.readFieldEnd()
7899 
    iprot.readStructEnd()
7900 
 
7901 
  def write(self, oprot):
7902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7904 
      return
7905 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
7906 
    if self.beginIndex is not None:
7907 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7908 
      oprot.writeI64(self.beginIndex)
7909 
      oprot.writeFieldEnd()
7910 
    if self.totalItems is not None:
7911 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7912 
      oprot.writeI64(self.totalItems)
7913 
      oprot.writeFieldEnd()
7914 
    if self.brand is not None:
7915 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7916 
      oprot.writeString(self.brand)
7917 
      oprot.writeFieldEnd()
7918 
    if self.category is not None:
7919 
      oprot.writeFieldBegin('category', TType.I64, 4)
7920 
      oprot.writeI64(self.category)
7921 
      oprot.writeFieldEnd()
7922 
    oprot.writeFieldStop()
7923 
    oprot.writeStructEnd()
7924 
 
7925 
  def validate(self):
7926 
    return
7927 
 
7928 
 
7929 
  def __repr__(self):
7930 
    L = ['%s=%r' % (key, value)
7931 
      for key, value in self.__dict__.iteritems()]
7932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7933 
 
7934 
  def __eq__(self, other):
7935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7936 
 
7937 
  def __ne__(self, other):
7938 
    return not (self == other)
7939 
 
7940 
class getBestDealsCatalogIds_result:
7941 
  """
7942 
  Attributes:
7943 
   - success
7944 
   - cex
7945 
  """
7946 
 
7947 
  thrift_spec = (
7948 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7949 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7950 
  )
7951 
 
7952 
  def __init__(self, success=None, cex=None,):
7953 
    self.success = success
7954 
    self.cex = cex
7955 
 
7956 
  def read(self, iprot):
7957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7959 
      return
7960 
    iprot.readStructBegin()
7961 
    while True:
7962 
      (fname, ftype, fid) = iprot.readFieldBegin()
7963 
      if ftype == TType.STOP:
7964 
        break
7965 
      if fid == 0:
7966 
        if ftype == TType.LIST:
7967 
          self.success = []
7968 
          (_etype82, _size79) = iprot.readListBegin()
7969 
          for _i83 in xrange(_size79):
7970 
            _elem84 = iprot.readI64();
7971 
            self.success.append(_elem84)
7972 
          iprot.readListEnd()
7973 
        else:
7974 
          iprot.skip(ftype)
7975 
      elif fid == 1:
7976 
        if ftype == TType.STRUCT:
7977 
          self.cex = CatalogServiceException()
7978 
          self.cex.read(iprot)
7979 
        else:
7980 
          iprot.skip(ftype)
7981 
      else:
7982 
        iprot.skip(ftype)
7983 
      iprot.readFieldEnd()
7984 
    iprot.readStructEnd()
7985 
 
7986 
  def write(self, oprot):
7987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7989 
      return
7990 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
7991 
    if self.success is not None:
7992 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7993 
      oprot.writeListBegin(TType.I64, len(self.success))
7994 
      for iter85 in self.success:
7995 
        oprot.writeI64(iter85)
7996 
      oprot.writeListEnd()
7997 
      oprot.writeFieldEnd()
7998 
    if self.cex is not None:
7999 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8000 
      self.cex.write(oprot)
8001 
      oprot.writeFieldEnd()
8002 
    oprot.writeFieldStop()
8003 
    oprot.writeStructEnd()
8004 
 
8005 
  def validate(self):
8006 
    return
8007 
 
8008 
 
8009 
  def __repr__(self):
8010 
    L = ['%s=%r' % (key, value)
8011 
      for key, value in self.__dict__.iteritems()]
8012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8013 
 
8014 
  def __eq__(self, other):
8015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8016 
 
8017 
  def __ne__(self, other):
8018 
    return not (self == other)
8019 
 
8020 
class getBestDealsCount_args:
8021 
 
8022 
  thrift_spec = (
8023 
  )
8024 
 
8025 
  def read(self, iprot):
8026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8028 
      return
8029 
    iprot.readStructBegin()
8030 
    while True:
8031 
      (fname, ftype, fid) = iprot.readFieldBegin()
8032 
      if ftype == TType.STOP:
8033 
        break
8034 
      else:
8035 
        iprot.skip(ftype)
8036 
      iprot.readFieldEnd()
8037 
    iprot.readStructEnd()
8038 
 
8039 
  def write(self, oprot):
8040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8042 
      return
8043 
    oprot.writeStructBegin('getBestDealsCount_args')
8044 
    oprot.writeFieldStop()
8045 
    oprot.writeStructEnd()
8046 
 
8047 
  def validate(self):
8048 
    return
8049 
 
8050 
 
8051 
  def __repr__(self):
8052 
    L = ['%s=%r' % (key, value)
8053 
      for key, value in self.__dict__.iteritems()]
8054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8055 
 
8056 
  def __eq__(self, other):
8057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8058 
 
8059 
  def __ne__(self, other):
8060 
    return not (self == other)
8061 
 
8062 
class getBestDealsCount_result:
8063 
  """
8064 
  Attributes:
8065 
   - success
8066 
   - cex
8067 
  """
8068 
 
8069 
  thrift_spec = (
8070 
    (0, TType.I64, 'success', None, None, ), # 0
8071 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8072 
  )
8073 
 
8074 
  def __init__(self, success=None, cex=None,):
8075 
    self.success = success
8076 
    self.cex = cex
8077 
 
8078 
  def read(self, iprot):
8079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8081 
      return
8082 
    iprot.readStructBegin()
8083 
    while True:
8084 
      (fname, ftype, fid) = iprot.readFieldBegin()
8085 
      if ftype == TType.STOP:
8086 
        break
8087 
      if fid == 0:
8088 
        if ftype == TType.I64:
8089 
          self.success = iprot.readI64();
8090 
        else:
8091 
          iprot.skip(ftype)
8092 
      elif fid == 1:
8093 
        if ftype == TType.STRUCT:
8094 
          self.cex = CatalogServiceException()
8095 
          self.cex.read(iprot)
8096 
        else:
8097 
          iprot.skip(ftype)
8098 
      else:
8099 
        iprot.skip(ftype)
8100 
      iprot.readFieldEnd()
8101 
    iprot.readStructEnd()
8102 
 
8103 
  def write(self, oprot):
8104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8106 
      return
8107 
    oprot.writeStructBegin('getBestDealsCount_result')
8108 
    if self.success is not None:
8109 
      oprot.writeFieldBegin('success', TType.I64, 0)
8110 
      oprot.writeI64(self.success)
8111 
      oprot.writeFieldEnd()
8112 
    if self.cex is not None:
8113 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8114 
      self.cex.write(oprot)
8115 
      oprot.writeFieldEnd()
8116 
    oprot.writeFieldStop()
8117 
    oprot.writeStructEnd()
8118 
 
8119 
  def validate(self):
8120 
    return
8121 
 
8122 
 
8123 
  def __repr__(self):
8124 
    L = ['%s=%r' % (key, value)
8125 
      for key, value in self.__dict__.iteritems()]
8126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8127 
 
8128 
  def __eq__(self, other):
8129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8130 
 
8131 
  def __ne__(self, other):
8132 
    return not (self == other)
8133 
 
8134 
class getComingSoon_args:
8135 
 
8136 
  thrift_spec = (
8137 
  )
8138 
 
8139 
  def read(self, iprot):
8140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8142 
      return
8143 
    iprot.readStructBegin()
8144 
    while True:
8145 
      (fname, ftype, fid) = iprot.readFieldBegin()
8146 
      if ftype == TType.STOP:
8147 
        break
8148 
      else:
8149 
        iprot.skip(ftype)
8150 
      iprot.readFieldEnd()
8151 
    iprot.readStructEnd()
8152 
 
8153 
  def write(self, oprot):
8154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8156 
      return
8157 
    oprot.writeStructBegin('getComingSoon_args')
8158 
    oprot.writeFieldStop()
8159 
    oprot.writeStructEnd()
8160 
 
8161 
  def validate(self):
8162 
    return
8163 
 
8164 
 
8165 
  def __repr__(self):
8166 
    L = ['%s=%r' % (key, value)
8167 
      for key, value in self.__dict__.iteritems()]
8168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8169 
 
8170 
  def __eq__(self, other):
8171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8172 
 
8173 
  def __ne__(self, other):
8174 
    return not (self == other)
8175 
 
8176 
class getComingSoon_result:
8177 
  """
8178 
  Attributes:
8179 
   - success
8180 
   - isex
8181 
  """
8182 
 
8183 
  thrift_spec = (
8184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8185 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8186 
  )
8187 
 
8188 
  def __init__(self, success=None, isex=None,):
8189 
    self.success = success
8190 
    self.isex = isex
8191 
 
8192 
  def read(self, iprot):
8193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8195 
      return
8196 
    iprot.readStructBegin()
8197 
    while True:
8198 
      (fname, ftype, fid) = iprot.readFieldBegin()
8199 
      if ftype == TType.STOP:
8200 
        break
8201 
      if fid == 0:
8202 
        if ftype == TType.LIST:
8203 
          self.success = []
8204 
          (_etype89, _size86) = iprot.readListBegin()
8205 
          for _i90 in xrange(_size86):
8206 
            _elem91 = Item()
8207 
            _elem91.read(iprot)
8208 
            self.success.append(_elem91)
8209 
          iprot.readListEnd()
8210 
        else:
8211 
          iprot.skip(ftype)
8212 
      elif fid == 1:
8213 
        if ftype == TType.STRUCT:
8214 
          self.isex = CatalogServiceException()
8215 
          self.isex.read(iprot)
8216 
        else:
8217 
          iprot.skip(ftype)
8218 
      else:
8219 
        iprot.skip(ftype)
8220 
      iprot.readFieldEnd()
8221 
    iprot.readStructEnd()
8222 
 
8223 
  def write(self, oprot):
8224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8226 
      return
8227 
    oprot.writeStructBegin('getComingSoon_result')
8228 
    if self.success is not None:
8229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8231 
      for iter92 in self.success:
8232 
        iter92.write(oprot)
8233 
      oprot.writeListEnd()
8234 
      oprot.writeFieldEnd()
8235 
    if self.isex is not None:
8236 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8237 
      self.isex.write(oprot)
8238 
      oprot.writeFieldEnd()
8239 
    oprot.writeFieldStop()
8240 
    oprot.writeStructEnd()
8241 
 
8242 
  def validate(self):
8243 
    return
8244 
 
8245 
 
8246 
  def __repr__(self):
8247 
    L = ['%s=%r' % (key, value)
8248 
      for key, value in self.__dict__.iteritems()]
8249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8250 
 
8251 
  def __eq__(self, other):
8252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8253 
 
8254 
  def __ne__(self, other):
8255 
    return not (self == other)
8256 
 
8257 
class getComingSoonCatalogIds_args:
8258 
  """
8259 
  Attributes:
8260 
   - beginIndex
8261 
   - totalItems
8262 
   - brand
8263 
   - category
8264 
  """
8265 
 
8266 
  thrift_spec = (
8267 
    None, # 0
8268 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8269 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8270 
    (3, TType.STRING, 'brand', None, None, ), # 3
8271 
    (4, TType.I64, 'category', None, None, ), # 4
8272 
  )
8273 
 
8274 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8275 
    self.beginIndex = beginIndex
8276 
    self.totalItems = totalItems
8277 
    self.brand = brand
8278 
    self.category = category
8279 
 
8280 
  def read(self, iprot):
8281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8283 
      return
8284 
    iprot.readStructBegin()
8285 
    while True:
8286 
      (fname, ftype, fid) = iprot.readFieldBegin()
8287 
      if ftype == TType.STOP:
8288 
        break
8289 
      if fid == 1:
8290 
        if ftype == TType.I64:
8291 
          self.beginIndex = iprot.readI64();
8292 
        else:
8293 
          iprot.skip(ftype)
8294 
      elif fid == 2:
8295 
        if ftype == TType.I64:
8296 
          self.totalItems = iprot.readI64();
8297 
        else:
8298 
          iprot.skip(ftype)
8299 
      elif fid == 3:
8300 
        if ftype == TType.STRING:
8301 
          self.brand = iprot.readString();
8302 
        else:
8303 
          iprot.skip(ftype)
8304 
      elif fid == 4:
8305 
        if ftype == TType.I64:
8306 
          self.category = iprot.readI64();
8307 
        else:
8308 
          iprot.skip(ftype)
8309 
      else:
8310 
        iprot.skip(ftype)
8311 
      iprot.readFieldEnd()
8312 
    iprot.readStructEnd()
8313 
 
8314 
  def write(self, oprot):
8315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8317 
      return
8318 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8319 
    if self.beginIndex is not None:
8320 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8321 
      oprot.writeI64(self.beginIndex)
8322 
      oprot.writeFieldEnd()
8323 
    if self.totalItems is not None:
8324 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8325 
      oprot.writeI64(self.totalItems)
8326 
      oprot.writeFieldEnd()
8327 
    if self.brand is not None:
8328 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8329 
      oprot.writeString(self.brand)
8330 
      oprot.writeFieldEnd()
8331 
    if self.category is not None:
8332 
      oprot.writeFieldBegin('category', TType.I64, 4)
8333 
      oprot.writeI64(self.category)
8334 
      oprot.writeFieldEnd()
8335 
    oprot.writeFieldStop()
8336 
    oprot.writeStructEnd()
8337 
 
8338 
  def validate(self):
8339 
    return
8340 
 
8341 
 
8342 
  def __repr__(self):
8343 
    L = ['%s=%r' % (key, value)
8344 
      for key, value in self.__dict__.iteritems()]
8345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8346 
 
8347 
  def __eq__(self, other):
8348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8349 
 
8350 
  def __ne__(self, other):
8351 
    return not (self == other)
8352 
 
8353 
class getComingSoonCatalogIds_result:
8354 
  """
8355 
  Attributes:
8356 
   - success
8357 
   - cex
8358 
  """
8359 
 
8360 
  thrift_spec = (
8361 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8362 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8363 
  )
8364 
 
8365 
  def __init__(self, success=None, cex=None,):
8366 
    self.success = success
8367 
    self.cex = cex
8368 
 
8369 
  def read(self, iprot):
8370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8372 
      return
8373 
    iprot.readStructBegin()
8374 
    while True:
8375 
      (fname, ftype, fid) = iprot.readFieldBegin()
8376 
      if ftype == TType.STOP:
8377 
        break
8378 
      if fid == 0:
8379 
        if ftype == TType.LIST:
8380 
          self.success = []
8381 
          (_etype96, _size93) = iprot.readListBegin()
8382 
          for _i97 in xrange(_size93):
8383 
            _elem98 = iprot.readI64();
8384 
            self.success.append(_elem98)
8385 
          iprot.readListEnd()
8386 
        else:
8387 
          iprot.skip(ftype)
8388 
      elif fid == 1:
8389 
        if ftype == TType.STRUCT:
8390 
          self.cex = CatalogServiceException()
8391 
          self.cex.read(iprot)
8392 
        else:
8393 
          iprot.skip(ftype)
8394 
      else:
8395 
        iprot.skip(ftype)
8396 
      iprot.readFieldEnd()
8397 
    iprot.readStructEnd()
8398 
 
8399 
  def write(self, oprot):
8400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8402 
      return
8403 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8404 
    if self.success is not None:
8405 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8406 
      oprot.writeListBegin(TType.I64, len(self.success))
8407 
      for iter99 in self.success:
8408 
        oprot.writeI64(iter99)
8409 
      oprot.writeListEnd()
8410 
      oprot.writeFieldEnd()
8411 
    if self.cex is not None:
8412 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8413 
      self.cex.write(oprot)
8414 
      oprot.writeFieldEnd()
8415 
    oprot.writeFieldStop()
8416 
    oprot.writeStructEnd()
8417 
 
8418 
  def validate(self):
8419 
    return
8420 
 
8421 
 
8422 
  def __repr__(self):
8423 
    L = ['%s=%r' % (key, value)
8424 
      for key, value in self.__dict__.iteritems()]
8425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8426 
 
8427 
  def __eq__(self, other):
8428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8429 
 
8430 
  def __ne__(self, other):
8431 
    return not (self == other)
8432 
 
8433 
class getComingSoonCount_args:
8434 
 
8435 
  thrift_spec = (
8436 
  )
8437 
 
8438 
  def read(self, iprot):
8439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8441 
      return
8442 
    iprot.readStructBegin()
8443 
    while True:
8444 
      (fname, ftype, fid) = iprot.readFieldBegin()
8445 
      if ftype == TType.STOP:
8446 
        break
8447 
      else:
8448 
        iprot.skip(ftype)
8449 
      iprot.readFieldEnd()
8450 
    iprot.readStructEnd()
8451 
 
8452 
  def write(self, oprot):
8453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8455 
      return
8456 
    oprot.writeStructBegin('getComingSoonCount_args')
8457 
    oprot.writeFieldStop()
8458 
    oprot.writeStructEnd()
8459 
 
8460 
  def validate(self):
8461 
    return
8462 
 
8463 
 
8464 
  def __repr__(self):
8465 
    L = ['%s=%r' % (key, value)
8466 
      for key, value in self.__dict__.iteritems()]
8467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8468 
 
8469 
  def __eq__(self, other):
8470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8471 
 
8472 
  def __ne__(self, other):
8473 
    return not (self == other)
8474 
 
8475 
class getComingSoonCount_result:
8476 
  """
8477 
  Attributes:
8478 
   - success
8479 
   - cex
8480 
  """
8481 
 
8482 
  thrift_spec = (
8483 
    (0, TType.I64, 'success', None, None, ), # 0
8484 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8485 
  )
8486 
 
8487 
  def __init__(self, success=None, cex=None,):
8488 
    self.success = success
8489 
    self.cex = cex
8490 
 
8491 
  def read(self, iprot):
8492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8494 
      return
8495 
    iprot.readStructBegin()
8496 
    while True:
8497 
      (fname, ftype, fid) = iprot.readFieldBegin()
8498 
      if ftype == TType.STOP:
8499 
        break
8500 
      if fid == 0:
8501 
        if ftype == TType.I64:
8502 
          self.success = iprot.readI64();
8503 
        else:
8504 
          iprot.skip(ftype)
8505 
      elif fid == 1:
8506 
        if ftype == TType.STRUCT:
8507 
          self.cex = CatalogServiceException()
8508 
          self.cex.read(iprot)
8509 
        else:
8510 
          iprot.skip(ftype)
8511 
      else:
8512 
        iprot.skip(ftype)
8513 
      iprot.readFieldEnd()
8514 
    iprot.readStructEnd()
8515 
 
8516 
  def write(self, oprot):
8517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8519 
      return
8520 
    oprot.writeStructBegin('getComingSoonCount_result')
8521 
    if self.success is not None:
8522 
      oprot.writeFieldBegin('success', TType.I64, 0)
8523 
      oprot.writeI64(self.success)
8524 
      oprot.writeFieldEnd()
8525 
    if self.cex is not None:
8526 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8527 
      self.cex.write(oprot)
8528 
      oprot.writeFieldEnd()
8529 
    oprot.writeFieldStop()
8530 
    oprot.writeStructEnd()
8531 
 
8532 
  def validate(self):
8533 
    return
8534 
 
8535 
 
8536 
  def __repr__(self):
8537 
    L = ['%s=%r' % (key, value)
8538 
      for key, value in self.__dict__.iteritems()]
8539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8540 
 
8541 
  def __eq__(self, other):
8542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8543 
 
8544 
  def __ne__(self, other):
8545 
    return not (self == other)
8546 
 
8547 
class getLatestArrivals_args:
8548 
 
8549 
  thrift_spec = (
8550 
  )
8551 
 
8552 
  def read(self, iprot):
8553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8555 
      return
8556 
    iprot.readStructBegin()
8557 
    while True:
8558 
      (fname, ftype, fid) = iprot.readFieldBegin()
8559 
      if ftype == TType.STOP:
8560 
        break
8561 
      else:
8562 
        iprot.skip(ftype)
8563 
      iprot.readFieldEnd()
8564 
    iprot.readStructEnd()
8565 
 
8566 
  def write(self, oprot):
8567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8569 
      return
8570 
    oprot.writeStructBegin('getLatestArrivals_args')
8571 
    oprot.writeFieldStop()
8572 
    oprot.writeStructEnd()
8573 
 
8574 
  def validate(self):
8575 
    return
8576 
 
8577 
 
8578 
  def __repr__(self):
8579 
    L = ['%s=%r' % (key, value)
8580 
      for key, value in self.__dict__.iteritems()]
8581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8582 
 
8583 
  def __eq__(self, other):
8584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8585 
 
8586 
  def __ne__(self, other):
8587 
    return not (self == other)
8588 
 
8589 
class getLatestArrivals_result:
8590 
  """
8591 
  Attributes:
8592 
   - success
8593 
   - isex
8594 
  """
8595 
 
8596 
  thrift_spec = (
8597 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8598 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8599 
  )
8600 
 
8601 
  def __init__(self, success=None, isex=None,):
8602 
    self.success = success
8603 
    self.isex = isex
8604 
 
8605 
  def read(self, iprot):
8606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8608 
      return
8609 
    iprot.readStructBegin()
8610 
    while True:
8611 
      (fname, ftype, fid) = iprot.readFieldBegin()
8612 
      if ftype == TType.STOP:
8613 
        break
8614 
      if fid == 0:
8615 
        if ftype == TType.LIST:
8616 
          self.success = []
8617 
          (_etype103, _size100) = iprot.readListBegin()
8618 
          for _i104 in xrange(_size100):
8619 
            _elem105 = Item()
8620 
            _elem105.read(iprot)
8621 
            self.success.append(_elem105)
8622 
          iprot.readListEnd()
8623 
        else:
8624 
          iprot.skip(ftype)
8625 
      elif fid == 1:
8626 
        if ftype == TType.STRUCT:
8627 
          self.isex = CatalogServiceException()
8628 
          self.isex.read(iprot)
8629 
        else:
8630 
          iprot.skip(ftype)
8631 
      else:
8632 
        iprot.skip(ftype)
8633 
      iprot.readFieldEnd()
8634 
    iprot.readStructEnd()
8635 
 
8636 
  def write(self, oprot):
8637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8639 
      return
8640 
    oprot.writeStructBegin('getLatestArrivals_result')
8641 
    if self.success is not None:
8642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8643 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8644 
      for iter106 in self.success:
8645 
        iter106.write(oprot)
8646 
      oprot.writeListEnd()
8647 
      oprot.writeFieldEnd()
8648 
    if self.isex is not None:
8649 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8650 
      self.isex.write(oprot)
8651 
      oprot.writeFieldEnd()
8652 
    oprot.writeFieldStop()
8653 
    oprot.writeStructEnd()
8654 
 
8655 
  def validate(self):
8656 
    return
8657 
 
8658 
 
8659 
  def __repr__(self):
8660 
    L = ['%s=%r' % (key, value)
8661 
      for key, value in self.__dict__.iteritems()]
8662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8663 
 
8664 
  def __eq__(self, other):
8665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8666 
 
8667 
  def __ne__(self, other):
8668 
    return not (self == other)
8669 
 
8670 
class getLatestArrivalsCatalogIds_args:
8671 
  """
8672 
  Attributes:
8673 
   - beginIndex
8674 
   - totalItems
8675 
   - brand
8676 
   - categories
8677 
  """
8678 
 
8679 
  thrift_spec = (
8680 
    None, # 0
8681 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8682 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8683 
    (3, TType.STRING, 'brand', None, None, ), # 3
8684 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8685 
  )
8686 
 
8687 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8688 
    self.beginIndex = beginIndex
8689 
    self.totalItems = totalItems
8690 
    self.brand = brand
8691 
    self.categories = categories
8692 
 
8693 
  def read(self, iprot):
8694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8696 
      return
8697 
    iprot.readStructBegin()
8698 
    while True:
8699 
      (fname, ftype, fid) = iprot.readFieldBegin()
8700 
      if ftype == TType.STOP:
8701 
        break
8702 
      if fid == 1:
8703 
        if ftype == TType.I64:
8704 
          self.beginIndex = iprot.readI64();
8705 
        else:
8706 
          iprot.skip(ftype)
8707 
      elif fid == 2:
8708 
        if ftype == TType.I64:
8709 
          self.totalItems = iprot.readI64();
8710 
        else:
8711 
          iprot.skip(ftype)
8712 
      elif fid == 3:
8713 
        if ftype == TType.STRING:
8714 
          self.brand = iprot.readString();
8715 
        else:
8716 
          iprot.skip(ftype)
8717 
      elif fid == 4:
8718 
        if ftype == TType.LIST:
8719 
          self.categories = []
8720 
          (_etype110, _size107) = iprot.readListBegin()
8721 
          for _i111 in xrange(_size107):
8722 
            _elem112 = iprot.readI64();
8723 
            self.categories.append(_elem112)
8724 
          iprot.readListEnd()
8725 
        else:
8726 
          iprot.skip(ftype)
8727 
      else:
8728 
        iprot.skip(ftype)
8729 
      iprot.readFieldEnd()
8730 
    iprot.readStructEnd()
8731 
 
8732 
  def write(self, oprot):
8733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8735 
      return
8736 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8737 
    if self.beginIndex is not None:
8738 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8739 
      oprot.writeI64(self.beginIndex)
8740 
      oprot.writeFieldEnd()
8741 
    if self.totalItems is not None:
8742 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8743 
      oprot.writeI64(self.totalItems)
8744 
      oprot.writeFieldEnd()
8745 
    if self.brand is not None:
8746 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8747 
      oprot.writeString(self.brand)
8748 
      oprot.writeFieldEnd()
8749 
    if self.categories is not None:
8750 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8751 
      oprot.writeListBegin(TType.I64, len(self.categories))
8752 
      for iter113 in self.categories:
8753 
        oprot.writeI64(iter113)
8754 
      oprot.writeListEnd()
8755 
      oprot.writeFieldEnd()
8756 
    oprot.writeFieldStop()
8757 
    oprot.writeStructEnd()
8758 
 
8759 
  def validate(self):
8760 
    return
8761 
 
8762 
 
8763 
  def __repr__(self):
8764 
    L = ['%s=%r' % (key, value)
8765 
      for key, value in self.__dict__.iteritems()]
8766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8767 
 
8768 
  def __eq__(self, other):
8769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8770 
 
8771 
  def __ne__(self, other):
8772 
    return not (self == other)
8773 
 
8774 
class getLatestArrivalsCatalogIds_result:
8775 
  """
8776 
  Attributes:
8777 
   - success
8778 
   - cex
8779 
  """
8780 
 
8781 
  thrift_spec = (
8782 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8783 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8784 
  )
8785 
 
8786 
  def __init__(self, success=None, cex=None,):
8787 
    self.success = success
8788 
    self.cex = cex
8789 
 
8790 
  def read(self, iprot):
8791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8793 
      return
8794 
    iprot.readStructBegin()
8795 
    while True:
8796 
      (fname, ftype, fid) = iprot.readFieldBegin()
8797 
      if ftype == TType.STOP:
8798 
        break
8799 
      if fid == 0:
8800 
        if ftype == TType.LIST:
8801 
          self.success = []
8802 
          (_etype117, _size114) = iprot.readListBegin()
8803 
          for _i118 in xrange(_size114):
8804 
            _elem119 = iprot.readI64();
8805 
            self.success.append(_elem119)
8806 
          iprot.readListEnd()
8807 
        else:
8808 
          iprot.skip(ftype)
8809 
      elif fid == 1:
8810 
        if ftype == TType.STRUCT:
8811 
          self.cex = CatalogServiceException()
8812 
          self.cex.read(iprot)
8813 
        else:
8814 
          iprot.skip(ftype)
8815 
      else:
8816 
        iprot.skip(ftype)
8817 
      iprot.readFieldEnd()
8818 
    iprot.readStructEnd()
8819 
 
8820 
  def write(self, oprot):
8821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8823 
      return
8824 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
8825 
    if self.success is not None:
8826 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8827 
      oprot.writeListBegin(TType.I64, len(self.success))
8828 
      for iter120 in self.success:
8829 
        oprot.writeI64(iter120)
8830 
      oprot.writeListEnd()
8831 
      oprot.writeFieldEnd()
8832 
    if self.cex is not None:
8833 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8834 
      self.cex.write(oprot)
8835 
      oprot.writeFieldEnd()
8836 
    oprot.writeFieldStop()
8837 
    oprot.writeStructEnd()
8838 
 
8839 
  def validate(self):
8840 
    return
8841 
 
8842 
 
8843 
  def __repr__(self):
8844 
    L = ['%s=%r' % (key, value)
8845 
      for key, value in self.__dict__.iteritems()]
8846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8847 
 
8848 
  def __eq__(self, other):
8849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8850 
 
8851 
  def __ne__(self, other):
8852 
    return not (self == other)
8853 
 
8854 
class getLatestArrivalsCount_args:
8855 
 
8856 
  thrift_spec = (
8857 
  )
8858 
 
8859 
  def read(self, iprot):
8860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8862 
      return
8863 
    iprot.readStructBegin()
8864 
    while True:
8865 
      (fname, ftype, fid) = iprot.readFieldBegin()
8866 
      if ftype == TType.STOP:
8867 
        break
8868 
      else:
8869 
        iprot.skip(ftype)
8870 
      iprot.readFieldEnd()
8871 
    iprot.readStructEnd()
8872 
 
8873 
  def write(self, oprot):
8874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8876 
      return
8877 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
8878 
    oprot.writeFieldStop()
8879 
    oprot.writeStructEnd()
8880 
 
8881 
  def validate(self):
8882 
    return
8883 
 
8884 
 
8885 
  def __repr__(self):
8886 
    L = ['%s=%r' % (key, value)
8887 
      for key, value in self.__dict__.iteritems()]
8888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8889 
 
8890 
  def __eq__(self, other):
8891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8892 
 
8893 
  def __ne__(self, other):
8894 
    return not (self == other)
8895 
 
8896 
class getLatestArrivalsCount_result:
8897 
  """
8898 
  Attributes:
8899 
   - success
8900 
   - cex
8901 
  """
8902 
 
8903 
  thrift_spec = (
8904 
    (0, TType.I64, 'success', None, None, ), # 0
8905 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8906 
  )
8907 
 
8908 
  def __init__(self, success=None, cex=None,):
8909 
    self.success = success
8910 
    self.cex = cex
8911 
 
8912 
  def read(self, iprot):
8913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8915 
      return
8916 
    iprot.readStructBegin()
8917 
    while True:
8918 
      (fname, ftype, fid) = iprot.readFieldBegin()
8919 
      if ftype == TType.STOP:
8920 
        break
8921 
      if fid == 0:
8922 
        if ftype == TType.I64:
8923 
          self.success = iprot.readI64();
8924 
        else:
8925 
          iprot.skip(ftype)
8926 
      elif fid == 1:
8927 
        if ftype == TType.STRUCT:
8928 
          self.cex = CatalogServiceException()
8929 
          self.cex.read(iprot)
8930 
        else:
8931 
          iprot.skip(ftype)
8932 
      else:
8933 
        iprot.skip(ftype)
8934 
      iprot.readFieldEnd()
8935 
    iprot.readStructEnd()
8936 
 
8937 
  def write(self, oprot):
8938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8940 
      return
8941 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
8942 
    if self.success is not None:
8943 
      oprot.writeFieldBegin('success', TType.I64, 0)
8944 
      oprot.writeI64(self.success)
8945 
      oprot.writeFieldEnd()
8946 
    if self.cex is not None:
8947 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8948 
      self.cex.write(oprot)
8949 
      oprot.writeFieldEnd()
8950 
    oprot.writeFieldStop()
8951 
    oprot.writeStructEnd()
8952 
 
8953 
  def validate(self):
8954 
    return
8955 
 
8956 
 
8957 
  def __repr__(self):
8958 
    L = ['%s=%r' % (key, value)
8959 
      for key, value in self.__dict__.iteritems()]
8960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8961 
 
8962 
  def __eq__(self, other):
8963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8964 
 
8965 
  def __ne__(self, other):
8966 
    return not (self == other)
8967 
 
8968 
class generateNewEntityID_args:
8969 
 
8970 
  thrift_spec = (
8971 
  )
8972 
 
8973 
  def read(self, iprot):
8974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8976 
      return
8977 
    iprot.readStructBegin()
8978 
    while True:
8979 
      (fname, ftype, fid) = iprot.readFieldBegin()
8980 
      if ftype == TType.STOP:
8981 
        break
8982 
      else:
8983 
        iprot.skip(ftype)
8984 
      iprot.readFieldEnd()
8985 
    iprot.readStructEnd()
8986 
 
8987 
  def write(self, oprot):
8988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8990 
      return
8991 
    oprot.writeStructBegin('generateNewEntityID_args')
8992 
    oprot.writeFieldStop()
8993 
    oprot.writeStructEnd()
8994 
 
8995 
  def validate(self):
8996 
    return
8997 
 
8998 
 
8999 
  def __repr__(self):
9000 
    L = ['%s=%r' % (key, value)
9001 
      for key, value in self.__dict__.iteritems()]
9002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9003 
 
9004 
  def __eq__(self, other):
9005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9006 
 
9007 
  def __ne__(self, other):
9008 
    return not (self == other)
9009 
 
9010 
class generateNewEntityID_result:
9011 
  """
9012 
  Attributes:
9013 
   - success
9014 
  """
9015 
 
9016 
  thrift_spec = (
9017 
    (0, TType.I64, 'success', None, None, ), # 0
9018 
  )
9019 
 
9020 
  def __init__(self, success=None,):
9021 
    self.success = success
9022 
 
9023 
  def read(self, iprot):
9024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9026 
      return
9027 
    iprot.readStructBegin()
9028 
    while True:
9029 
      (fname, ftype, fid) = iprot.readFieldBegin()
9030 
      if ftype == TType.STOP:
9031 
        break
9032 
      if fid == 0:
9033 
        if ftype == TType.I64:
9034 
          self.success = iprot.readI64();
9035 
        else:
9036 
          iprot.skip(ftype)
9037 
      else:
9038 
        iprot.skip(ftype)
9039 
      iprot.readFieldEnd()
9040 
    iprot.readStructEnd()
9041 
 
9042 
  def write(self, oprot):
9043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9045 
      return
9046 
    oprot.writeStructBegin('generateNewEntityID_result')
9047 
    if self.success is not None:
9048 
      oprot.writeFieldBegin('success', TType.I64, 0)
9049 
      oprot.writeI64(self.success)
9050 
      oprot.writeFieldEnd()
9051 
    oprot.writeFieldStop()
9052 
    oprot.writeStructEnd()
9053 
 
9054 
  def validate(self):
9055 
    return
9056 
 
9057 
 
9058 
  def __repr__(self):
9059 
    L = ['%s=%r' % (key, value)
9060 
      for key, value in self.__dict__.iteritems()]
9061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9062 
 
9063 
  def __eq__(self, other):
9064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9065 
 
9066 
  def __ne__(self, other):
9067 
    return not (self == other)
9068 
 
9069 
class addCategory_args:
9070 
  """
9071 
  Attributes:
9072 
   - category
9073 
  """
9074 
 
9075 
  thrift_spec = (
9076 
    None, # 0
9077 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9078 
  )
9079 
 
9080 
  def __init__(self, category=None,):
9081 
    self.category = category
9082 
 
9083 
  def read(self, iprot):
9084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9086 
      return
9087 
    iprot.readStructBegin()
9088 
    while True:
9089 
      (fname, ftype, fid) = iprot.readFieldBegin()
9090 
      if ftype == TType.STOP:
9091 
        break
9092 
      if fid == 1:
9093 
        if ftype == TType.STRUCT:
9094 
          self.category = Category()
9095 
          self.category.read(iprot)
9096 
        else:
9097 
          iprot.skip(ftype)
9098 
      else:
9099 
        iprot.skip(ftype)
9100 
      iprot.readFieldEnd()
9101 
    iprot.readStructEnd()
9102 
 
9103 
  def write(self, oprot):
9104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9106 
      return
9107 
    oprot.writeStructBegin('addCategory_args')
9108 
    if self.category is not None:
9109 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9110 
      self.category.write(oprot)
9111 
      oprot.writeFieldEnd()
9112 
    oprot.writeFieldStop()
9113 
    oprot.writeStructEnd()
9114 
 
9115 
  def validate(self):
9116 
    return
9117 
 
9118 
 
9119 
  def __repr__(self):
9120 
    L = ['%s=%r' % (key, value)
9121 
      for key, value in self.__dict__.iteritems()]
9122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9123 
 
9124 
  def __eq__(self, other):
9125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9126 
 
9127 
  def __ne__(self, other):
9128 
    return not (self == other)
9129 
 
9130 
class addCategory_result:
9131 
  """
9132 
  Attributes:
9133 
   - success
9134 
  """
9135 
 
9136 
  thrift_spec = (
9137 
    (0, TType.BOOL, 'success', None, None, ), # 0
9138 
  )
9139 
 
9140 
  def __init__(self, success=None,):
9141 
    self.success = success
9142 
 
9143 
  def read(self, iprot):
9144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9146 
      return
9147 
    iprot.readStructBegin()
9148 
    while True:
9149 
      (fname, ftype, fid) = iprot.readFieldBegin()
9150 
      if ftype == TType.STOP:
9151 
        break
9152 
      if fid == 0:
9153 
        if ftype == TType.BOOL:
9154 
          self.success = iprot.readBool();
9155 
        else:
9156 
          iprot.skip(ftype)
9157 
      else:
9158 
        iprot.skip(ftype)
9159 
      iprot.readFieldEnd()
9160 
    iprot.readStructEnd()
9161 
 
9162 
  def write(self, oprot):
9163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9165 
      return
9166 
    oprot.writeStructBegin('addCategory_result')
9167 
    if self.success is not None:
9168 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9169 
      oprot.writeBool(self.success)
9170 
      oprot.writeFieldEnd()
9171 
    oprot.writeFieldStop()
9172 
    oprot.writeStructEnd()
9173 
 
9174 
  def validate(self):
9175 
    return
9176 
 
9177 
 
9178 
  def __repr__(self):
9179 
    L = ['%s=%r' % (key, value)
9180 
      for key, value in self.__dict__.iteritems()]
9181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9182 
 
9183 
  def __eq__(self, other):
9184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9185 
 
9186 
  def __ne__(self, other):
9187 
    return not (self == other)
9188 
 
9189 
class getCategory_args:
9190 
  """
9191 
  Attributes:
9192 
   - id
9193 
  """
9194 
 
9195 
  thrift_spec = (
9196 
    None, # 0
9197 
    (1, TType.I64, 'id', None, None, ), # 1
9198 
  )
9199 
 
9200 
  def __init__(self, id=None,):
9201 
    self.id = id
9202 
 
9203 
  def read(self, iprot):
9204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9206 
      return
9207 
    iprot.readStructBegin()
9208 
    while True:
9209 
      (fname, ftype, fid) = iprot.readFieldBegin()
9210 
      if ftype == TType.STOP:
9211 
        break
9212 
      if fid == 1:
9213 
        if ftype == TType.I64:
9214 
          self.id = iprot.readI64();
9215 
        else:
9216 
          iprot.skip(ftype)
9217 
      else:
9218 
        iprot.skip(ftype)
9219 
      iprot.readFieldEnd()
9220 
    iprot.readStructEnd()
9221 
 
9222 
  def write(self, oprot):
9223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9225 
      return
9226 
    oprot.writeStructBegin('getCategory_args')
9227 
    if self.id is not None:
9228 
      oprot.writeFieldBegin('id', TType.I64, 1)
9229 
      oprot.writeI64(self.id)
9230 
      oprot.writeFieldEnd()
9231 
    oprot.writeFieldStop()
9232 
    oprot.writeStructEnd()
9233 
 
9234 
  def validate(self):
9235 
    return
9236 
 
9237 
 
9238 
  def __repr__(self):
9239 
    L = ['%s=%r' % (key, value)
9240 
      for key, value in self.__dict__.iteritems()]
9241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9242 
 
9243 
  def __eq__(self, other):
9244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9245 
 
9246 
  def __ne__(self, other):
9247 
    return not (self == other)
9248 
 
9249 
class getCategory_result:
9250 
  """
9251 
  Attributes:
9252 
   - success
9253 
  """
9254 
 
9255 
  thrift_spec = (
9256 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9257 
  )
9258 
 
9259 
  def __init__(self, success=None,):
9260 
    self.success = success
9261 
 
9262 
  def read(self, iprot):
9263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9265 
      return
9266 
    iprot.readStructBegin()
9267 
    while True:
9268 
      (fname, ftype, fid) = iprot.readFieldBegin()
9269 
      if ftype == TType.STOP:
9270 
        break
9271 
      if fid == 0:
9272 
        if ftype == TType.STRUCT:
9273 
          self.success = Category()
9274 
          self.success.read(iprot)
9275 
        else:
9276 
          iprot.skip(ftype)
9277 
      else:
9278 
        iprot.skip(ftype)
9279 
      iprot.readFieldEnd()
9280 
    iprot.readStructEnd()
9281 
 
9282 
  def write(self, oprot):
9283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9285 
      return
9286 
    oprot.writeStructBegin('getCategory_result')
9287 
    if self.success is not None:
9288 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9289 
      self.success.write(oprot)
9290 
      oprot.writeFieldEnd()
9291 
    oprot.writeFieldStop()
9292 
    oprot.writeStructEnd()
9293 
 
9294 
  def validate(self):
9295 
    return
9296 
 
9297 
 
9298 
  def __repr__(self):
9299 
    L = ['%s=%r' % (key, value)
9300 
      for key, value in self.__dict__.iteritems()]
9301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9302 
 
9303 
  def __eq__(self, other):
9304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9305 
 
9306 
  def __ne__(self, other):
9307 
    return not (self == other)
9308 
 
9309 
class getAllCategories_args:
9310 
 
9311 
  thrift_spec = (
9312 
  )
9313 
 
9314 
  def read(self, iprot):
9315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9317 
      return
9318 
    iprot.readStructBegin()
9319 
    while True:
9320 
      (fname, ftype, fid) = iprot.readFieldBegin()
9321 
      if ftype == TType.STOP:
9322 
        break
9323 
      else:
9324 
        iprot.skip(ftype)
9325 
      iprot.readFieldEnd()
9326 
    iprot.readStructEnd()
9327 
 
9328 
  def write(self, oprot):
9329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9331 
      return
9332 
    oprot.writeStructBegin('getAllCategories_args')
9333 
    oprot.writeFieldStop()
9334 
    oprot.writeStructEnd()
9335 
 
9336 
  def validate(self):
9337 
    return
9338 
 
9339 
 
9340 
  def __repr__(self):
9341 
    L = ['%s=%r' % (key, value)
9342 
      for key, value in self.__dict__.iteritems()]
9343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9344 
 
9345 
  def __eq__(self, other):
9346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9347 
 
9348 
  def __ne__(self, other):
9349 
    return not (self == other)
9350 
 
9351 
class getAllCategories_result:
9352 
  """
9353 
  Attributes:
9354 
   - success
9355 
  """
9356 
 
9357 
  thrift_spec = (
9358 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9359 
  )
9360 
 
9361 
  def __init__(self, success=None,):
9362 
    self.success = success
9363 
 
9364 
  def read(self, iprot):
9365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9367 
      return
9368 
    iprot.readStructBegin()
9369 
    while True:
9370 
      (fname, ftype, fid) = iprot.readFieldBegin()
9371 
      if ftype == TType.STOP:
9372 
        break
9373 
      if fid == 0:
9374 
        if ftype == TType.LIST:
9375 
          self.success = []
9376 
          (_etype124, _size121) = iprot.readListBegin()
9377 
          for _i125 in xrange(_size121):
9378 
            _elem126 = Category()
9379 
            _elem126.read(iprot)
9380 
            self.success.append(_elem126)
9381 
          iprot.readListEnd()
9382 
        else:
9383 
          iprot.skip(ftype)
9384 
      else:
9385 
        iprot.skip(ftype)
9386 
      iprot.readFieldEnd()
9387 
    iprot.readStructEnd()
9388 
 
9389 
  def write(self, oprot):
9390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9392 
      return
9393 
    oprot.writeStructBegin('getAllCategories_result')
9394 
    if self.success is not None:
9395 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9396 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9397 
      for iter127 in self.success:
9398 
        iter127.write(oprot)
9399 
      oprot.writeListEnd()
9400 
      oprot.writeFieldEnd()
9401 
    oprot.writeFieldStop()
9402 
    oprot.writeStructEnd()
9403 
 
9404 
  def validate(self):
9405 
    return
9406 
 
9407 
 
9408 
  def __repr__(self):
9409 
    L = ['%s=%r' % (key, value)
9410 
      for key, value in self.__dict__.iteritems()]
9411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9412 
 
9413 
  def __eq__(self, other):
9414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9415 
 
9416 
  def __ne__(self, other):
9417 
    return not (self == other)
9418 
 
9419 
class getAllSimilarItems_args:
9420 
  """
9421 
  Attributes:
9422 
   - itemId
9423 
  """
9424 
 
9425 
  thrift_spec = (
9426 
    None, # 0
9427 
    (1, TType.I64, 'itemId', None, None, ), # 1
9428 
  )
9429 
 
9430 
  def __init__(self, itemId=None,):
9431 
    self.itemId = itemId
9432 
 
9433 
  def read(self, iprot):
9434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9436 
      return
9437 
    iprot.readStructBegin()
9438 
    while True:
9439 
      (fname, ftype, fid) = iprot.readFieldBegin()
9440 
      if ftype == TType.STOP:
9441 
        break
9442 
      if fid == 1:
9443 
        if ftype == TType.I64:
9444 
          self.itemId = iprot.readI64();
9445 
        else:
9446 
          iprot.skip(ftype)
9447 
      else:
9448 
        iprot.skip(ftype)
9449 
      iprot.readFieldEnd()
9450 
    iprot.readStructEnd()
9451 
 
9452 
  def write(self, oprot):
9453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9455 
      return
9456 
    oprot.writeStructBegin('getAllSimilarItems_args')
9457 
    if self.itemId is not None:
9458 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9459 
      oprot.writeI64(self.itemId)
9460 
      oprot.writeFieldEnd()
9461 
    oprot.writeFieldStop()
9462 
    oprot.writeStructEnd()
9463 
 
9464 
  def validate(self):
9465 
    return
9466 
 
9467 
 
9468 
  def __repr__(self):
9469 
    L = ['%s=%r' % (key, value)
9470 
      for key, value in self.__dict__.iteritems()]
9471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9472 
 
9473 
  def __eq__(self, other):
9474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9475 
 
9476 
  def __ne__(self, other):
9477 
    return not (self == other)
9478 
 
9479 
class getAllSimilarItems_result:
9480 
  """
9481 
  Attributes:
9482 
   - success
9483 
  """
9484 
 
9485 
  thrift_spec = (
9486 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9487 
  )
9488 
 
9489 
  def __init__(self, success=None,):
9490 
    self.success = success
9491 
 
9492 
  def read(self, iprot):
9493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9495 
      return
9496 
    iprot.readStructBegin()
9497 
    while True:
9498 
      (fname, ftype, fid) = iprot.readFieldBegin()
9499 
      if ftype == TType.STOP:
9500 
        break
9501 
      if fid == 0:
9502 
        if ftype == TType.LIST:
9503 
          self.success = []
9504 
          (_etype131, _size128) = iprot.readListBegin()
9505 
          for _i132 in xrange(_size128):
9506 
            _elem133 = Item()
9507 
            _elem133.read(iprot)
9508 
            self.success.append(_elem133)
9509 
          iprot.readListEnd()
9510 
        else:
9511 
          iprot.skip(ftype)
9512 
      else:
9513 
        iprot.skip(ftype)
9514 
      iprot.readFieldEnd()
9515 
    iprot.readStructEnd()
9516 
 
9517 
  def write(self, oprot):
9518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9520 
      return
9521 
    oprot.writeStructBegin('getAllSimilarItems_result')
9522 
    if self.success is not None:
9523 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9524 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9525 
      for iter134 in self.success:
9526 
        iter134.write(oprot)
9527 
      oprot.writeListEnd()
9528 
      oprot.writeFieldEnd()
9529 
    oprot.writeFieldStop()
9530 
    oprot.writeStructEnd()
9531 
 
9532 
  def validate(self):
9533 
    return
9534 
 
9535 
 
9536 
  def __repr__(self):
9537 
    L = ['%s=%r' % (key, value)
9538 
      for key, value in self.__dict__.iteritems()]
9539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9540 
 
9541 
  def __eq__(self, other):
9542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9543 
 
9544 
  def __ne__(self, other):
9545 
    return not (self == other)
9546 
 
9547 
class addSimilarItem_args:
9548 
  """
9549 
  Attributes:
9550 
   - itemId
9551 
   - catalogItemId
9552 
  """
9553 
 
9554 
  thrift_spec = (
9555 
    None, # 0
9556 
    (1, TType.I64, 'itemId', None, None, ), # 1
9557 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9558 
  )
9559 
 
9560 
  def __init__(self, itemId=None, catalogItemId=None,):
9561 
    self.itemId = itemId
9562 
    self.catalogItemId = catalogItemId
9563 
 
9564 
  def read(self, iprot):
9565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9567 
      return
9568 
    iprot.readStructBegin()
9569 
    while True:
9570 
      (fname, ftype, fid) = iprot.readFieldBegin()
9571 
      if ftype == TType.STOP:
9572 
        break
9573 
      if fid == 1:
9574 
        if ftype == TType.I64:
9575 
          self.itemId = iprot.readI64();
9576 
        else:
9577 
          iprot.skip(ftype)
9578 
      elif fid == 2:
9579 
        if ftype == TType.I64:
9580 
          self.catalogItemId = iprot.readI64();
9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      else:
9584 
        iprot.skip(ftype)
9585 
      iprot.readFieldEnd()
9586 
    iprot.readStructEnd()
9587 
 
9588 
  def write(self, oprot):
9589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9591 
      return
9592 
    oprot.writeStructBegin('addSimilarItem_args')
9593 
    if self.itemId is not None:
9594 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9595 
      oprot.writeI64(self.itemId)
9596 
      oprot.writeFieldEnd()
9597 
    if self.catalogItemId is not None:
9598 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9599 
      oprot.writeI64(self.catalogItemId)
9600 
      oprot.writeFieldEnd()
9601 
    oprot.writeFieldStop()
9602 
    oprot.writeStructEnd()
9603 
 
9604 
  def validate(self):
9605 
    return
9606 
 
9607 
 
9608 
  def __repr__(self):
9609 
    L = ['%s=%r' % (key, value)
9610 
      for key, value in self.__dict__.iteritems()]
9611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9612 
 
9613 
  def __eq__(self, other):
9614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9615 
 
9616 
  def __ne__(self, other):
9617 
    return not (self == other)
9618 
 
9619 
class addSimilarItem_result:
9620 
  """
9621 
  Attributes:
9622 
   - success
9623 
   - cex
9624 
  """
9625 
 
9626 
  thrift_spec = (
9627 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9628 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9629 
  )
9630 
 
9631 
  def __init__(self, success=None, cex=None,):
9632 
    self.success = success
9633 
    self.cex = cex
9634 
 
9635 
  def read(self, iprot):
9636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9638 
      return
9639 
    iprot.readStructBegin()
9640 
    while True:
9641 
      (fname, ftype, fid) = iprot.readFieldBegin()
9642 
      if ftype == TType.STOP:
9643 
        break
9644 
      if fid == 0:
9645 
        if ftype == TType.STRUCT:
9646 
          self.success = Item()
9647 
          self.success.read(iprot)
9648 
        else:
9649 
          iprot.skip(ftype)
9650 
      elif fid == 1:
9651 
        if ftype == TType.STRUCT:
9652 
          self.cex = CatalogServiceException()
9653 
          self.cex.read(iprot)
9654 
        else:
9655 
          iprot.skip(ftype)
9656 
      else:
9657 
        iprot.skip(ftype)
9658 
      iprot.readFieldEnd()
9659 
    iprot.readStructEnd()
9660 
 
9661 
  def write(self, oprot):
9662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9664 
      return
9665 
    oprot.writeStructBegin('addSimilarItem_result')
9666 
    if self.success is not None:
9667 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9668 
      self.success.write(oprot)
9669 
      oprot.writeFieldEnd()
9670 
    if self.cex is not None:
9671 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9672 
      self.cex.write(oprot)
9673 
      oprot.writeFieldEnd()
9674 
    oprot.writeFieldStop()
9675 
    oprot.writeStructEnd()
9676 
 
9677 
  def validate(self):
9678 
    return
9679 
 
9680 
 
9681 
  def __repr__(self):
9682 
    L = ['%s=%r' % (key, value)
9683 
      for key, value in self.__dict__.iteritems()]
9684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9685 
 
9686 
  def __eq__(self, other):
9687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9688 
 
9689 
  def __ne__(self, other):
9690 
    return not (self == other)
9691 
 
6512 kshitij.so 9692 
class addTag_args:
9693 
  """
9694 
  Attributes:
9695 
   - displayName
9696 
   - itemId
9697 
  """
9698 
 
9699 
  thrift_spec = (
9700 
    None, # 0
9701 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9702 
    (2, TType.I64, 'itemId', None, None, ), # 2
9703 
  )
9704 
 
9705 
  def __init__(self, displayName=None, itemId=None,):
9706 
    self.displayName = displayName
9707 
    self.itemId = itemId
9708 
 
9709 
  def read(self, iprot):
9710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9712 
      return
9713 
    iprot.readStructBegin()
9714 
    while True:
9715 
      (fname, ftype, fid) = iprot.readFieldBegin()
9716 
      if ftype == TType.STOP:
9717 
        break
9718 
      if fid == 1:
9719 
        if ftype == TType.STRING:
9720 
          self.displayName = iprot.readString();
9721 
        else:
9722 
          iprot.skip(ftype)
9723 
      elif fid == 2:
9724 
        if ftype == TType.I64:
9725 
          self.itemId = iprot.readI64();
9726 
        else:
9727 
          iprot.skip(ftype)
9728 
      else:
9729 
        iprot.skip(ftype)
9730 
      iprot.readFieldEnd()
9731 
    iprot.readStructEnd()
9732 
 
9733 
  def write(self, oprot):
9734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9736 
      return
9737 
    oprot.writeStructBegin('addTag_args')
9738 
    if self.displayName is not None:
9739 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9740 
      oprot.writeString(self.displayName)
9741 
      oprot.writeFieldEnd()
9742 
    if self.itemId is not None:
9743 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9744 
      oprot.writeI64(self.itemId)
9745 
      oprot.writeFieldEnd()
9746 
    oprot.writeFieldStop()
9747 
    oprot.writeStructEnd()
9748 
 
9749 
  def validate(self):
9750 
    return
9751 
 
9752 
 
9753 
  def __repr__(self):
9754 
    L = ['%s=%r' % (key, value)
9755 
      for key, value in self.__dict__.iteritems()]
9756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9757 
 
9758 
  def __eq__(self, other):
9759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9760 
 
9761 
  def __ne__(self, other):
9762 
    return not (self == other)
9763 
 
9764 
class addTag_result:
9765 
  """
9766 
  Attributes:
9767 
   - success
9768 
  """
9769 
 
9770 
  thrift_spec = (
9771 
    (0, TType.BOOL, 'success', None, None, ), # 0
9772 
  )
9773 
 
9774 
  def __init__(self, success=None,):
9775 
    self.success = success
9776 
 
9777 
  def read(self, iprot):
9778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9780 
      return
9781 
    iprot.readStructBegin()
9782 
    while True:
9783 
      (fname, ftype, fid) = iprot.readFieldBegin()
9784 
      if ftype == TType.STOP:
9785 
        break
9786 
      if fid == 0:
9787 
        if ftype == TType.BOOL:
9788 
          self.success = iprot.readBool();
9789 
        else:
9790 
          iprot.skip(ftype)
9791 
      else:
9792 
        iprot.skip(ftype)
9793 
      iprot.readFieldEnd()
9794 
    iprot.readStructEnd()
9795 
 
9796 
  def write(self, oprot):
9797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9799 
      return
9800 
    oprot.writeStructBegin('addTag_result')
9801 
    if self.success is not None:
9802 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9803 
      oprot.writeBool(self.success)
9804 
      oprot.writeFieldEnd()
9805 
    oprot.writeFieldStop()
9806 
    oprot.writeStructEnd()
9807 
 
9808 
  def validate(self):
9809 
    return
9810 
 
9811 
 
9812 
  def __repr__(self):
9813 
    L = ['%s=%r' % (key, value)
9814 
      for key, value in self.__dict__.iteritems()]
9815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9816 
 
9817 
  def __eq__(self, other):
9818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9819 
 
9820 
  def __ne__(self, other):
9821 
    return not (self == other)
9822 
 
9823 
class deleteEntityTag_args:
9824 
  """
9825 
  Attributes:
9826 
   - displayName
9827 
   - itemId
9828 
  """
9829 
 
9830 
  thrift_spec = (
9831 
    None, # 0
9832 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9833 
    (2, TType.I64, 'itemId', None, None, ), # 2
9834 
  )
9835 
 
9836 
  def __init__(self, displayName=None, itemId=None,):
9837 
    self.displayName = displayName
9838 
    self.itemId = itemId
9839 
 
9840 
  def read(self, iprot):
9841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9843 
      return
9844 
    iprot.readStructBegin()
9845 
    while True:
9846 
      (fname, ftype, fid) = iprot.readFieldBegin()
9847 
      if ftype == TType.STOP:
9848 
        break
9849 
      if fid == 1:
9850 
        if ftype == TType.STRING:
9851 
          self.displayName = iprot.readString();
9852 
        else:
9853 
          iprot.skip(ftype)
9854 
      elif fid == 2:
9855 
        if ftype == TType.I64:
9856 
          self.itemId = iprot.readI64();
9857 
        else:
9858 
          iprot.skip(ftype)
9859 
      else:
9860 
        iprot.skip(ftype)
9861 
      iprot.readFieldEnd()
9862 
    iprot.readStructEnd()
9863 
 
9864 
  def write(self, oprot):
9865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9867 
      return
9868 
    oprot.writeStructBegin('deleteEntityTag_args')
9869 
    if self.displayName is not None:
9870 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9871 
      oprot.writeString(self.displayName)
9872 
      oprot.writeFieldEnd()
9873 
    if self.itemId is not None:
9874 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9875 
      oprot.writeI64(self.itemId)
9876 
      oprot.writeFieldEnd()
9877 
    oprot.writeFieldStop()
9878 
    oprot.writeStructEnd()
9879 
 
9880 
  def validate(self):
9881 
    return
9882 
 
9883 
 
9884 
  def __repr__(self):
9885 
    L = ['%s=%r' % (key, value)
9886 
      for key, value in self.__dict__.iteritems()]
9887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9888 
 
9889 
  def __eq__(self, other):
9890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9891 
 
9892 
  def __ne__(self, other):
9893 
    return not (self == other)
9894 
 
9895 
class deleteEntityTag_result:
9896 
  """
9897 
  Attributes:
9898 
   - success
9899 
  """
9900 
 
9901 
  thrift_spec = (
9902 
    (0, TType.BOOL, 'success', None, None, ), # 0
9903 
  )
9904 
 
9905 
  def __init__(self, success=None,):
9906 
    self.success = success
9907 
 
9908 
  def read(self, iprot):
9909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9911 
      return
9912 
    iprot.readStructBegin()
9913 
    while True:
9914 
      (fname, ftype, fid) = iprot.readFieldBegin()
9915 
      if ftype == TType.STOP:
9916 
        break
9917 
      if fid == 0:
9918 
        if ftype == TType.BOOL:
9919 
          self.success = iprot.readBool();
9920 
        else:
9921 
          iprot.skip(ftype)
9922 
      else:
9923 
        iprot.skip(ftype)
9924 
      iprot.readFieldEnd()
9925 
    iprot.readStructEnd()
9926 
 
9927 
  def write(self, oprot):
9928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9930 
      return
9931 
    oprot.writeStructBegin('deleteEntityTag_result')
9932 
    if self.success is not None:
9933 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9934 
      oprot.writeBool(self.success)
9935 
      oprot.writeFieldEnd()
9936 
    oprot.writeFieldStop()
9937 
    oprot.writeStructEnd()
9938 
 
9939 
  def validate(self):
9940 
    return
9941 
 
9942 
 
9943 
  def __repr__(self):
9944 
    L = ['%s=%r' % (key, value)
9945 
      for key, value in self.__dict__.iteritems()]
9946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9947 
 
9948 
  def __eq__(self, other):
9949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9950 
 
9951 
  def __ne__(self, other):
9952 
    return not (self == other)
9953 
 
9954 
class deleteTag_args:
9955 
  """
9956 
  Attributes:
9957 
   - displayName
9958 
  """
9959 
 
9960 
  thrift_spec = (
9961 
    None, # 0
9962 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9963 
  )
9964 
 
9965 
  def __init__(self, displayName=None,):
9966 
    self.displayName = displayName
9967 
 
9968 
  def read(self, iprot):
9969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9971 
      return
9972 
    iprot.readStructBegin()
9973 
    while True:
9974 
      (fname, ftype, fid) = iprot.readFieldBegin()
9975 
      if ftype == TType.STOP:
9976 
        break
9977 
      if fid == 1:
9978 
        if ftype == TType.STRING:
9979 
          self.displayName = iprot.readString();
9980 
        else:
9981 
          iprot.skip(ftype)
9982 
      else:
9983 
        iprot.skip(ftype)
9984 
      iprot.readFieldEnd()
9985 
    iprot.readStructEnd()
9986 
 
9987 
  def write(self, oprot):
9988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9990 
      return
9991 
    oprot.writeStructBegin('deleteTag_args')
9992 
    if self.displayName is not None:
9993 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9994 
      oprot.writeString(self.displayName)
9995 
      oprot.writeFieldEnd()
9996 
    oprot.writeFieldStop()
9997 
    oprot.writeStructEnd()
9998 
 
9999 
  def validate(self):
10000 
    return
10001 
 
10002 
 
10003 
  def __repr__(self):
10004 
    L = ['%s=%r' % (key, value)
10005 
      for key, value in self.__dict__.iteritems()]
10006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10007 
 
10008 
  def __eq__(self, other):
10009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10010 
 
10011 
  def __ne__(self, other):
10012 
    return not (self == other)
10013 
 
10014 
class deleteTag_result:
10015 
  """
10016 
  Attributes:
10017 
   - success
10018 
  """
10019 
 
10020 
  thrift_spec = (
10021 
    (0, TType.BOOL, 'success', None, None, ), # 0
10022 
  )
10023 
 
10024 
  def __init__(self, success=None,):
10025 
    self.success = success
10026 
 
10027 
  def read(self, iprot):
10028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10030 
      return
10031 
    iprot.readStructBegin()
10032 
    while True:
10033 
      (fname, ftype, fid) = iprot.readFieldBegin()
10034 
      if ftype == TType.STOP:
10035 
        break
10036 
      if fid == 0:
10037 
        if ftype == TType.BOOL:
10038 
          self.success = iprot.readBool();
10039 
        else:
10040 
          iprot.skip(ftype)
10041 
      else:
10042 
        iprot.skip(ftype)
10043 
      iprot.readFieldEnd()
10044 
    iprot.readStructEnd()
10045 
 
10046 
  def write(self, oprot):
10047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10049 
      return
10050 
    oprot.writeStructBegin('deleteTag_result')
10051 
    if self.success is not None:
10052 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10053 
      oprot.writeBool(self.success)
10054 
      oprot.writeFieldEnd()
10055 
    oprot.writeFieldStop()
10056 
    oprot.writeStructEnd()
10057 
 
10058 
  def validate(self):
10059 
    return
10060 
 
10061 
 
10062 
  def __repr__(self):
10063 
    L = ['%s=%r' % (key, value)
10064 
      for key, value in self.__dict__.iteritems()]
10065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10066 
 
10067 
  def __eq__(self, other):
10068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10069 
 
10070 
  def __ne__(self, other):
10071 
    return not (self == other)
10072 
 
10073 
class getAllTags_args:
10074 
 
10075 
  thrift_spec = (
10076 
  )
10077 
 
10078 
  def read(self, iprot):
10079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10081 
      return
10082 
    iprot.readStructBegin()
10083 
    while True:
10084 
      (fname, ftype, fid) = iprot.readFieldBegin()
10085 
      if ftype == TType.STOP:
10086 
        break
10087 
      else:
10088 
        iprot.skip(ftype)
10089 
      iprot.readFieldEnd()
10090 
    iprot.readStructEnd()
10091 
 
10092 
  def write(self, oprot):
10093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10095 
      return
10096 
    oprot.writeStructBegin('getAllTags_args')
10097 
    oprot.writeFieldStop()
10098 
    oprot.writeStructEnd()
10099 
 
10100 
  def validate(self):
10101 
    return
10102 
 
10103 
 
10104 
  def __repr__(self):
10105 
    L = ['%s=%r' % (key, value)
10106 
      for key, value in self.__dict__.iteritems()]
10107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10108 
 
10109 
  def __eq__(self, other):
10110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10111 
 
10112 
  def __ne__(self, other):
10113 
    return not (self == other)
10114 
 
10115 
class getAllTags_result:
10116 
  """
10117 
  Attributes:
10118 
   - success
10119 
  """
10120 
 
10121 
  thrift_spec = (
10122 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10123 
  )
10124 
 
10125 
  def __init__(self, success=None,):
10126 
    self.success = success
10127 
 
10128 
  def read(self, iprot):
10129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10131 
      return
10132 
    iprot.readStructBegin()
10133 
    while True:
10134 
      (fname, ftype, fid) = iprot.readFieldBegin()
10135 
      if ftype == TType.STOP:
10136 
        break
10137 
      if fid == 0:
10138 
        if ftype == TType.LIST:
10139 
          self.success = []
10140 
          (_etype138, _size135) = iprot.readListBegin()
10141 
          for _i139 in xrange(_size135):
10142 
            _elem140 = iprot.readString();
10143 
            self.success.append(_elem140)
10144 
          iprot.readListEnd()
10145 
        else:
10146 
          iprot.skip(ftype)
10147 
      else:
10148 
        iprot.skip(ftype)
10149 
      iprot.readFieldEnd()
10150 
    iprot.readStructEnd()
10151 
 
10152 
  def write(self, oprot):
10153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10155 
      return
10156 
    oprot.writeStructBegin('getAllTags_result')
10157 
    if self.success is not None:
10158 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10159 
      oprot.writeListBegin(TType.STRING, len(self.success))
10160 
      for iter141 in self.success:
10161 
        oprot.writeString(iter141)
10162 
      oprot.writeListEnd()
10163 
      oprot.writeFieldEnd()
10164 
    oprot.writeFieldStop()
10165 
    oprot.writeStructEnd()
10166 
 
10167 
  def validate(self):
10168 
    return
10169 
 
10170 
 
10171 
  def __repr__(self):
10172 
    L = ['%s=%r' % (key, value)
10173 
      for key, value in self.__dict__.iteritems()]
10174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10175 
 
10176 
  def __eq__(self, other):
10177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10178 
 
10179 
  def __ne__(self, other):
10180 
    return not (self == other)
10181 
 
10182 
class getAllEntitiesByTagName_args:
10183 
  """
10184 
  Attributes:
10185 
   - displayName
10186 
  """
10187 
 
10188 
  thrift_spec = (
10189 
    None, # 0
10190 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10191 
  )
10192 
 
10193 
  def __init__(self, displayName=None,):
10194 
    self.displayName = displayName
10195 
 
10196 
  def read(self, iprot):
10197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10199 
      return
10200 
    iprot.readStructBegin()
10201 
    while True:
10202 
      (fname, ftype, fid) = iprot.readFieldBegin()
10203 
      if ftype == TType.STOP:
10204 
        break
10205 
      if fid == 1:
10206 
        if ftype == TType.STRING:
10207 
          self.displayName = iprot.readString();
10208 
        else:
10209 
          iprot.skip(ftype)
10210 
      else:
10211 
        iprot.skip(ftype)
10212 
      iprot.readFieldEnd()
10213 
    iprot.readStructEnd()
10214 
 
10215 
  def write(self, oprot):
10216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10218 
      return
10219 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10220 
    if self.displayName is not None:
10221 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10222 
      oprot.writeString(self.displayName)
10223 
      oprot.writeFieldEnd()
10224 
    oprot.writeFieldStop()
10225 
    oprot.writeStructEnd()
10226 
 
10227 
  def validate(self):
10228 
    return
10229 
 
10230 
 
10231 
  def __repr__(self):
10232 
    L = ['%s=%r' % (key, value)
10233 
      for key, value in self.__dict__.iteritems()]
10234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10235 
 
10236 
  def __eq__(self, other):
10237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10238 
 
10239 
  def __ne__(self, other):
10240 
    return not (self == other)
10241 
 
10242 
class getAllEntitiesByTagName_result:
10243 
  """
10244 
  Attributes:
10245 
   - success
10246 
  """
10247 
 
10248 
  thrift_spec = (
10249 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10250 
  )
10251 
 
10252 
  def __init__(self, success=None,):
10253 
    self.success = success
10254 
 
10255 
  def read(self, iprot):
10256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10258 
      return
10259 
    iprot.readStructBegin()
10260 
    while True:
10261 
      (fname, ftype, fid) = iprot.readFieldBegin()
10262 
      if ftype == TType.STOP:
10263 
        break
10264 
      if fid == 0:
10265 
        if ftype == TType.LIST:
10266 
          self.success = []
10267 
          (_etype145, _size142) = iprot.readListBegin()
10268 
          for _i146 in xrange(_size142):
10269 
            _elem147 = iprot.readI64();
10270 
            self.success.append(_elem147)
10271 
          iprot.readListEnd()
10272 
        else:
10273 
          iprot.skip(ftype)
10274 
      else:
10275 
        iprot.skip(ftype)
10276 
      iprot.readFieldEnd()
10277 
    iprot.readStructEnd()
10278 
 
10279 
  def write(self, oprot):
10280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10282 
      return
10283 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10284 
    if self.success is not None:
10285 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10286 
      oprot.writeListBegin(TType.I64, len(self.success))
10287 
      for iter148 in self.success:
10288 
        oprot.writeI64(iter148)
10289 
      oprot.writeListEnd()
10290 
      oprot.writeFieldEnd()
10291 
    oprot.writeFieldStop()
10292 
    oprot.writeStructEnd()
10293 
 
10294 
  def validate(self):
10295 
    return
10296 
 
10297 
 
10298 
  def __repr__(self):
10299 
    L = ['%s=%r' % (key, value)
10300 
      for key, value in self.__dict__.iteritems()]
10301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10302 
 
10303 
  def __eq__(self, other):
10304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10305 
 
10306 
  def __ne__(self, other):
10307 
    return not (self == other)
10308 
 
6845 amit.gupta 10309 
class getAllEntityTags_args:
10310 
 
10311 
  thrift_spec = (
10312 
  )
10313 
 
10314 
  def read(self, iprot):
10315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10317 
      return
10318 
    iprot.readStructBegin()
10319 
    while True:
10320 
      (fname, ftype, fid) = iprot.readFieldBegin()
10321 
      if ftype == TType.STOP:
10322 
        break
10323 
      else:
10324 
        iprot.skip(ftype)
10325 
      iprot.readFieldEnd()
10326 
    iprot.readStructEnd()
10327 
 
10328 
  def write(self, oprot):
10329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10331 
      return
10332 
    oprot.writeStructBegin('getAllEntityTags_args')
10333 
    oprot.writeFieldStop()
10334 
    oprot.writeStructEnd()
10335 
 
10336 
  def validate(self):
10337 
    return
10338 
 
10339 
 
10340 
  def __repr__(self):
10341 
    L = ['%s=%r' % (key, value)
10342 
      for key, value in self.__dict__.iteritems()]
10343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10344 
 
10345 
  def __eq__(self, other):
10346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10347 
 
10348 
  def __ne__(self, other):
10349 
    return not (self == other)
10350 
 
10351 
class getAllEntityTags_result:
10352 
  """
10353 
  Attributes:
10354 
   - success
10355 
  """
10356 
 
10357 
  thrift_spec = (
10358 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10359 
  )
10360 
 
10361 
  def __init__(self, success=None,):
10362 
    self.success = success
10363 
 
10364 
  def read(self, iprot):
10365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10367 
      return
10368 
    iprot.readStructBegin()
10369 
    while True:
10370 
      (fname, ftype, fid) = iprot.readFieldBegin()
10371 
      if ftype == TType.STOP:
10372 
        break
10373 
      if fid == 0:
10374 
        if ftype == TType.MAP:
10375 
          self.success = {}
10376 
          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
10377 
          for _i153 in xrange(_size149):
10378 
            _key154 = iprot.readI64();
10379 
            _val155 = []
10380 
            (_etype159, _size156) = iprot.readListBegin()
10381 
            for _i160 in xrange(_size156):
10382 
              _elem161 = iprot.readString();
10383 
              _val155.append(_elem161)
10384 
            iprot.readListEnd()
10385 
            self.success[_key154] = _val155
10386 
          iprot.readMapEnd()
10387 
        else:
10388 
          iprot.skip(ftype)
10389 
      else:
10390 
        iprot.skip(ftype)
10391 
      iprot.readFieldEnd()
10392 
    iprot.readStructEnd()
10393 
 
10394 
  def write(self, oprot):
10395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10397 
      return
10398 
    oprot.writeStructBegin('getAllEntityTags_result')
10399 
    if self.success is not None:
10400 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10401 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
10402 
      for kiter162,viter163 in self.success.items():
10403 
        oprot.writeI64(kiter162)
10404 
        oprot.writeListBegin(TType.STRING, len(viter163))
10405 
        for iter164 in viter163:
10406 
          oprot.writeString(iter164)
10407 
        oprot.writeListEnd()
10408 
      oprot.writeMapEnd()
10409 
      oprot.writeFieldEnd()
10410 
    oprot.writeFieldStop()
10411 
    oprot.writeStructEnd()
10412 
 
10413 
  def validate(self):
10414 
    return
10415 
 
10416 
 
10417 
  def __repr__(self):
10418 
    L = ['%s=%r' % (key, value)
10419 
      for key, value in self.__dict__.iteritems()]
10420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10421 
 
10422 
  def __eq__(self, other):
10423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10424 
 
10425 
  def __ne__(self, other):
10426 
    return not (self == other)
10427 
 
6850 kshitij.so 10428 
class addBanner_args:
10429 
  """
10430 
  Attributes:
10431 
   - bannerName
10432 
   - imageName
10433 
   - link
10434 
   - priority
10435 
   - isActive
10436 
   - hasMap
10437 
  """
10438 
 
10439 
  thrift_spec = (
10440 
    None, # 0
10441 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10442 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10443 
    (3, TType.STRING, 'link', None, None, ), # 3
10444 
    (4, TType.I64, 'priority', None, None, ), # 4
10445 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10446 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10447 
  )
10448 
 
10449 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10450 
    self.bannerName = bannerName
10451 
    self.imageName = imageName
10452 
    self.link = link
10453 
    self.priority = priority
10454 
    self.isActive = isActive
10455 
    self.hasMap = hasMap
10456 
 
10457 
  def read(self, iprot):
10458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10460 
      return
10461 
    iprot.readStructBegin()
10462 
    while True:
10463 
      (fname, ftype, fid) = iprot.readFieldBegin()
10464 
      if ftype == TType.STOP:
10465 
        break
10466 
      if fid == 1:
10467 
        if ftype == TType.STRING:
10468 
          self.bannerName = iprot.readString();
10469 
        else:
10470 
          iprot.skip(ftype)
10471 
      elif fid == 2:
10472 
        if ftype == TType.STRING:
10473 
          self.imageName = iprot.readString();
10474 
        else:
10475 
          iprot.skip(ftype)
10476 
      elif fid == 3:
10477 
        if ftype == TType.STRING:
10478 
          self.link = iprot.readString();
10479 
        else:
10480 
          iprot.skip(ftype)
10481 
      elif fid == 4:
10482 
        if ftype == TType.I64:
10483 
          self.priority = iprot.readI64();
10484 
        else:
10485 
          iprot.skip(ftype)
10486 
      elif fid == 5:
10487 
        if ftype == TType.BOOL:
10488 
          self.isActive = iprot.readBool();
10489 
        else:
10490 
          iprot.skip(ftype)
10491 
      elif fid == 6:
10492 
        if ftype == TType.BOOL:
10493 
          self.hasMap = iprot.readBool();
10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      else:
10497 
        iprot.skip(ftype)
10498 
      iprot.readFieldEnd()
10499 
    iprot.readStructEnd()
10500 
 
10501 
  def write(self, oprot):
10502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10504 
      return
10505 
    oprot.writeStructBegin('addBanner_args')
10506 
    if self.bannerName is not None:
10507 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10508 
      oprot.writeString(self.bannerName)
10509 
      oprot.writeFieldEnd()
10510 
    if self.imageName is not None:
10511 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10512 
      oprot.writeString(self.imageName)
10513 
      oprot.writeFieldEnd()
10514 
    if self.link is not None:
10515 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10516 
      oprot.writeString(self.link)
10517 
      oprot.writeFieldEnd()
10518 
    if self.priority is not None:
10519 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10520 
      oprot.writeI64(self.priority)
10521 
      oprot.writeFieldEnd()
10522 
    if self.isActive is not None:
10523 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10524 
      oprot.writeBool(self.isActive)
10525 
      oprot.writeFieldEnd()
10526 
    if self.hasMap is not None:
10527 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10528 
      oprot.writeBool(self.hasMap)
10529 
      oprot.writeFieldEnd()
10530 
    oprot.writeFieldStop()
10531 
    oprot.writeStructEnd()
10532 
 
10533 
  def validate(self):
10534 
    return
10535 
 
10536 
 
10537 
  def __repr__(self):
10538 
    L = ['%s=%r' % (key, value)
10539 
      for key, value in self.__dict__.iteritems()]
10540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10541 
 
10542 
  def __eq__(self, other):
10543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10544 
 
10545 
  def __ne__(self, other):
10546 
    return not (self == other)
10547 
 
10548 
class addBanner_result:
10549 
  """
10550 
  Attributes:
10551 
   - success
10552 
  """
10553 
 
10554 
  thrift_spec = (
10555 
    (0, TType.BOOL, 'success', None, None, ), # 0
10556 
  )
10557 
 
10558 
  def __init__(self, success=None,):
10559 
    self.success = success
10560 
 
10561 
  def read(self, iprot):
10562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10564 
      return
10565 
    iprot.readStructBegin()
10566 
    while True:
10567 
      (fname, ftype, fid) = iprot.readFieldBegin()
10568 
      if ftype == TType.STOP:
10569 
        break
10570 
      if fid == 0:
10571 
        if ftype == TType.BOOL:
10572 
          self.success = iprot.readBool();
10573 
        else:
10574 
          iprot.skip(ftype)
10575 
      else:
10576 
        iprot.skip(ftype)
10577 
      iprot.readFieldEnd()
10578 
    iprot.readStructEnd()
10579 
 
10580 
  def write(self, oprot):
10581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10583 
      return
10584 
    oprot.writeStructBegin('addBanner_result')
10585 
    if self.success is not None:
10586 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10587 
      oprot.writeBool(self.success)
10588 
      oprot.writeFieldEnd()
10589 
    oprot.writeFieldStop()
10590 
    oprot.writeStructEnd()
10591 
 
10592 
  def validate(self):
10593 
    return
10594 
 
10595 
 
10596 
  def __repr__(self):
10597 
    L = ['%s=%r' % (key, value)
10598 
      for key, value in self.__dict__.iteritems()]
10599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10600 
 
10601 
  def __eq__(self, other):
10602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10603 
 
10604 
  def __ne__(self, other):
10605 
    return not (self == other)
10606 
 
10607 
class getAllBanners_args:
10608 
 
10609 
  thrift_spec = (
10610 
  )
10611 
 
10612 
  def read(self, iprot):
10613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10615 
      return
10616 
    iprot.readStructBegin()
10617 
    while True:
10618 
      (fname, ftype, fid) = iprot.readFieldBegin()
10619 
      if ftype == TType.STOP:
10620 
        break
10621 
      else:
10622 
        iprot.skip(ftype)
10623 
      iprot.readFieldEnd()
10624 
    iprot.readStructEnd()
10625 
 
10626 
  def write(self, oprot):
10627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10629 
      return
10630 
    oprot.writeStructBegin('getAllBanners_args')
10631 
    oprot.writeFieldStop()
10632 
    oprot.writeStructEnd()
10633 
 
10634 
  def validate(self):
10635 
    return
10636 
 
10637 
 
10638 
  def __repr__(self):
10639 
    L = ['%s=%r' % (key, value)
10640 
      for key, value in self.__dict__.iteritems()]
10641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10642 
 
10643 
  def __eq__(self, other):
10644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10645 
 
10646 
  def __ne__(self, other):
10647 
    return not (self == other)
10648 
 
10649 
class getAllBanners_result:
10650 
  """
10651 
  Attributes:
10652 
   - success
10653 
  """
10654 
 
10655 
  thrift_spec = (
10656 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10657 
  )
10658 
 
10659 
  def __init__(self, success=None,):
10660 
    self.success = success
10661 
 
10662 
  def read(self, iprot):
10663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10665 
      return
10666 
    iprot.readStructBegin()
10667 
    while True:
10668 
      (fname, ftype, fid) = iprot.readFieldBegin()
10669 
      if ftype == TType.STOP:
10670 
        break
10671 
      if fid == 0:
10672 
        if ftype == TType.LIST:
10673 
          self.success = []
10674 
          (_etype168, _size165) = iprot.readListBegin()
10675 
          for _i169 in xrange(_size165):
10676 
            _elem170 = iprot.readString();
10677 
            self.success.append(_elem170)
10678 
          iprot.readListEnd()
10679 
        else:
10680 
          iprot.skip(ftype)
10681 
      else:
10682 
        iprot.skip(ftype)
10683 
      iprot.readFieldEnd()
10684 
    iprot.readStructEnd()
10685 
 
10686 
  def write(self, oprot):
10687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10689 
      return
10690 
    oprot.writeStructBegin('getAllBanners_result')
10691 
    if self.success is not None:
10692 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10693 
      oprot.writeListBegin(TType.STRING, len(self.success))
10694 
      for iter171 in self.success:
10695 
        oprot.writeString(iter171)
10696 
      oprot.writeListEnd()
10697 
      oprot.writeFieldEnd()
10698 
    oprot.writeFieldStop()
10699 
    oprot.writeStructEnd()
10700 
 
10701 
  def validate(self):
10702 
    return
10703 
 
10704 
 
10705 
  def __repr__(self):
10706 
    L = ['%s=%r' % (key, value)
10707 
      for key, value in self.__dict__.iteritems()]
10708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10709 
 
10710 
  def __eq__(self, other):
10711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10712 
 
10713 
  def __ne__(self, other):
10714 
    return not (self == other)
10715 
 
10716 
class deleteBanner_args:
10717 
  """
10718 
  Attributes:
10719 
   - bannerName
10720 
  """
10721 
 
10722 
  thrift_spec = (
10723 
    None, # 0
10724 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10725 
  )
10726 
 
10727 
  def __init__(self, bannerName=None,):
10728 
    self.bannerName = bannerName
10729 
 
10730 
  def read(self, iprot):
10731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10733 
      return
10734 
    iprot.readStructBegin()
10735 
    while True:
10736 
      (fname, ftype, fid) = iprot.readFieldBegin()
10737 
      if ftype == TType.STOP:
10738 
        break
10739 
      if fid == 1:
10740 
        if ftype == TType.STRING:
10741 
          self.bannerName = iprot.readString();
10742 
        else:
10743 
          iprot.skip(ftype)
10744 
      else:
10745 
        iprot.skip(ftype)
10746 
      iprot.readFieldEnd()
10747 
    iprot.readStructEnd()
10748 
 
10749 
  def write(self, oprot):
10750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10752 
      return
10753 
    oprot.writeStructBegin('deleteBanner_args')
10754 
    if self.bannerName is not None:
10755 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10756 
      oprot.writeString(self.bannerName)
10757 
      oprot.writeFieldEnd()
10758 
    oprot.writeFieldStop()
10759 
    oprot.writeStructEnd()
10760 
 
10761 
  def validate(self):
10762 
    return
10763 
 
10764 
 
10765 
  def __repr__(self):
10766 
    L = ['%s=%r' % (key, value)
10767 
      for key, value in self.__dict__.iteritems()]
10768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10769 
 
10770 
  def __eq__(self, other):
10771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10772 
 
10773 
  def __ne__(self, other):
10774 
    return not (self == other)
10775 
 
10776 
class deleteBanner_result:
10777 
  """
10778 
  Attributes:
10779 
   - success
10780 
  """
10781 
 
10782 
  thrift_spec = (
10783 
    (0, TType.BOOL, 'success', None, None, ), # 0
10784 
  )
10785 
 
10786 
  def __init__(self, success=None,):
10787 
    self.success = success
10788 
 
10789 
  def read(self, iprot):
10790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10792 
      return
10793 
    iprot.readStructBegin()
10794 
    while True:
10795 
      (fname, ftype, fid) = iprot.readFieldBegin()
10796 
      if ftype == TType.STOP:
10797 
        break
10798 
      if fid == 0:
10799 
        if ftype == TType.BOOL:
10800 
          self.success = iprot.readBool();
10801 
        else:
10802 
          iprot.skip(ftype)
10803 
      else:
10804 
        iprot.skip(ftype)
10805 
      iprot.readFieldEnd()
10806 
    iprot.readStructEnd()
10807 
 
10808 
  def write(self, oprot):
10809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10811 
      return
10812 
    oprot.writeStructBegin('deleteBanner_result')
10813 
    if self.success is not None:
10814 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10815 
      oprot.writeBool(self.success)
10816 
      oprot.writeFieldEnd()
10817 
    oprot.writeFieldStop()
10818 
    oprot.writeStructEnd()
10819 
 
10820 
  def validate(self):
10821 
    return
10822 
 
10823 
 
10824 
  def __repr__(self):
10825 
    L = ['%s=%r' % (key, value)
10826 
      for key, value in self.__dict__.iteritems()]
10827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10828 
 
10829 
  def __eq__(self, other):
10830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10831 
 
10832 
  def __ne__(self, other):
10833 
    return not (self == other)
10834 
 
10835 
class getBannerDetails_args:
10836 
  """
10837 
  Attributes:
10838 
   - bannerName
10839 
  """
10840 
 
10841 
  thrift_spec = (
10842 
    None, # 0
10843 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10844 
  )
10845 
 
10846 
  def __init__(self, bannerName=None,):
10847 
    self.bannerName = bannerName
10848 
 
10849 
  def read(self, iprot):
10850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10852 
      return
10853 
    iprot.readStructBegin()
10854 
    while True:
10855 
      (fname, ftype, fid) = iprot.readFieldBegin()
10856 
      if ftype == TType.STOP:
10857 
        break
10858 
      if fid == 1:
10859 
        if ftype == TType.STRING:
10860 
          self.bannerName = iprot.readString();
10861 
        else:
10862 
          iprot.skip(ftype)
10863 
      else:
10864 
        iprot.skip(ftype)
10865 
      iprot.readFieldEnd()
10866 
    iprot.readStructEnd()
10867 
 
10868 
  def write(self, oprot):
10869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10871 
      return
10872 
    oprot.writeStructBegin('getBannerDetails_args')
10873 
    if self.bannerName is not None:
10874 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10875 
      oprot.writeString(self.bannerName)
10876 
      oprot.writeFieldEnd()
10877 
    oprot.writeFieldStop()
10878 
    oprot.writeStructEnd()
10879 
 
10880 
  def validate(self):
10881 
    return
10882 
 
10883 
 
10884 
  def __repr__(self):
10885 
    L = ['%s=%r' % (key, value)
10886 
      for key, value in self.__dict__.iteritems()]
10887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10888 
 
10889 
  def __eq__(self, other):
10890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10891 
 
10892 
  def __ne__(self, other):
10893 
    return not (self == other)
10894 
 
10895 
class getBannerDetails_result:
10896 
  """
10897 
  Attributes:
10898 
   - success
10899 
  """
10900 
 
10901 
  thrift_spec = (
10902 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
10903 
  )
10904 
 
10905 
  def __init__(self, success=None,):
10906 
    self.success = success
10907 
 
10908 
  def read(self, iprot):
10909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10911 
      return
10912 
    iprot.readStructBegin()
10913 
    while True:
10914 
      (fname, ftype, fid) = iprot.readFieldBegin()
10915 
      if ftype == TType.STOP:
10916 
        break
10917 
      if fid == 0:
10918 
        if ftype == TType.STRUCT:
10919 
          self.success = Banner()
10920 
          self.success.read(iprot)
10921 
        else:
10922 
          iprot.skip(ftype)
10923 
      else:
10924 
        iprot.skip(ftype)
10925 
      iprot.readFieldEnd()
10926 
    iprot.readStructEnd()
10927 
 
10928 
  def write(self, oprot):
10929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10931 
      return
10932 
    oprot.writeStructBegin('getBannerDetails_result')
10933 
    if self.success is not None:
10934 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10935 
      self.success.write(oprot)
10936 
      oprot.writeFieldEnd()
10937 
    oprot.writeFieldStop()
10938 
    oprot.writeStructEnd()
10939 
 
10940 
  def validate(self):
10941 
    return
10942 
 
10943 
 
10944 
  def __repr__(self):
10945 
    L = ['%s=%r' % (key, value)
10946 
      for key, value in self.__dict__.iteritems()]
10947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10948 
 
10949 
  def __eq__(self, other):
10950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10951 
 
10952 
  def __ne__(self, other):
10953 
    return not (self == other)
10954 
 
10955 
class getActiveBanners_args:
10956 
 
10957 
  thrift_spec = (
10958 
  )
10959 
 
10960 
  def read(self, iprot):
10961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10963 
      return
10964 
    iprot.readStructBegin()
10965 
    while True:
10966 
      (fname, ftype, fid) = iprot.readFieldBegin()
10967 
      if ftype == TType.STOP:
10968 
        break
10969 
      else:
10970 
        iprot.skip(ftype)
10971 
      iprot.readFieldEnd()
10972 
    iprot.readStructEnd()
10973 
 
10974 
  def write(self, oprot):
10975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10977 
      return
10978 
    oprot.writeStructBegin('getActiveBanners_args')
10979 
    oprot.writeFieldStop()
10980 
    oprot.writeStructEnd()
10981 
 
10982 
  def validate(self):
10983 
    return
10984 
 
10985 
 
10986 
  def __repr__(self):
10987 
    L = ['%s=%r' % (key, value)
10988 
      for key, value in self.__dict__.iteritems()]
10989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10990 
 
10991 
  def __eq__(self, other):
10992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10993 
 
10994 
  def __ne__(self, other):
10995 
    return not (self == other)
10996 
 
10997 
class getActiveBanners_result:
10998 
  """
10999 
  Attributes:
11000 
   - success
11001 
  """
11002 
 
11003 
  thrift_spec = (
11004 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11005 
  )
11006 
 
11007 
  def __init__(self, success=None,):
11008 
    self.success = success
11009 
 
11010 
  def read(self, iprot):
11011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11013 
      return
11014 
    iprot.readStructBegin()
11015 
    while True:
11016 
      (fname, ftype, fid) = iprot.readFieldBegin()
11017 
      if ftype == TType.STOP:
11018 
        break
11019 
      if fid == 0:
11020 
        if ftype == TType.LIST:
11021 
          self.success = []
11022 
          (_etype175, _size172) = iprot.readListBegin()
11023 
          for _i176 in xrange(_size172):
11024 
            _elem177 = Banner()
11025 
            _elem177.read(iprot)
11026 
            self.success.append(_elem177)
11027 
          iprot.readListEnd()
11028 
        else:
11029 
          iprot.skip(ftype)
11030 
      else:
11031 
        iprot.skip(ftype)
11032 
      iprot.readFieldEnd()
11033 
    iprot.readStructEnd()
11034 
 
11035 
  def write(self, oprot):
11036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11038 
      return
11039 
    oprot.writeStructBegin('getActiveBanners_result')
11040 
    if self.success is not None:
11041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11043 
      for iter178 in self.success:
11044 
        iter178.write(oprot)
11045 
      oprot.writeListEnd()
11046 
      oprot.writeFieldEnd()
11047 
    oprot.writeFieldStop()
11048 
    oprot.writeStructEnd()
11049 
 
11050 
  def validate(self):
11051 
    return
11052 
 
11053 
 
11054 
  def __repr__(self):
11055 
    L = ['%s=%r' % (key, value)
11056 
      for key, value in self.__dict__.iteritems()]
11057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11058 
 
11059 
  def __eq__(self, other):
11060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11061 
 
11062 
  def __ne__(self, other):
11063 
    return not (self == other)
11064 
 
6849 kshitij.so 11065 
class addBannerMap_args:
11066 
  """
11067 
  Attributes:
11068 
   - bannerName
11069 
   - mapLink
11070 
   - coordinates
11071 
  """
11072 
 
11073 
  thrift_spec = (
11074 
    None, # 0
11075 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11076 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11077 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11078 
  )
11079 
 
11080 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11081 
    self.bannerName = bannerName
11082 
    self.mapLink = mapLink
11083 
    self.coordinates = coordinates
11084 
 
11085 
  def read(self, iprot):
11086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11088 
      return
11089 
    iprot.readStructBegin()
11090 
    while True:
11091 
      (fname, ftype, fid) = iprot.readFieldBegin()
11092 
      if ftype == TType.STOP:
11093 
        break
11094 
      if fid == 1:
11095 
        if ftype == TType.STRING:
11096 
          self.bannerName = iprot.readString();
11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      elif fid == 2:
11100 
        if ftype == TType.STRING:
11101 
          self.mapLink = iprot.readString();
11102 
        else:
11103 
          iprot.skip(ftype)
11104 
      elif fid == 3:
11105 
        if ftype == TType.STRING:
11106 
          self.coordinates = iprot.readString();
11107 
        else:
11108 
          iprot.skip(ftype)
11109 
      else:
11110 
        iprot.skip(ftype)
11111 
      iprot.readFieldEnd()
11112 
    iprot.readStructEnd()
11113 
 
11114 
  def write(self, oprot):
11115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11117 
      return
11118 
    oprot.writeStructBegin('addBannerMap_args')
11119 
    if self.bannerName is not None:
11120 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11121 
      oprot.writeString(self.bannerName)
11122 
      oprot.writeFieldEnd()
11123 
    if self.mapLink is not None:
11124 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11125 
      oprot.writeString(self.mapLink)
11126 
      oprot.writeFieldEnd()
11127 
    if self.coordinates is not None:
11128 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11129 
      oprot.writeString(self.coordinates)
11130 
      oprot.writeFieldEnd()
11131 
    oprot.writeFieldStop()
11132 
    oprot.writeStructEnd()
11133 
 
11134 
  def validate(self):
11135 
    return
11136 
 
11137 
 
11138 
  def __repr__(self):
11139 
    L = ['%s=%r' % (key, value)
11140 
      for key, value in self.__dict__.iteritems()]
11141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11142 
 
11143 
  def __eq__(self, other):
11144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11145 
 
11146 
  def __ne__(self, other):
11147 
    return not (self == other)
11148 
 
11149 
class addBannerMap_result:
11150 
  """
11151 
  Attributes:
11152 
   - success
11153 
  """
11154 
 
11155 
  thrift_spec = (
11156 
    (0, TType.BOOL, 'success', None, None, ), # 0
11157 
  )
11158 
 
11159 
  def __init__(self, success=None,):
11160 
    self.success = success
11161 
 
11162 
  def read(self, iprot):
11163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11165 
      return
11166 
    iprot.readStructBegin()
11167 
    while True:
11168 
      (fname, ftype, fid) = iprot.readFieldBegin()
11169 
      if ftype == TType.STOP:
11170 
        break
11171 
      if fid == 0:
11172 
        if ftype == TType.BOOL:
11173 
          self.success = iprot.readBool();
11174 
        else:
11175 
          iprot.skip(ftype)
11176 
      else:
11177 
        iprot.skip(ftype)
11178 
      iprot.readFieldEnd()
11179 
    iprot.readStructEnd()
11180 
 
11181 
  def write(self, oprot):
11182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11184 
      return
11185 
    oprot.writeStructBegin('addBannerMap_result')
11186 
    if self.success is not None:
11187 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11188 
      oprot.writeBool(self.success)
11189 
      oprot.writeFieldEnd()
11190 
    oprot.writeFieldStop()
11191 
    oprot.writeStructEnd()
11192 
 
11193 
  def validate(self):
11194 
    return
11195 
 
11196 
 
11197 
  def __repr__(self):
11198 
    L = ['%s=%r' % (key, value)
11199 
      for key, value in self.__dict__.iteritems()]
11200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11201 
 
11202 
  def __eq__(self, other):
11203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11204 
 
11205 
  def __ne__(self, other):
11206 
    return not (self == other)
11207 
 
11208 
class deleteBannerMap_args:
11209 
  """
11210 
  Attributes:
11211 
   - bannerName
11212 
  """
11213 
 
11214 
  thrift_spec = (
11215 
    None, # 0
11216 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11217 
  )
11218 
 
11219 
  def __init__(self, bannerName=None,):
11220 
    self.bannerName = bannerName
11221 
 
11222 
  def read(self, iprot):
11223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11225 
      return
11226 
    iprot.readStructBegin()
11227 
    while True:
11228 
      (fname, ftype, fid) = iprot.readFieldBegin()
11229 
      if ftype == TType.STOP:
11230 
        break
11231 
      if fid == 1:
11232 
        if ftype == TType.STRING:
11233 
          self.bannerName = iprot.readString();
11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      else:
11237 
        iprot.skip(ftype)
11238 
      iprot.readFieldEnd()
11239 
    iprot.readStructEnd()
11240 
 
11241 
  def write(self, oprot):
11242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11244 
      return
11245 
    oprot.writeStructBegin('deleteBannerMap_args')
11246 
    if self.bannerName is not None:
11247 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11248 
      oprot.writeString(self.bannerName)
11249 
      oprot.writeFieldEnd()
11250 
    oprot.writeFieldStop()
11251 
    oprot.writeStructEnd()
11252 
 
11253 
  def validate(self):
11254 
    return
11255 
 
11256 
 
11257 
  def __repr__(self):
11258 
    L = ['%s=%r' % (key, value)
11259 
      for key, value in self.__dict__.iteritems()]
11260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11261 
 
11262 
  def __eq__(self, other):
11263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11264 
 
11265 
  def __ne__(self, other):
11266 
    return not (self == other)
11267 
 
11268 
class deleteBannerMap_result:
11269 
  """
11270 
  Attributes:
11271 
   - success
11272 
  """
11273 
 
11274 
  thrift_spec = (
11275 
    (0, TType.BOOL, 'success', None, None, ), # 0
11276 
  )
11277 
 
11278 
  def __init__(self, success=None,):
11279 
    self.success = success
11280 
 
11281 
  def read(self, iprot):
11282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11284 
      return
11285 
    iprot.readStructBegin()
11286 
    while True:
11287 
      (fname, ftype, fid) = iprot.readFieldBegin()
11288 
      if ftype == TType.STOP:
11289 
        break
11290 
      if fid == 0:
11291 
        if ftype == TType.BOOL:
11292 
          self.success = iprot.readBool();
11293 
        else:
11294 
          iprot.skip(ftype)
11295 
      else:
11296 
        iprot.skip(ftype)
11297 
      iprot.readFieldEnd()
11298 
    iprot.readStructEnd()
11299 
 
11300 
  def write(self, oprot):
11301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11303 
      return
11304 
    oprot.writeStructBegin('deleteBannerMap_result')
11305 
    if self.success is not None:
11306 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11307 
      oprot.writeBool(self.success)
11308 
      oprot.writeFieldEnd()
11309 
    oprot.writeFieldStop()
11310 
    oprot.writeStructEnd()
11311 
 
11312 
  def validate(self):
11313 
    return
11314 
 
11315 
 
11316 
  def __repr__(self):
11317 
    L = ['%s=%r' % (key, value)
11318 
      for key, value in self.__dict__.iteritems()]
11319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11320 
 
11321 
  def __eq__(self, other):
11322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11323 
 
11324 
  def __ne__(self, other):
11325 
    return not (self == other)
11326 
 
11327 
class getBannerMapDetails_args:
11328 
  """
11329 
  Attributes:
11330 
   - bannerName
11331 
  """
11332 
 
11333 
  thrift_spec = (
11334 
    None, # 0
11335 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11336 
  )
11337 
 
11338 
  def __init__(self, bannerName=None,):
11339 
    self.bannerName = bannerName
11340 
 
11341 
  def read(self, iprot):
11342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11344 
      return
11345 
    iprot.readStructBegin()
11346 
    while True:
11347 
      (fname, ftype, fid) = iprot.readFieldBegin()
11348 
      if ftype == TType.STOP:
11349 
        break
11350 
      if fid == 1:
11351 
        if ftype == TType.STRING:
11352 
          self.bannerName = iprot.readString();
11353 
        else:
11354 
          iprot.skip(ftype)
11355 
      else:
11356 
        iprot.skip(ftype)
11357 
      iprot.readFieldEnd()
11358 
    iprot.readStructEnd()
11359 
 
11360 
  def write(self, oprot):
11361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11363 
      return
11364 
    oprot.writeStructBegin('getBannerMapDetails_args')
11365 
    if self.bannerName is not None:
11366 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11367 
      oprot.writeString(self.bannerName)
11368 
      oprot.writeFieldEnd()
11369 
    oprot.writeFieldStop()
11370 
    oprot.writeStructEnd()
11371 
 
11372 
  def validate(self):
11373 
    return
11374 
 
11375 
 
11376 
  def __repr__(self):
11377 
    L = ['%s=%r' % (key, value)
11378 
      for key, value in self.__dict__.iteritems()]
11379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11380 
 
11381 
  def __eq__(self, other):
11382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11383 
 
11384 
  def __ne__(self, other):
11385 
    return not (self == other)
11386 
 
11387 
class getBannerMapDetails_result:
11388 
  """
11389 
  Attributes:
11390 
   - success
11391 
  """
11392 
 
11393 
  thrift_spec = (
11394 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11395 
  )
11396 
 
11397 
  def __init__(self, success=None,):
11398 
    self.success = success
11399 
 
11400 
  def read(self, iprot):
11401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11403 
      return
11404 
    iprot.readStructBegin()
11405 
    while True:
11406 
      (fname, ftype, fid) = iprot.readFieldBegin()
11407 
      if ftype == TType.STOP:
11408 
        break
11409 
      if fid == 0:
11410 
        if ftype == TType.LIST:
11411 
          self.success = []
6850 kshitij.so 11412 
          (_etype182, _size179) = iprot.readListBegin()
11413 
          for _i183 in xrange(_size179):
11414 
            _elem184 = BannerMap()
11415 
            _elem184.read(iprot)
11416 
            self.success.append(_elem184)
6849 kshitij.so 11417 
          iprot.readListEnd()
11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      else:
11421 
        iprot.skip(ftype)
11422 
      iprot.readFieldEnd()
11423 
    iprot.readStructEnd()
11424 
 
11425 
  def write(self, oprot):
11426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11428 
      return
11429 
    oprot.writeStructBegin('getBannerMapDetails_result')
11430 
    if self.success is not None:
11431 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11432 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11433 
      for iter185 in self.success:
11434 
        iter185.write(oprot)
6849 kshitij.so 11435 
      oprot.writeListEnd()
11436 
      oprot.writeFieldEnd()
11437 
    oprot.writeFieldStop()
11438 
    oprot.writeStructEnd()
11439 
 
11440 
  def validate(self):
11441 
    return
11442 
 
11443 
 
11444 
  def __repr__(self):
11445 
    L = ['%s=%r' % (key, value)
11446 
      for key, value in self.__dict__.iteritems()]
11447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11448 
 
11449 
  def __eq__(self, other):
11450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11451 
 
11452 
  def __ne__(self, other):
11453 
    return not (self == other)
11454 
 
5944 mandeep.dh 11455 
class deleteSimilarItem_args:
11456 
  """
11457 
  Attributes:
11458 
   - itemId
11459 
   - catalogItemId
11460 
  """
11461 
 
11462 
  thrift_spec = (
11463 
    None, # 0
11464 
    (1, TType.I64, 'itemId', None, None, ), # 1
11465 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11466 
  )
11467 
 
11468 
  def __init__(self, itemId=None, catalogItemId=None,):
11469 
    self.itemId = itemId
11470 
    self.catalogItemId = catalogItemId
11471 
 
11472 
  def read(self, iprot):
11473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11475 
      return
11476 
    iprot.readStructBegin()
11477 
    while True:
11478 
      (fname, ftype, fid) = iprot.readFieldBegin()
11479 
      if ftype == TType.STOP:
11480 
        break
11481 
      if fid == 1:
11482 
        if ftype == TType.I64:
11483 
          self.itemId = iprot.readI64();
11484 
        else:
11485 
          iprot.skip(ftype)
11486 
      elif fid == 2:
11487 
        if ftype == TType.I64:
11488 
          self.catalogItemId = iprot.readI64();
11489 
        else:
11490 
          iprot.skip(ftype)
11491 
      else:
11492 
        iprot.skip(ftype)
11493 
      iprot.readFieldEnd()
11494 
    iprot.readStructEnd()
11495 
 
11496 
  def write(self, oprot):
11497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11499 
      return
11500 
    oprot.writeStructBegin('deleteSimilarItem_args')
11501 
    if self.itemId is not None:
11502 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11503 
      oprot.writeI64(self.itemId)
11504 
      oprot.writeFieldEnd()
11505 
    if self.catalogItemId is not None:
11506 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11507 
      oprot.writeI64(self.catalogItemId)
11508 
      oprot.writeFieldEnd()
11509 
    oprot.writeFieldStop()
11510 
    oprot.writeStructEnd()
11511 
 
11512 
  def validate(self):
11513 
    return
11514 
 
11515 
 
11516 
  def __repr__(self):
11517 
    L = ['%s=%r' % (key, value)
11518 
      for key, value in self.__dict__.iteritems()]
11519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11520 
 
11521 
  def __eq__(self, other):
11522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11523 
 
11524 
  def __ne__(self, other):
11525 
    return not (self == other)
11526 
 
11527 
class deleteSimilarItem_result:
11528 
  """
11529 
  Attributes:
11530 
   - success
11531 
   - cex
11532 
  """
11533 
 
11534 
  thrift_spec = (
11535 
    (0, TType.BOOL, 'success', None, None, ), # 0
11536 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11537 
  )
11538 
 
11539 
  def __init__(self, success=None, cex=None,):
11540 
    self.success = success
11541 
    self.cex = cex
11542 
 
11543 
  def read(self, iprot):
11544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11546 
      return
11547 
    iprot.readStructBegin()
11548 
    while True:
11549 
      (fname, ftype, fid) = iprot.readFieldBegin()
11550 
      if ftype == TType.STOP:
11551 
        break
11552 
      if fid == 0:
11553 
        if ftype == TType.BOOL:
11554 
          self.success = iprot.readBool();
11555 
        else:
11556 
          iprot.skip(ftype)
11557 
      elif fid == 1:
11558 
        if ftype == TType.STRUCT:
11559 
          self.cex = CatalogServiceException()
11560 
          self.cex.read(iprot)
11561 
        else:
11562 
          iprot.skip(ftype)
11563 
      else:
11564 
        iprot.skip(ftype)
11565 
      iprot.readFieldEnd()
11566 
    iprot.readStructEnd()
11567 
 
11568 
  def write(self, oprot):
11569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11571 
      return
11572 
    oprot.writeStructBegin('deleteSimilarItem_result')
11573 
    if self.success is not None:
11574 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11575 
      oprot.writeBool(self.success)
11576 
      oprot.writeFieldEnd()
11577 
    if self.cex is not None:
11578 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11579 
      self.cex.write(oprot)
11580 
      oprot.writeFieldEnd()
11581 
    oprot.writeFieldStop()
11582 
    oprot.writeStructEnd()
11583 
 
11584 
  def validate(self):
11585 
    return
11586 
 
11587 
 
11588 
  def __repr__(self):
11589 
    L = ['%s=%r' % (key, value)
11590 
      for key, value in self.__dict__.iteritems()]
11591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11592 
 
11593 
  def __eq__(self, other):
11594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11595 
 
11596 
  def __ne__(self, other):
11597 
    return not (self == other)
11598 
 
11599 
class checkSimilarItem_args:
11600 
  """
11601 
  Attributes:
11602 
   - brand
11603 
   - modelNumber
11604 
   - modelName
11605 
   - color
11606 
  """
11607 
 
11608 
  thrift_spec = (
11609 
    None, # 0
11610 
    (1, TType.STRING, 'brand', None, None, ), # 1
11611 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11612 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11613 
    (4, TType.STRING, 'color', None, None, ), # 4
11614 
  )
11615 
 
11616 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11617 
    self.brand = brand
11618 
    self.modelNumber = modelNumber
11619 
    self.modelName = modelName
11620 
    self.color = color
11621 
 
11622 
  def read(self, iprot):
11623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11625 
      return
11626 
    iprot.readStructBegin()
11627 
    while True:
11628 
      (fname, ftype, fid) = iprot.readFieldBegin()
11629 
      if ftype == TType.STOP:
11630 
        break
11631 
      if fid == 1:
11632 
        if ftype == TType.STRING:
11633 
          self.brand = iprot.readString();
11634 
        else:
11635 
          iprot.skip(ftype)
11636 
      elif fid == 2:
11637 
        if ftype == TType.STRING:
11638 
          self.modelNumber = iprot.readString();
11639 
        else:
11640 
          iprot.skip(ftype)
11641 
      elif fid == 3:
11642 
        if ftype == TType.STRING:
11643 
          self.modelName = iprot.readString();
11644 
        else:
11645 
          iprot.skip(ftype)
11646 
      elif fid == 4:
11647 
        if ftype == TType.STRING:
11648 
          self.color = iprot.readString();
11649 
        else:
11650 
          iprot.skip(ftype)
11651 
      else:
11652 
        iprot.skip(ftype)
11653 
      iprot.readFieldEnd()
11654 
    iprot.readStructEnd()
11655 
 
11656 
  def write(self, oprot):
11657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11659 
      return
11660 
    oprot.writeStructBegin('checkSimilarItem_args')
11661 
    if self.brand is not None:
11662 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11663 
      oprot.writeString(self.brand)
11664 
      oprot.writeFieldEnd()
11665 
    if self.modelNumber is not None:
11666 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11667 
      oprot.writeString(self.modelNumber)
11668 
      oprot.writeFieldEnd()
11669 
    if self.modelName is not None:
11670 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11671 
      oprot.writeString(self.modelName)
11672 
      oprot.writeFieldEnd()
11673 
    if self.color is not None:
11674 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11675 
      oprot.writeString(self.color)
11676 
      oprot.writeFieldEnd()
11677 
    oprot.writeFieldStop()
11678 
    oprot.writeStructEnd()
11679 
 
11680 
  def validate(self):
11681 
    return
11682 
 
11683 
 
11684 
  def __repr__(self):
11685 
    L = ['%s=%r' % (key, value)
11686 
      for key, value in self.__dict__.iteritems()]
11687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11688 
 
11689 
  def __eq__(self, other):
11690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11691 
 
11692 
  def __ne__(self, other):
11693 
    return not (self == other)
11694 
 
11695 
class checkSimilarItem_result:
11696 
  """
11697 
  Attributes:
11698 
   - success
11699 
  """
11700 
 
11701 
  thrift_spec = (
11702 
    (0, TType.I64, 'success', None, None, ), # 0
11703 
  )
11704 
 
11705 
  def __init__(self, success=None,):
11706 
    self.success = success
11707 
 
11708 
  def read(self, iprot):
11709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11711 
      return
11712 
    iprot.readStructBegin()
11713 
    while True:
11714 
      (fname, ftype, fid) = iprot.readFieldBegin()
11715 
      if ftype == TType.STOP:
11716 
        break
11717 
      if fid == 0:
11718 
        if ftype == TType.I64:
11719 
          self.success = iprot.readI64();
11720 
        else:
11721 
          iprot.skip(ftype)
11722 
      else:
11723 
        iprot.skip(ftype)
11724 
      iprot.readFieldEnd()
11725 
    iprot.readStructEnd()
11726 
 
11727 
  def write(self, oprot):
11728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11730 
      return
11731 
    oprot.writeStructBegin('checkSimilarItem_result')
11732 
    if self.success is not None:
11733 
      oprot.writeFieldBegin('success', TType.I64, 0)
11734 
      oprot.writeI64(self.success)
11735 
      oprot.writeFieldEnd()
11736 
    oprot.writeFieldStop()
11737 
    oprot.writeStructEnd()
11738 
 
11739 
  def validate(self):
11740 
    return
11741 
 
11742 
 
11743 
  def __repr__(self):
11744 
    L = ['%s=%r' % (key, value)
11745 
      for key, value in self.__dict__.iteritems()]
11746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11747 
 
11748 
  def __eq__(self, other):
11749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11750 
 
11751 
  def __ne__(self, other):
11752 
    return not (self == other)
11753 
 
11754 
class validateRiskyStatus_args:
11755 
  """
11756 
  Attributes:
11757 
   - itemId
11758 
  """
11759 
 
11760 
  thrift_spec = (
11761 
    None, # 0
11762 
    (1, TType.I64, 'itemId', None, None, ), # 1
11763 
  )
11764 
 
11765 
  def __init__(self, itemId=None,):
11766 
    self.itemId = itemId
11767 
 
11768 
  def read(self, iprot):
11769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11771 
      return
11772 
    iprot.readStructBegin()
11773 
    while True:
11774 
      (fname, ftype, fid) = iprot.readFieldBegin()
11775 
      if ftype == TType.STOP:
11776 
        break
11777 
      if fid == 1:
11778 
        if ftype == TType.I64:
11779 
          self.itemId = iprot.readI64();
11780 
        else:
11781 
          iprot.skip(ftype)
11782 
      else:
11783 
        iprot.skip(ftype)
11784 
      iprot.readFieldEnd()
11785 
    iprot.readStructEnd()
11786 
 
11787 
  def write(self, oprot):
11788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11790 
      return
11791 
    oprot.writeStructBegin('validateRiskyStatus_args')
11792 
    if self.itemId is not None:
11793 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11794 
      oprot.writeI64(self.itemId)
11795 
      oprot.writeFieldEnd()
11796 
    oprot.writeFieldStop()
11797 
    oprot.writeStructEnd()
11798 
 
11799 
  def validate(self):
11800 
    return
11801 
 
11802 
 
11803 
  def __repr__(self):
11804 
    L = ['%s=%r' % (key, value)
11805 
      for key, value in self.__dict__.iteritems()]
11806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11807 
 
11808 
  def __eq__(self, other):
11809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11810 
 
11811 
  def __ne__(self, other):
11812 
    return not (self == other)
11813 
 
11814 
class validateRiskyStatus_result:
11815 
 
11816 
  thrift_spec = (
11817 
  )
11818 
 
11819 
  def read(self, iprot):
11820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11822 
      return
11823 
    iprot.readStructBegin()
11824 
    while True:
11825 
      (fname, ftype, fid) = iprot.readFieldBegin()
11826 
      if ftype == TType.STOP:
11827 
        break
11828 
      else:
11829 
        iprot.skip(ftype)
11830 
      iprot.readFieldEnd()
11831 
    iprot.readStructEnd()
11832 
 
11833 
  def write(self, oprot):
11834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11836 
      return
11837 
    oprot.writeStructBegin('validateRiskyStatus_result')
11838 
    oprot.writeFieldStop()
11839 
    oprot.writeStructEnd()
11840 
 
11841 
  def validate(self):
11842 
    return
11843 
 
11844 
 
11845 
  def __repr__(self):
11846 
    L = ['%s=%r' % (key, value)
11847 
      for key, value in self.__dict__.iteritems()]
11848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11849 
 
11850 
  def __eq__(self, other):
11851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11852 
 
11853 
  def __ne__(self, other):
11854 
    return not (self == other)
11855 
 
11856 
class changeItemRiskyFlag_args:
11857 
  """
11858 
  Attributes:
11859 
   - itemId
11860 
   - risky
11861 
  """
11862 
 
11863 
  thrift_spec = (
11864 
    None, # 0
11865 
    (1, TType.I64, 'itemId', None, None, ), # 1
11866 
    (2, TType.BOOL, 'risky', None, None, ), # 2
11867 
  )
11868 
 
11869 
  def __init__(self, itemId=None, risky=None,):
11870 
    self.itemId = itemId
11871 
    self.risky = risky
11872 
 
11873 
  def read(self, iprot):
11874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11876 
      return
11877 
    iprot.readStructBegin()
11878 
    while True:
11879 
      (fname, ftype, fid) = iprot.readFieldBegin()
11880 
      if ftype == TType.STOP:
11881 
        break
11882 
      if fid == 1:
11883 
        if ftype == TType.I64:
11884 
          self.itemId = iprot.readI64();
11885 
        else:
11886 
          iprot.skip(ftype)
11887 
      elif fid == 2:
11888 
        if ftype == TType.BOOL:
11889 
          self.risky = iprot.readBool();
11890 
        else:
11891 
          iprot.skip(ftype)
11892 
      else:
11893 
        iprot.skip(ftype)
11894 
      iprot.readFieldEnd()
11895 
    iprot.readStructEnd()
11896 
 
11897 
  def write(self, oprot):
11898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11900 
      return
11901 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
11902 
    if self.itemId is not None:
11903 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11904 
      oprot.writeI64(self.itemId)
11905 
      oprot.writeFieldEnd()
11906 
    if self.risky is not None:
11907 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
11908 
      oprot.writeBool(self.risky)
11909 
      oprot.writeFieldEnd()
11910 
    oprot.writeFieldStop()
11911 
    oprot.writeStructEnd()
11912 
 
11913 
  def validate(self):
11914 
    return
11915 
 
11916 
 
11917 
  def __repr__(self):
11918 
    L = ['%s=%r' % (key, value)
11919 
      for key, value in self.__dict__.iteritems()]
11920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11921 
 
11922 
  def __eq__(self, other):
11923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11924 
 
11925 
  def __ne__(self, other):
11926 
    return not (self == other)
11927 
 
11928 
class changeItemRiskyFlag_result:
11929 
 
11930 
  thrift_spec = (
11931 
  )
11932 
 
11933 
  def read(self, iprot):
11934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11936 
      return
11937 
    iprot.readStructBegin()
11938 
    while True:
11939 
      (fname, ftype, fid) = iprot.readFieldBegin()
11940 
      if ftype == TType.STOP:
11941 
        break
11942 
      else:
11943 
        iprot.skip(ftype)
11944 
      iprot.readFieldEnd()
11945 
    iprot.readStructEnd()
11946 
 
11947 
  def write(self, oprot):
11948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11950 
      return
11951 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
11952 
    oprot.writeFieldStop()
11953 
    oprot.writeStructEnd()
11954 
 
11955 
  def validate(self):
11956 
    return
11957 
 
11958 
 
11959 
  def __repr__(self):
11960 
    L = ['%s=%r' % (key, value)
11961 
      for key, value in self.__dict__.iteritems()]
11962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11963 
 
11964 
  def __eq__(self, other):
11965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11966 
 
11967 
  def __ne__(self, other):
11968 
    return not (self == other)
11969 
 
11970 
class getItemsByRiskyFlag_args:
11971 
 
11972 
  thrift_spec = (
11973 
  )
11974 
 
11975 
  def read(self, iprot):
11976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11978 
      return
11979 
    iprot.readStructBegin()
11980 
    while True:
11981 
      (fname, ftype, fid) = iprot.readFieldBegin()
11982 
      if ftype == TType.STOP:
11983 
        break
11984 
      else:
11985 
        iprot.skip(ftype)
11986 
      iprot.readFieldEnd()
11987 
    iprot.readStructEnd()
11988 
 
11989 
  def write(self, oprot):
11990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11992 
      return
11993 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
11994 
    oprot.writeFieldStop()
11995 
    oprot.writeStructEnd()
11996 
 
11997 
  def validate(self):
11998 
    return
11999 
 
12000 
 
12001 
  def __repr__(self):
12002 
    L = ['%s=%r' % (key, value)
12003 
      for key, value in self.__dict__.iteritems()]
12004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12005 
 
12006 
  def __eq__(self, other):
12007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12008 
 
12009 
  def __ne__(self, other):
12010 
    return not (self == other)
12011 
 
12012 
class getItemsByRiskyFlag_result:
12013 
  """
12014 
  Attributes:
12015 
   - success
12016 
  """
12017 
 
12018 
  thrift_spec = (
12019 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12020 
  )
12021 
 
12022 
  def __init__(self, success=None,):
12023 
    self.success = success
12024 
 
12025 
  def read(self, iprot):
12026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12028 
      return
12029 
    iprot.readStructBegin()
12030 
    while True:
12031 
      (fname, ftype, fid) = iprot.readFieldBegin()
12032 
      if ftype == TType.STOP:
12033 
        break
12034 
      if fid == 0:
12035 
        if ftype == TType.LIST:
12036 
          self.success = []
6850 kshitij.so 12037 
          (_etype189, _size186) = iprot.readListBegin()
12038 
          for _i190 in xrange(_size186):
12039 
            _elem191 = Item()
12040 
            _elem191.read(iprot)
12041 
            self.success.append(_elem191)
5944 mandeep.dh 12042 
          iprot.readListEnd()
12043 
        else:
12044 
          iprot.skip(ftype)
12045 
      else:
12046 
        iprot.skip(ftype)
12047 
      iprot.readFieldEnd()
12048 
    iprot.readStructEnd()
12049 
 
12050 
  def write(self, oprot):
12051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12053 
      return
12054 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12055 
    if self.success is not None:
12056 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12057 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12058 
      for iter192 in self.success:
12059 
        iter192.write(oprot)
5944 mandeep.dh 12060 
      oprot.writeListEnd()
12061 
      oprot.writeFieldEnd()
12062 
    oprot.writeFieldStop()
12063 
    oprot.writeStructEnd()
12064 
 
12065 
  def validate(self):
12066 
    return
12067 
 
12068 
 
12069 
  def __repr__(self):
12070 
    L = ['%s=%r' % (key, value)
12071 
      for key, value in self.__dict__.iteritems()]
12072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12073 
 
12074 
  def __eq__(self, other):
12075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12076 
 
12077 
  def __ne__(self, other):
12078 
    return not (self == other)
12079 
 
12080 
class getItemsForMasterSheet_args:
12081 
  """
12082 
  Attributes:
12083 
   - category
12084 
   - brand
12085 
  """
12086 
 
12087 
  thrift_spec = (
12088 
    None, # 0
12089 
    (1, TType.STRING, 'category', None, None, ), # 1
12090 
    (2, TType.STRING, 'brand', None, None, ), # 2
12091 
  )
12092 
 
12093 
  def __init__(self, category=None, brand=None,):
12094 
    self.category = category
12095 
    self.brand = brand
12096 
 
12097 
  def read(self, iprot):
12098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12100 
      return
12101 
    iprot.readStructBegin()
12102 
    while True:
12103 
      (fname, ftype, fid) = iprot.readFieldBegin()
12104 
      if ftype == TType.STOP:
12105 
        break
12106 
      if fid == 1:
12107 
        if ftype == TType.STRING:
12108 
          self.category = iprot.readString();
12109 
        else:
12110 
          iprot.skip(ftype)
12111 
      elif fid == 2:
12112 
        if ftype == TType.STRING:
12113 
          self.brand = iprot.readString();
12114 
        else:
12115 
          iprot.skip(ftype)
12116 
      else:
12117 
        iprot.skip(ftype)
12118 
      iprot.readFieldEnd()
12119 
    iprot.readStructEnd()
12120 
 
12121 
  def write(self, oprot):
12122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12124 
      return
12125 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12126 
    if self.category is not None:
12127 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12128 
      oprot.writeString(self.category)
12129 
      oprot.writeFieldEnd()
12130 
    if self.brand is not None:
12131 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12132 
      oprot.writeString(self.brand)
12133 
      oprot.writeFieldEnd()
12134 
    oprot.writeFieldStop()
12135 
    oprot.writeStructEnd()
12136 
 
12137 
  def validate(self):
12138 
    return
12139 
 
12140 
 
12141 
  def __repr__(self):
12142 
    L = ['%s=%r' % (key, value)
12143 
      for key, value in self.__dict__.iteritems()]
12144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12145 
 
12146 
  def __eq__(self, other):
12147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12148 
 
12149 
  def __ne__(self, other):
12150 
    return not (self == other)
12151 
 
12152 
class getItemsForMasterSheet_result:
12153 
  """
12154 
  Attributes:
12155 
   - success
12156 
  """
12157 
 
12158 
  thrift_spec = (
12159 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12160 
  )
12161 
 
12162 
  def __init__(self, success=None,):
12163 
    self.success = success
12164 
 
12165 
  def read(self, iprot):
12166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12168 
      return
12169 
    iprot.readStructBegin()
12170 
    while True:
12171 
      (fname, ftype, fid) = iprot.readFieldBegin()
12172 
      if ftype == TType.STOP:
12173 
        break
12174 
      if fid == 0:
12175 
        if ftype == TType.LIST:
12176 
          self.success = []
6850 kshitij.so 12177 
          (_etype196, _size193) = iprot.readListBegin()
12178 
          for _i197 in xrange(_size193):
12179 
            _elem198 = Item()
12180 
            _elem198.read(iprot)
12181 
            self.success.append(_elem198)
5944 mandeep.dh 12182 
          iprot.readListEnd()
12183 
        else:
12184 
          iprot.skip(ftype)
12185 
      else:
12186 
        iprot.skip(ftype)
12187 
      iprot.readFieldEnd()
12188 
    iprot.readStructEnd()
12189 
 
12190 
  def write(self, oprot):
12191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12193 
      return
12194 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12195 
    if self.success is not None:
12196 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12197 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12198 
      for iter199 in self.success:
12199 
        iter199.write(oprot)
5944 mandeep.dh 12200 
      oprot.writeListEnd()
12201 
      oprot.writeFieldEnd()
12202 
    oprot.writeFieldStop()
12203 
    oprot.writeStructEnd()
12204 
 
12205 
  def validate(self):
12206 
    return
12207 
 
12208 
 
12209 
  def __repr__(self):
12210 
    L = ['%s=%r' % (key, value)
12211 
      for key, value in self.__dict__.iteritems()]
12212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12213 
 
12214 
  def __eq__(self, other):
12215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12216 
 
12217 
  def __ne__(self, other):
12218 
    return not (self == other)
12219 
 
12220 
class getSimilarItemsCatalogIds_args:
12221 
  """
12222 
  Attributes:
12223 
   - beginIndex
12224 
   - totalItems
12225 
   - itemId
12226 
  """
12227 
 
12228 
  thrift_spec = (
12229 
    None, # 0
12230 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12231 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12232 
    (3, TType.I64, 'itemId', None, None, ), # 3
12233 
  )
12234 
 
12235 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12236 
    self.beginIndex = beginIndex
12237 
    self.totalItems = totalItems
12238 
    self.itemId = itemId
12239 
 
12240 
  def read(self, iprot):
12241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12243 
      return
12244 
    iprot.readStructBegin()
12245 
    while True:
12246 
      (fname, ftype, fid) = iprot.readFieldBegin()
12247 
      if ftype == TType.STOP:
12248 
        break
12249 
      if fid == 1:
12250 
        if ftype == TType.I64:
12251 
          self.beginIndex = iprot.readI64();
12252 
        else:
12253 
          iprot.skip(ftype)
12254 
      elif fid == 2:
12255 
        if ftype == TType.I64:
12256 
          self.totalItems = iprot.readI64();
12257 
        else:
12258 
          iprot.skip(ftype)
12259 
      elif fid == 3:
12260 
        if ftype == TType.I64:
12261 
          self.itemId = iprot.readI64();
12262 
        else:
12263 
          iprot.skip(ftype)
12264 
      else:
12265 
        iprot.skip(ftype)
12266 
      iprot.readFieldEnd()
12267 
    iprot.readStructEnd()
12268 
 
12269 
  def write(self, oprot):
12270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12272 
      return
12273 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12274 
    if self.beginIndex is not None:
12275 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12276 
      oprot.writeI64(self.beginIndex)
12277 
      oprot.writeFieldEnd()
12278 
    if self.totalItems is not None:
12279 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12280 
      oprot.writeI64(self.totalItems)
12281 
      oprot.writeFieldEnd()
12282 
    if self.itemId is not None:
12283 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12284 
      oprot.writeI64(self.itemId)
12285 
      oprot.writeFieldEnd()
12286 
    oprot.writeFieldStop()
12287 
    oprot.writeStructEnd()
12288 
 
12289 
  def validate(self):
12290 
    return
12291 
 
12292 
 
12293 
  def __repr__(self):
12294 
    L = ['%s=%r' % (key, value)
12295 
      for key, value in self.__dict__.iteritems()]
12296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12297 
 
12298 
  def __eq__(self, other):
12299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12300 
 
12301 
  def __ne__(self, other):
12302 
    return not (self == other)
12303 
 
12304 
class getSimilarItemsCatalogIds_result:
12305 
  """
12306 
  Attributes:
12307 
   - success
12308 
  """
12309 
 
12310 
  thrift_spec = (
12311 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12312 
  )
12313 
 
12314 
  def __init__(self, success=None,):
12315 
    self.success = success
12316 
 
12317 
  def read(self, iprot):
12318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12320 
      return
12321 
    iprot.readStructBegin()
12322 
    while True:
12323 
      (fname, ftype, fid) = iprot.readFieldBegin()
12324 
      if ftype == TType.STOP:
12325 
        break
12326 
      if fid == 0:
12327 
        if ftype == TType.LIST:
12328 
          self.success = []
6850 kshitij.so 12329 
          (_etype203, _size200) = iprot.readListBegin()
12330 
          for _i204 in xrange(_size200):
12331 
            _elem205 = iprot.readI64();
12332 
            self.success.append(_elem205)
5944 mandeep.dh 12333 
          iprot.readListEnd()
12334 
        else:
12335 
          iprot.skip(ftype)
12336 
      else:
12337 
        iprot.skip(ftype)
12338 
      iprot.readFieldEnd()
12339 
    iprot.readStructEnd()
12340 
 
12341 
  def write(self, oprot):
12342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12344 
      return
12345 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12346 
    if self.success is not None:
12347 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12348 
      oprot.writeListBegin(TType.I64, len(self.success))
6850 kshitij.so 12349 
      for iter206 in self.success:
12350 
        oprot.writeI64(iter206)
5944 mandeep.dh 12351 
      oprot.writeListEnd()
12352 
      oprot.writeFieldEnd()
12353 
    oprot.writeFieldStop()
12354 
    oprot.writeStructEnd()
12355 
 
12356 
  def validate(self):
12357 
    return
12358 
 
12359 
 
12360 
  def __repr__(self):
12361 
    L = ['%s=%r' % (key, value)
12362 
      for key, value in self.__dict__.iteritems()]
12363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12364 
 
12365 
  def __eq__(self, other):
12366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12367 
 
12368 
  def __ne__(self, other):
12369 
    return not (self == other)
12370 
 
12371 
class addProductNotification_args:
12372 
  """
12373 
  Attributes:
12374 
   - itemId
12375 
   - email
12376 
  """
12377 
 
12378 
  thrift_spec = None
12379 
  def __init__(self, itemId=None, email=None,):
12380 
    self.itemId = itemId
12381 
    self.email = email
12382 
 
12383 
  def read(self, iprot):
12384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12386 
      return
12387 
    iprot.readStructBegin()
12388 
    while True:
12389 
      (fname, ftype, fid) = iprot.readFieldBegin()
12390 
      if ftype == TType.STOP:
12391 
        break
12392 
      if fid == -1:
12393 
        if ftype == TType.I64:
12394 
          self.itemId = iprot.readI64();
12395 
        else:
12396 
          iprot.skip(ftype)
12397 
      elif fid == -2:
12398 
        if ftype == TType.STRING:
12399 
          self.email = iprot.readString();
12400 
        else:
12401 
          iprot.skip(ftype)
12402 
      else:
12403 
        iprot.skip(ftype)
12404 
      iprot.readFieldEnd()
12405 
    iprot.readStructEnd()
12406 
 
12407 
  def write(self, oprot):
12408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12410 
      return
12411 
    oprot.writeStructBegin('addProductNotification_args')
12412 
    if self.email is not None:
12413 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12414 
      oprot.writeString(self.email)
12415 
      oprot.writeFieldEnd()
12416 
    if self.itemId is not None:
12417 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12418 
      oprot.writeI64(self.itemId)
12419 
      oprot.writeFieldEnd()
12420 
    oprot.writeFieldStop()
12421 
    oprot.writeStructEnd()
12422 
 
12423 
  def validate(self):
12424 
    return
12425 
 
12426 
 
12427 
  def __repr__(self):
12428 
    L = ['%s=%r' % (key, value)
12429 
      for key, value in self.__dict__.iteritems()]
12430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12431 
 
12432 
  def __eq__(self, other):
12433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12434 
 
12435 
  def __ne__(self, other):
12436 
    return not (self == other)
12437 
 
12438 
class addProductNotification_result:
12439 
  """
12440 
  Attributes:
12441 
   - success
12442 
  """
12443 
 
12444 
  thrift_spec = (
12445 
    (0, TType.BOOL, 'success', None, None, ), # 0
12446 
  )
12447 
 
12448 
  def __init__(self, success=None,):
12449 
    self.success = success
12450 
 
12451 
  def read(self, iprot):
12452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12454 
      return
12455 
    iprot.readStructBegin()
12456 
    while True:
12457 
      (fname, ftype, fid) = iprot.readFieldBegin()
12458 
      if ftype == TType.STOP:
12459 
        break
12460 
      if fid == 0:
12461 
        if ftype == TType.BOOL:
12462 
          self.success = iprot.readBool();
12463 
        else:
12464 
          iprot.skip(ftype)
12465 
      else:
12466 
        iprot.skip(ftype)
12467 
      iprot.readFieldEnd()
12468 
    iprot.readStructEnd()
12469 
 
12470 
  def write(self, oprot):
12471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12473 
      return
12474 
    oprot.writeStructBegin('addProductNotification_result')
12475 
    if self.success is not None:
12476 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12477 
      oprot.writeBool(self.success)
12478 
      oprot.writeFieldEnd()
12479 
    oprot.writeFieldStop()
12480 
    oprot.writeStructEnd()
12481 
 
12482 
  def validate(self):
12483 
    return
12484 
 
12485 
 
12486 
  def __repr__(self):
12487 
    L = ['%s=%r' % (key, value)
12488 
      for key, value in self.__dict__.iteritems()]
12489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12490 
 
12491 
  def __eq__(self, other):
12492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12493 
 
12494 
  def __ne__(self, other):
12495 
    return not (self == other)
12496 
 
12497 
class sendProductNotifications_args:
12498 
 
12499 
  thrift_spec = (
12500 
  )
12501 
 
12502 
  def read(self, iprot):
12503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12505 
      return
12506 
    iprot.readStructBegin()
12507 
    while True:
12508 
      (fname, ftype, fid) = iprot.readFieldBegin()
12509 
      if ftype == TType.STOP:
12510 
        break
12511 
      else:
12512 
        iprot.skip(ftype)
12513 
      iprot.readFieldEnd()
12514 
    iprot.readStructEnd()
12515 
 
12516 
  def write(self, oprot):
12517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12519 
      return
12520 
    oprot.writeStructBegin('sendProductNotifications_args')
12521 
    oprot.writeFieldStop()
12522 
    oprot.writeStructEnd()
12523 
 
12524 
  def validate(self):
12525 
    return
12526 
 
12527 
 
12528 
  def __repr__(self):
12529 
    L = ['%s=%r' % (key, value)
12530 
      for key, value in self.__dict__.iteritems()]
12531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12532 
 
12533 
  def __eq__(self, other):
12534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12535 
 
12536 
  def __ne__(self, other):
12537 
    return not (self == other)
12538 
 
12539 
class sendProductNotifications_result:
12540 
  """
12541 
  Attributes:
12542 
   - success
12543 
  """
12544 
 
12545 
  thrift_spec = (
12546 
    (0, TType.BOOL, 'success', None, None, ), # 0
12547 
  )
12548 
 
12549 
  def __init__(self, success=None,):
12550 
    self.success = success
12551 
 
12552 
  def read(self, iprot):
12553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12555 
      return
12556 
    iprot.readStructBegin()
12557 
    while True:
12558 
      (fname, ftype, fid) = iprot.readFieldBegin()
12559 
      if ftype == TType.STOP:
12560 
        break
12561 
      if fid == 0:
12562 
        if ftype == TType.BOOL:
12563 
          self.success = iprot.readBool();
12564 
        else:
12565 
          iprot.skip(ftype)
12566 
      else:
12567 
        iprot.skip(ftype)
12568 
      iprot.readFieldEnd()
12569 
    iprot.readStructEnd()
12570 
 
12571 
  def write(self, oprot):
12572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12574 
      return
12575 
    oprot.writeStructBegin('sendProductNotifications_result')
12576 
    if self.success is not None:
12577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12578 
      oprot.writeBool(self.success)
12579 
      oprot.writeFieldEnd()
12580 
    oprot.writeFieldStop()
12581 
    oprot.writeStructEnd()
12582 
 
12583 
  def validate(self):
12584 
    return
12585 
 
12586 
 
12587 
  def __repr__(self):
12588 
    L = ['%s=%r' % (key, value)
12589 
      for key, value in self.__dict__.iteritems()]
12590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12591 
 
12592 
  def __eq__(self, other):
12593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12594 
 
12595 
  def __ne__(self, other):
12596 
    return not (self == other)
12597 
 
12598 
class getAllBrandsByCategory_args:
12599 
  """
12600 
  Attributes:
12601 
   - categoryId
12602 
  """
12603 
 
12604 
  thrift_spec = (
12605 
    None, # 0
12606 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12607 
  )
12608 
 
12609 
  def __init__(self, categoryId=None,):
12610 
    self.categoryId = categoryId
12611 
 
12612 
  def read(self, iprot):
12613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12615 
      return
12616 
    iprot.readStructBegin()
12617 
    while True:
12618 
      (fname, ftype, fid) = iprot.readFieldBegin()
12619 
      if ftype == TType.STOP:
12620 
        break
12621 
      if fid == 1:
12622 
        if ftype == TType.I64:
12623 
          self.categoryId = iprot.readI64();
12624 
        else:
12625 
          iprot.skip(ftype)
12626 
      else:
12627 
        iprot.skip(ftype)
12628 
      iprot.readFieldEnd()
12629 
    iprot.readStructEnd()
12630 
 
12631 
  def write(self, oprot):
12632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12634 
      return
12635 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12636 
    if self.categoryId is not None:
12637 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12638 
      oprot.writeI64(self.categoryId)
12639 
      oprot.writeFieldEnd()
12640 
    oprot.writeFieldStop()
12641 
    oprot.writeStructEnd()
12642 
 
12643 
  def validate(self):
12644 
    return
12645 
 
12646 
 
12647 
  def __repr__(self):
12648 
    L = ['%s=%r' % (key, value)
12649 
      for key, value in self.__dict__.iteritems()]
12650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12651 
 
12652 
  def __eq__(self, other):
12653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12654 
 
12655 
  def __ne__(self, other):
12656 
    return not (self == other)
12657 
 
12658 
class getAllBrandsByCategory_result:
12659 
  """
12660 
  Attributes:
12661 
   - success
12662 
  """
12663 
 
12664 
  thrift_spec = (
12665 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12666 
  )
12667 
 
12668 
  def __init__(self, success=None,):
12669 
    self.success = success
12670 
 
12671 
  def read(self, iprot):
12672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12674 
      return
12675 
    iprot.readStructBegin()
12676 
    while True:
12677 
      (fname, ftype, fid) = iprot.readFieldBegin()
12678 
      if ftype == TType.STOP:
12679 
        break
12680 
      if fid == 0:
12681 
        if ftype == TType.LIST:
12682 
          self.success = []
6850 kshitij.so 12683 
          (_etype210, _size207) = iprot.readListBegin()
12684 
          for _i211 in xrange(_size207):
12685 
            _elem212 = iprot.readString();
12686 
            self.success.append(_elem212)
5944 mandeep.dh 12687 
          iprot.readListEnd()
12688 
        else:
12689 
          iprot.skip(ftype)
12690 
      else:
12691 
        iprot.skip(ftype)
12692 
      iprot.readFieldEnd()
12693 
    iprot.readStructEnd()
12694 
 
12695 
  def write(self, oprot):
12696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12698 
      return
12699 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12700 
    if self.success is not None:
12701 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12702 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12703 
      for iter213 in self.success:
12704 
        oprot.writeString(iter213)
5944 mandeep.dh 12705 
      oprot.writeListEnd()
12706 
      oprot.writeFieldEnd()
12707 
    oprot.writeFieldStop()
12708 
    oprot.writeStructEnd()
12709 
 
12710 
  def validate(self):
12711 
    return
12712 
 
12713 
 
12714 
  def __repr__(self):
12715 
    L = ['%s=%r' % (key, value)
12716 
      for key, value in self.__dict__.iteritems()]
12717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12718 
 
12719 
  def __eq__(self, other):
12720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12721 
 
12722 
  def __ne__(self, other):
12723 
    return not (self == other)
12724 
 
12725 
class getAllBrands_args:
12726 
 
12727 
  thrift_spec = (
12728 
  )
12729 
 
12730 
  def read(self, iprot):
12731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12733 
      return
12734 
    iprot.readStructBegin()
12735 
    while True:
12736 
      (fname, ftype, fid) = iprot.readFieldBegin()
12737 
      if ftype == TType.STOP:
12738 
        break
12739 
      else:
12740 
        iprot.skip(ftype)
12741 
      iprot.readFieldEnd()
12742 
    iprot.readStructEnd()
12743 
 
12744 
  def write(self, oprot):
12745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12747 
      return
12748 
    oprot.writeStructBegin('getAllBrands_args')
12749 
    oprot.writeFieldStop()
12750 
    oprot.writeStructEnd()
12751 
 
12752 
  def validate(self):
12753 
    return
12754 
 
12755 
 
12756 
  def __repr__(self):
12757 
    L = ['%s=%r' % (key, value)
12758 
      for key, value in self.__dict__.iteritems()]
12759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12760 
 
12761 
  def __eq__(self, other):
12762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12763 
 
12764 
  def __ne__(self, other):
12765 
    return not (self == other)
12766 
 
12767 
class getAllBrands_result:
12768 
  """
12769 
  Attributes:
12770 
   - success
12771 
  """
12772 
 
12773 
  thrift_spec = (
12774 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12775 
  )
12776 
 
12777 
  def __init__(self, success=None,):
12778 
    self.success = success
12779 
 
12780 
  def read(self, iprot):
12781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12783 
      return
12784 
    iprot.readStructBegin()
12785 
    while True:
12786 
      (fname, ftype, fid) = iprot.readFieldBegin()
12787 
      if ftype == TType.STOP:
12788 
        break
12789 
      if fid == 0:
12790 
        if ftype == TType.LIST:
12791 
          self.success = []
6850 kshitij.so 12792 
          (_etype217, _size214) = iprot.readListBegin()
12793 
          for _i218 in xrange(_size214):
12794 
            _elem219 = iprot.readString();
12795 
            self.success.append(_elem219)
5944 mandeep.dh 12796 
          iprot.readListEnd()
12797 
        else:
12798 
          iprot.skip(ftype)
12799 
      else:
12800 
        iprot.skip(ftype)
12801 
      iprot.readFieldEnd()
12802 
    iprot.readStructEnd()
12803 
 
12804 
  def write(self, oprot):
12805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12807 
      return
12808 
    oprot.writeStructBegin('getAllBrands_result')
12809 
    if self.success is not None:
12810 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12811 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12812 
      for iter220 in self.success:
12813 
        oprot.writeString(iter220)
5944 mandeep.dh 12814 
      oprot.writeListEnd()
12815 
      oprot.writeFieldEnd()
12816 
    oprot.writeFieldStop()
12817 
    oprot.writeStructEnd()
12818 
 
12819 
  def validate(self):
12820 
    return
12821 
 
12822 
 
12823 
  def __repr__(self):
12824 
    L = ['%s=%r' % (key, value)
12825 
      for key, value in self.__dict__.iteritems()]
12826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12827 
 
12828 
  def __eq__(self, other):
12829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12830 
 
12831 
  def __ne__(self, other):
12832 
    return not (self == other)
12833 
 
12834 
class getAllSources_args:
12835 
 
12836 
  thrift_spec = (
12837 
  )
12838 
 
12839 
  def read(self, iprot):
12840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12842 
      return
12843 
    iprot.readStructBegin()
12844 
    while True:
12845 
      (fname, ftype, fid) = iprot.readFieldBegin()
12846 
      if ftype == TType.STOP:
12847 
        break
12848 
      else:
12849 
        iprot.skip(ftype)
12850 
      iprot.readFieldEnd()
12851 
    iprot.readStructEnd()
12852 
 
12853 
  def write(self, oprot):
12854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12856 
      return
12857 
    oprot.writeStructBegin('getAllSources_args')
12858 
    oprot.writeFieldStop()
12859 
    oprot.writeStructEnd()
12860 
 
12861 
  def validate(self):
12862 
    return
12863 
 
12864 
 
12865 
  def __repr__(self):
12866 
    L = ['%s=%r' % (key, value)
12867 
      for key, value in self.__dict__.iteritems()]
12868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12869 
 
12870 
  def __eq__(self, other):
12871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12872 
 
12873 
  def __ne__(self, other):
12874 
    return not (self == other)
12875 
 
12876 
class getAllSources_result:
12877 
  """
12878 
  Attributes:
12879 
   - success
12880 
  """
12881 
 
12882 
  thrift_spec = (
12883 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
12884 
  )
12885 
 
12886 
  def __init__(self, success=None,):
12887 
    self.success = success
12888 
 
12889 
  def read(self, iprot):
12890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12892 
      return
12893 
    iprot.readStructBegin()
12894 
    while True:
12895 
      (fname, ftype, fid) = iprot.readFieldBegin()
12896 
      if ftype == TType.STOP:
12897 
        break
12898 
      if fid == 0:
12899 
        if ftype == TType.LIST:
12900 
          self.success = []
6850 kshitij.so 12901 
          (_etype224, _size221) = iprot.readListBegin()
12902 
          for _i225 in xrange(_size221):
12903 
            _elem226 = Source()
12904 
            _elem226.read(iprot)
12905 
            self.success.append(_elem226)
5944 mandeep.dh 12906 
          iprot.readListEnd()
12907 
        else:
12908 
          iprot.skip(ftype)
12909 
      else:
12910 
        iprot.skip(ftype)
12911 
      iprot.readFieldEnd()
12912 
    iprot.readStructEnd()
12913 
 
12914 
  def write(self, oprot):
12915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12917 
      return
12918 
    oprot.writeStructBegin('getAllSources_result')
12919 
    if self.success is not None:
12920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12922 
      for iter227 in self.success:
12923 
        iter227.write(oprot)
5944 mandeep.dh 12924 
      oprot.writeListEnd()
12925 
      oprot.writeFieldEnd()
12926 
    oprot.writeFieldStop()
12927 
    oprot.writeStructEnd()
12928 
 
12929 
  def validate(self):
12930 
    return
12931 
 
12932 
 
12933 
  def __repr__(self):
12934 
    L = ['%s=%r' % (key, value)
12935 
      for key, value in self.__dict__.iteritems()]
12936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12937 
 
12938 
  def __eq__(self, other):
12939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12940 
 
12941 
  def __ne__(self, other):
12942 
    return not (self == other)
12943 
 
12944 
class getItemPricingBySource_args:
12945 
  """
12946 
  Attributes:
12947 
   - itemId
12948 
   - sourceId
12949 
  """
12950 
 
12951 
  thrift_spec = (
12952 
    None, # 0
12953 
    (1, TType.I64, 'itemId', None, None, ), # 1
12954 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12955 
  )
12956 
 
12957 
  def __init__(self, itemId=None, sourceId=None,):
12958 
    self.itemId = itemId
12959 
    self.sourceId = sourceId
12960 
 
12961 
  def read(self, iprot):
12962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12964 
      return
12965 
    iprot.readStructBegin()
12966 
    while True:
12967 
      (fname, ftype, fid) = iprot.readFieldBegin()
12968 
      if ftype == TType.STOP:
12969 
        break
12970 
      if fid == 1:
12971 
        if ftype == TType.I64:
12972 
          self.itemId = iprot.readI64();
12973 
        else:
12974 
          iprot.skip(ftype)
12975 
      elif fid == 2:
12976 
        if ftype == TType.I64:
12977 
          self.sourceId = iprot.readI64();
12978 
        else:
12979 
          iprot.skip(ftype)
12980 
      else:
12981 
        iprot.skip(ftype)
12982 
      iprot.readFieldEnd()
12983 
    iprot.readStructEnd()
12984 
 
12985 
  def write(self, oprot):
12986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12988 
      return
12989 
    oprot.writeStructBegin('getItemPricingBySource_args')
12990 
    if self.itemId is not None:
12991 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12992 
      oprot.writeI64(self.itemId)
12993 
      oprot.writeFieldEnd()
12994 
    if self.sourceId is not None:
12995 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12996 
      oprot.writeI64(self.sourceId)
12997 
      oprot.writeFieldEnd()
12998 
    oprot.writeFieldStop()
12999 
    oprot.writeStructEnd()
13000 
 
13001 
  def validate(self):
13002 
    return
13003 
 
13004 
 
13005 
  def __repr__(self):
13006 
    L = ['%s=%r' % (key, value)
13007 
      for key, value in self.__dict__.iteritems()]
13008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13009 
 
13010 
  def __eq__(self, other):
13011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13012 
 
13013 
  def __ne__(self, other):
13014 
    return not (self == other)
13015 
 
13016 
class getItemPricingBySource_result:
13017 
  """
13018 
  Attributes:
13019 
   - success
13020 
   - cex
13021 
  """
13022 
 
13023 
  thrift_spec = (
13024 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13025 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13026 
  )
13027 
 
13028 
  def __init__(self, success=None, cex=None,):
13029 
    self.success = success
13030 
    self.cex = cex
13031 
 
13032 
  def read(self, iprot):
13033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13035 
      return
13036 
    iprot.readStructBegin()
13037 
    while True:
13038 
      (fname, ftype, fid) = iprot.readFieldBegin()
13039 
      if ftype == TType.STOP:
13040 
        break
13041 
      if fid == 0:
13042 
        if ftype == TType.STRUCT:
13043 
          self.success = SourceItemPricing()
13044 
          self.success.read(iprot)
13045 
        else:
13046 
          iprot.skip(ftype)
13047 
      elif fid == 1:
13048 
        if ftype == TType.STRUCT:
13049 
          self.cex = CatalogServiceException()
13050 
          self.cex.read(iprot)
13051 
        else:
13052 
          iprot.skip(ftype)
13053 
      else:
13054 
        iprot.skip(ftype)
13055 
      iprot.readFieldEnd()
13056 
    iprot.readStructEnd()
13057 
 
13058 
  def write(self, oprot):
13059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13061 
      return
13062 
    oprot.writeStructBegin('getItemPricingBySource_result')
13063 
    if self.success is not None:
13064 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13065 
      self.success.write(oprot)
13066 
      oprot.writeFieldEnd()
13067 
    if self.cex is not None:
13068 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13069 
      self.cex.write(oprot)
13070 
      oprot.writeFieldEnd()
13071 
    oprot.writeFieldStop()
13072 
    oprot.writeStructEnd()
13073 
 
13074 
  def validate(self):
13075 
    return
13076 
 
13077 
 
13078 
  def __repr__(self):
13079 
    L = ['%s=%r' % (key, value)
13080 
      for key, value in self.__dict__.iteritems()]
13081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13082 
 
13083 
  def __eq__(self, other):
13084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13085 
 
13086 
  def __ne__(self, other):
13087 
    return not (self == other)
13088 
 
13089 
class addSourceItemPricing_args:
13090 
  """
13091 
  Attributes:
13092 
   - sourceItemPricing
13093 
  """
13094 
 
13095 
  thrift_spec = (
13096 
    None, # 0
13097 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13098 
  )
13099 
 
13100 
  def __init__(self, sourceItemPricing=None,):
13101 
    self.sourceItemPricing = sourceItemPricing
13102 
 
13103 
  def read(self, iprot):
13104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13106 
      return
13107 
    iprot.readStructBegin()
13108 
    while True:
13109 
      (fname, ftype, fid) = iprot.readFieldBegin()
13110 
      if ftype == TType.STOP:
13111 
        break
13112 
      if fid == 1:
13113 
        if ftype == TType.STRUCT:
13114 
          self.sourceItemPricing = SourceItemPricing()
13115 
          self.sourceItemPricing.read(iprot)
13116 
        else:
13117 
          iprot.skip(ftype)
13118 
      else:
13119 
        iprot.skip(ftype)
13120 
      iprot.readFieldEnd()
13121 
    iprot.readStructEnd()
13122 
 
13123 
  def write(self, oprot):
13124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13126 
      return
13127 
    oprot.writeStructBegin('addSourceItemPricing_args')
13128 
    if self.sourceItemPricing is not None:
13129 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13130 
      self.sourceItemPricing.write(oprot)
13131 
      oprot.writeFieldEnd()
13132 
    oprot.writeFieldStop()
13133 
    oprot.writeStructEnd()
13134 
 
13135 
  def validate(self):
13136 
    return
13137 
 
13138 
 
13139 
  def __repr__(self):
13140 
    L = ['%s=%r' % (key, value)
13141 
      for key, value in self.__dict__.iteritems()]
13142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13143 
 
13144 
  def __eq__(self, other):
13145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13146 
 
13147 
  def __ne__(self, other):
13148 
    return not (self == other)
13149 
 
13150 
class addSourceItemPricing_result:
13151 
  """
13152 
  Attributes:
13153 
   - cex
13154 
  """
13155 
 
13156 
  thrift_spec = (
13157 
    None, # 0
13158 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13159 
  )
13160 
 
13161 
  def __init__(self, cex=None,):
13162 
    self.cex = cex
13163 
 
13164 
  def read(self, iprot):
13165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13167 
      return
13168 
    iprot.readStructBegin()
13169 
    while True:
13170 
      (fname, ftype, fid) = iprot.readFieldBegin()
13171 
      if ftype == TType.STOP:
13172 
        break
13173 
      if fid == 1:
13174 
        if ftype == TType.STRUCT:
13175 
          self.cex = CatalogServiceException()
13176 
          self.cex.read(iprot)
13177 
        else:
13178 
          iprot.skip(ftype)
13179 
      else:
13180 
        iprot.skip(ftype)
13181 
      iprot.readFieldEnd()
13182 
    iprot.readStructEnd()
13183 
 
13184 
  def write(self, oprot):
13185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13187 
      return
13188 
    oprot.writeStructBegin('addSourceItemPricing_result')
13189 
    if self.cex is not None:
13190 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13191 
      self.cex.write(oprot)
13192 
      oprot.writeFieldEnd()
13193 
    oprot.writeFieldStop()
13194 
    oprot.writeStructEnd()
13195 
 
13196 
  def validate(self):
13197 
    return
13198 
 
13199 
 
13200 
  def __repr__(self):
13201 
    L = ['%s=%r' % (key, value)
13202 
      for key, value in self.__dict__.iteritems()]
13203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13204 
 
13205 
  def __eq__(self, other):
13206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13207 
 
13208 
  def __ne__(self, other):
13209 
    return not (self == other)
13210 
 
13211 
class getAllSourcePricing_args:
13212 
  """
13213 
  Attributes:
13214 
   - itemId
13215 
  """
13216 
 
13217 
  thrift_spec = (
13218 
    None, # 0
13219 
    (1, TType.I64, 'itemId', None, None, ), # 1
13220 
  )
13221 
 
13222 
  def __init__(self, itemId=None,):
13223 
    self.itemId = itemId
13224 
 
13225 
  def read(self, iprot):
13226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13228 
      return
13229 
    iprot.readStructBegin()
13230 
    while True:
13231 
      (fname, ftype, fid) = iprot.readFieldBegin()
13232 
      if ftype == TType.STOP:
13233 
        break
13234 
      if fid == 1:
13235 
        if ftype == TType.I64:
13236 
          self.itemId = iprot.readI64();
13237 
        else:
13238 
          iprot.skip(ftype)
13239 
      else:
13240 
        iprot.skip(ftype)
13241 
      iprot.readFieldEnd()
13242 
    iprot.readStructEnd()
13243 
 
13244 
  def write(self, oprot):
13245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13247 
      return
13248 
    oprot.writeStructBegin('getAllSourcePricing_args')
13249 
    if self.itemId is not None:
13250 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13251 
      oprot.writeI64(self.itemId)
13252 
      oprot.writeFieldEnd()
13253 
    oprot.writeFieldStop()
13254 
    oprot.writeStructEnd()
13255 
 
13256 
  def validate(self):
13257 
    return
13258 
 
13259 
 
13260 
  def __repr__(self):
13261 
    L = ['%s=%r' % (key, value)
13262 
      for key, value in self.__dict__.iteritems()]
13263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13264 
 
13265 
  def __eq__(self, other):
13266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13267 
 
13268 
  def __ne__(self, other):
13269 
    return not (self == other)
13270 
 
13271 
class getAllSourcePricing_result:
13272 
  """
13273 
  Attributes:
13274 
   - success
13275 
   - cex
13276 
  """
13277 
 
13278 
  thrift_spec = (
13279 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13280 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13281 
  )
13282 
 
13283 
  def __init__(self, success=None, cex=None,):
13284 
    self.success = success
13285 
    self.cex = cex
13286 
 
13287 
  def read(self, iprot):
13288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13290 
      return
13291 
    iprot.readStructBegin()
13292 
    while True:
13293 
      (fname, ftype, fid) = iprot.readFieldBegin()
13294 
      if ftype == TType.STOP:
13295 
        break
13296 
      if fid == 0:
13297 
        if ftype == TType.LIST:
13298 
          self.success = []
6850 kshitij.so 13299 
          (_etype231, _size228) = iprot.readListBegin()
13300 
          for _i232 in xrange(_size228):
13301 
            _elem233 = SourceItemPricing()
13302 
            _elem233.read(iprot)
13303 
            self.success.append(_elem233)
5944 mandeep.dh 13304 
          iprot.readListEnd()
13305 
        else:
13306 
          iprot.skip(ftype)
13307 
      elif fid == 1:
13308 
        if ftype == TType.STRUCT:
13309 
          self.cex = CatalogServiceException()
13310 
          self.cex.read(iprot)
13311 
        else:
13312 
          iprot.skip(ftype)
13313 
      else:
13314 
        iprot.skip(ftype)
13315 
      iprot.readFieldEnd()
13316 
    iprot.readStructEnd()
13317 
 
13318 
  def write(self, oprot):
13319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13321 
      return
13322 
    oprot.writeStructBegin('getAllSourcePricing_result')
13323 
    if self.success is not None:
13324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13325 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13326 
      for iter234 in self.success:
13327 
        iter234.write(oprot)
5944 mandeep.dh 13328 
      oprot.writeListEnd()
13329 
      oprot.writeFieldEnd()
13330 
    if self.cex is not None:
13331 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13332 
      self.cex.write(oprot)
13333 
      oprot.writeFieldEnd()
13334 
    oprot.writeFieldStop()
13335 
    oprot.writeStructEnd()
13336 
 
13337 
  def validate(self):
13338 
    return
13339 
 
13340 
 
13341 
  def __repr__(self):
13342 
    L = ['%s=%r' % (key, value)
13343 
      for key, value in self.__dict__.iteritems()]
13344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13345 
 
13346 
  def __eq__(self, other):
13347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13348 
 
13349 
  def __ne__(self, other):
13350 
    return not (self == other)
13351 
 
13352 
class getItemForSource_args:
13353 
  """
13354 
  Attributes:
13355 
   - item_id
13356 
   - sourceId
13357 
  """
13358 
 
13359 
  thrift_spec = (
13360 
    None, # 0
13361 
    (1, TType.I64, 'item_id', None, None, ), # 1
13362 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13363 
  )
13364 
 
13365 
  def __init__(self, item_id=None, sourceId=None,):
13366 
    self.item_id = item_id
13367 
    self.sourceId = sourceId
13368 
 
13369 
  def read(self, iprot):
13370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13372 
      return
13373 
    iprot.readStructBegin()
13374 
    while True:
13375 
      (fname, ftype, fid) = iprot.readFieldBegin()
13376 
      if ftype == TType.STOP:
13377 
        break
13378 
      if fid == 1:
13379 
        if ftype == TType.I64:
13380 
          self.item_id = iprot.readI64();
13381 
        else:
13382 
          iprot.skip(ftype)
13383 
      elif fid == 2:
13384 
        if ftype == TType.I64:
13385 
          self.sourceId = iprot.readI64();
13386 
        else:
13387 
          iprot.skip(ftype)
13388 
      else:
13389 
        iprot.skip(ftype)
13390 
      iprot.readFieldEnd()
13391 
    iprot.readStructEnd()
13392 
 
13393 
  def write(self, oprot):
13394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13396 
      return
13397 
    oprot.writeStructBegin('getItemForSource_args')
13398 
    if self.item_id is not None:
13399 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13400 
      oprot.writeI64(self.item_id)
13401 
      oprot.writeFieldEnd()
13402 
    if self.sourceId is not None:
13403 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13404 
      oprot.writeI64(self.sourceId)
13405 
      oprot.writeFieldEnd()
13406 
    oprot.writeFieldStop()
13407 
    oprot.writeStructEnd()
13408 
 
13409 
  def validate(self):
13410 
    return
13411 
 
13412 
 
13413 
  def __repr__(self):
13414 
    L = ['%s=%r' % (key, value)
13415 
      for key, value in self.__dict__.iteritems()]
13416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13417 
 
13418 
  def __eq__(self, other):
13419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13420 
 
13421 
  def __ne__(self, other):
13422 
    return not (self == other)
13423 
 
13424 
class getItemForSource_result:
13425 
  """
13426 
  Attributes:
13427 
   - success
13428 
   - cex
13429 
  """
13430 
 
13431 
  thrift_spec = (
13432 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13433 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13434 
  )
13435 
 
13436 
  def __init__(self, success=None, cex=None,):
13437 
    self.success = success
13438 
    self.cex = cex
13439 
 
13440 
  def read(self, iprot):
13441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13443 
      return
13444 
    iprot.readStructBegin()
13445 
    while True:
13446 
      (fname, ftype, fid) = iprot.readFieldBegin()
13447 
      if ftype == TType.STOP:
13448 
        break
13449 
      if fid == 0:
13450 
        if ftype == TType.STRUCT:
13451 
          self.success = Item()
13452 
          self.success.read(iprot)
13453 
        else:
13454 
          iprot.skip(ftype)
13455 
      elif fid == 1:
13456 
        if ftype == TType.STRUCT:
13457 
          self.cex = CatalogServiceException()
13458 
          self.cex.read(iprot)
13459 
        else:
13460 
          iprot.skip(ftype)
13461 
      else:
13462 
        iprot.skip(ftype)
13463 
      iprot.readFieldEnd()
13464 
    iprot.readStructEnd()
13465 
 
13466 
  def write(self, oprot):
13467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13469 
      return
13470 
    oprot.writeStructBegin('getItemForSource_result')
13471 
    if self.success is not None:
13472 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13473 
      self.success.write(oprot)
13474 
      oprot.writeFieldEnd()
13475 
    if self.cex is not None:
13476 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13477 
      self.cex.write(oprot)
13478 
      oprot.writeFieldEnd()
13479 
    oprot.writeFieldStop()
13480 
    oprot.writeStructEnd()
13481 
 
13482 
  def validate(self):
13483 
    return
13484 
 
13485 
 
13486 
  def __repr__(self):
13487 
    L = ['%s=%r' % (key, value)
13488 
      for key, value in self.__dict__.iteritems()]
13489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13490 
 
13491 
  def __eq__(self, other):
13492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13493 
 
13494 
  def __ne__(self, other):
13495 
    return not (self == other)
13496 
 
13497 
class searchItemsInRange_args:
13498 
  """
13499 
  Attributes:
13500 
   - searchTerms
13501 
   - offset
13502 
   - limit
13503 
  """
13504 
 
13505 
  thrift_spec = (
13506 
    None, # 0
13507 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13508 
    (2, TType.I64, 'offset', None, None, ), # 2
13509 
    (3, TType.I64, 'limit', None, None, ), # 3
13510 
  )
13511 
 
13512 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13513 
    self.searchTerms = searchTerms
13514 
    self.offset = offset
13515 
    self.limit = limit
13516 
 
13517 
  def read(self, iprot):
13518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13520 
      return
13521 
    iprot.readStructBegin()
13522 
    while True:
13523 
      (fname, ftype, fid) = iprot.readFieldBegin()
13524 
      if ftype == TType.STOP:
13525 
        break
13526 
      if fid == 1:
13527 
        if ftype == TType.LIST:
13528 
          self.searchTerms = []
6850 kshitij.so 13529 
          (_etype238, _size235) = iprot.readListBegin()
13530 
          for _i239 in xrange(_size235):
13531 
            _elem240 = iprot.readString();
13532 
            self.searchTerms.append(_elem240)
5944 mandeep.dh 13533 
          iprot.readListEnd()
13534 
        else:
13535 
          iprot.skip(ftype)
13536 
      elif fid == 2:
13537 
        if ftype == TType.I64:
13538 
          self.offset = iprot.readI64();
13539 
        else:
13540 
          iprot.skip(ftype)
13541 
      elif fid == 3:
13542 
        if ftype == TType.I64:
13543 
          self.limit = iprot.readI64();
13544 
        else:
13545 
          iprot.skip(ftype)
13546 
      else:
13547 
        iprot.skip(ftype)
13548 
      iprot.readFieldEnd()
13549 
    iprot.readStructEnd()
13550 
 
13551 
  def write(self, oprot):
13552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13554 
      return
13555 
    oprot.writeStructBegin('searchItemsInRange_args')
13556 
    if self.searchTerms is not None:
13557 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13558 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13559 
      for iter241 in self.searchTerms:
13560 
        oprot.writeString(iter241)
5944 mandeep.dh 13561 
      oprot.writeListEnd()
13562 
      oprot.writeFieldEnd()
13563 
    if self.offset is not None:
13564 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13565 
      oprot.writeI64(self.offset)
13566 
      oprot.writeFieldEnd()
13567 
    if self.limit is not None:
13568 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13569 
      oprot.writeI64(self.limit)
13570 
      oprot.writeFieldEnd()
13571 
    oprot.writeFieldStop()
13572 
    oprot.writeStructEnd()
13573 
 
13574 
  def validate(self):
13575 
    return
13576 
 
13577 
 
13578 
  def __repr__(self):
13579 
    L = ['%s=%r' % (key, value)
13580 
      for key, value in self.__dict__.iteritems()]
13581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13582 
 
13583 
  def __eq__(self, other):
13584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13585 
 
13586 
  def __ne__(self, other):
13587 
    return not (self == other)
13588 
 
13589 
class searchItemsInRange_result:
13590 
  """
13591 
  Attributes:
13592 
   - success
13593 
  """
13594 
 
13595 
  thrift_spec = (
13596 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13597 
  )
13598 
 
13599 
  def __init__(self, success=None,):
13600 
    self.success = success
13601 
 
13602 
  def read(self, iprot):
13603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13605 
      return
13606 
    iprot.readStructBegin()
13607 
    while True:
13608 
      (fname, ftype, fid) = iprot.readFieldBegin()
13609 
      if ftype == TType.STOP:
13610 
        break
13611 
      if fid == 0:
13612 
        if ftype == TType.LIST:
13613 
          self.success = []
6850 kshitij.so 13614 
          (_etype245, _size242) = iprot.readListBegin()
13615 
          for _i246 in xrange(_size242):
13616 
            _elem247 = Item()
13617 
            _elem247.read(iprot)
13618 
            self.success.append(_elem247)
5944 mandeep.dh 13619 
          iprot.readListEnd()
13620 
        else:
13621 
          iprot.skip(ftype)
13622 
      else:
13623 
        iprot.skip(ftype)
13624 
      iprot.readFieldEnd()
13625 
    iprot.readStructEnd()
13626 
 
13627 
  def write(self, oprot):
13628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13630 
      return
13631 
    oprot.writeStructBegin('searchItemsInRange_result')
13632 
    if self.success is not None:
13633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13635 
      for iter248 in self.success:
13636 
        iter248.write(oprot)
5944 mandeep.dh 13637 
      oprot.writeListEnd()
13638 
      oprot.writeFieldEnd()
13639 
    oprot.writeFieldStop()
13640 
    oprot.writeStructEnd()
13641 
 
13642 
  def validate(self):
13643 
    return
13644 
 
13645 
 
13646 
  def __repr__(self):
13647 
    L = ['%s=%r' % (key, value)
13648 
      for key, value in self.__dict__.iteritems()]
13649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13650 
 
13651 
  def __eq__(self, other):
13652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13653 
 
13654 
  def __ne__(self, other):
13655 
    return not (self == other)
13656 
 
13657 
class getSearchResultCount_args:
13658 
  """
13659 
  Attributes:
13660 
   - searchTerms
13661 
  """
13662 
 
13663 
  thrift_spec = (
13664 
    None, # 0
13665 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13666 
  )
13667 
 
13668 
  def __init__(self, searchTerms=None,):
13669 
    self.searchTerms = searchTerms
13670 
 
13671 
  def read(self, iprot):
13672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13674 
      return
13675 
    iprot.readStructBegin()
13676 
    while True:
13677 
      (fname, ftype, fid) = iprot.readFieldBegin()
13678 
      if ftype == TType.STOP:
13679 
        break
13680 
      if fid == 1:
13681 
        if ftype == TType.LIST:
13682 
          self.searchTerms = []
6850 kshitij.so 13683 
          (_etype252, _size249) = iprot.readListBegin()
13684 
          for _i253 in xrange(_size249):
13685 
            _elem254 = iprot.readString();
13686 
            self.searchTerms.append(_elem254)
5944 mandeep.dh 13687 
          iprot.readListEnd()
13688 
        else:
13689 
          iprot.skip(ftype)
13690 
      else:
13691 
        iprot.skip(ftype)
13692 
      iprot.readFieldEnd()
13693 
    iprot.readStructEnd()
13694 
 
13695 
  def write(self, oprot):
13696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13698 
      return
13699 
    oprot.writeStructBegin('getSearchResultCount_args')
13700 
    if self.searchTerms is not None:
13701 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13702 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13703 
      for iter255 in self.searchTerms:
13704 
        oprot.writeString(iter255)
5944 mandeep.dh 13705 
      oprot.writeListEnd()
13706 
      oprot.writeFieldEnd()
13707 
    oprot.writeFieldStop()
13708 
    oprot.writeStructEnd()
13709 
 
13710 
  def validate(self):
13711 
    return
13712 
 
13713 
 
13714 
  def __repr__(self):
13715 
    L = ['%s=%r' % (key, value)
13716 
      for key, value in self.__dict__.iteritems()]
13717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13718 
 
13719 
  def __eq__(self, other):
13720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13721 
 
13722 
  def __ne__(self, other):
13723 
    return not (self == other)
13724 
 
13725 
class getSearchResultCount_result:
13726 
  """
13727 
  Attributes:
13728 
   - success
13729 
  """
13730 
 
13731 
  thrift_spec = (
13732 
    (0, TType.I32, 'success', None, None, ), # 0
13733 
  )
13734 
 
13735 
  def __init__(self, success=None,):
13736 
    self.success = success
13737 
 
13738 
  def read(self, iprot):
13739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13741 
      return
13742 
    iprot.readStructBegin()
13743 
    while True:
13744 
      (fname, ftype, fid) = iprot.readFieldBegin()
13745 
      if ftype == TType.STOP:
13746 
        break
13747 
      if fid == 0:
13748 
        if ftype == TType.I32:
13749 
          self.success = iprot.readI32();
13750 
        else:
13751 
          iprot.skip(ftype)
13752 
      else:
13753 
        iprot.skip(ftype)
13754 
      iprot.readFieldEnd()
13755 
    iprot.readStructEnd()
13756 
 
13757 
  def write(self, oprot):
13758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13760 
      return
13761 
    oprot.writeStructBegin('getSearchResultCount_result')
13762 
    if self.success is not None:
13763 
      oprot.writeFieldBegin('success', TType.I32, 0)
13764 
      oprot.writeI32(self.success)
13765 
      oprot.writeFieldEnd()
13766 
    oprot.writeFieldStop()
13767 
    oprot.writeStructEnd()
13768 
 
13769 
  def validate(self):
13770 
    return
13771 
 
13772 
 
13773 
  def __repr__(self):
13774 
    L = ['%s=%r' % (key, value)
13775 
      for key, value in self.__dict__.iteritems()]
13776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13777 
 
13778 
  def __eq__(self, other):
13779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13780 
 
13781 
  def __ne__(self, other):
13782 
    return not (self == other)
13783 
 
13784 
class getProductNotifications_args:
13785 
  """
13786 
  Attributes:
13787 
   - startDateTime
13788 
  """
13789 
 
13790 
  thrift_spec = (
13791 
    None, # 0
13792 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13793 
  )
13794 
 
13795 
  def __init__(self, startDateTime=None,):
13796 
    self.startDateTime = startDateTime
13797 
 
13798 
  def read(self, iprot):
13799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13801 
      return
13802 
    iprot.readStructBegin()
13803 
    while True:
13804 
      (fname, ftype, fid) = iprot.readFieldBegin()
13805 
      if ftype == TType.STOP:
13806 
        break
13807 
      if fid == 1:
13808 
        if ftype == TType.I64:
13809 
          self.startDateTime = iprot.readI64();
13810 
        else:
13811 
          iprot.skip(ftype)
13812 
      else:
13813 
        iprot.skip(ftype)
13814 
      iprot.readFieldEnd()
13815 
    iprot.readStructEnd()
13816 
 
13817 
  def write(self, oprot):
13818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13820 
      return
13821 
    oprot.writeStructBegin('getProductNotifications_args')
13822 
    if self.startDateTime is not None:
13823 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13824 
      oprot.writeI64(self.startDateTime)
13825 
      oprot.writeFieldEnd()
13826 
    oprot.writeFieldStop()
13827 
    oprot.writeStructEnd()
13828 
 
13829 
  def validate(self):
13830 
    return
13831 
 
13832 
 
13833 
  def __repr__(self):
13834 
    L = ['%s=%r' % (key, value)
13835 
      for key, value in self.__dict__.iteritems()]
13836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13837 
 
13838 
  def __eq__(self, other):
13839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13840 
 
13841 
  def __ne__(self, other):
13842 
    return not (self == other)
13843 
 
13844 
class getProductNotifications_result:
13845 
  """
13846 
  Attributes:
13847 
   - success
13848 
  """
13849 
 
13850 
  thrift_spec = (
13851 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
13852 
  )
13853 
 
13854 
  def __init__(self, success=None,):
13855 
    self.success = success
13856 
 
13857 
  def read(self, iprot):
13858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13860 
      return
13861 
    iprot.readStructBegin()
13862 
    while True:
13863 
      (fname, ftype, fid) = iprot.readFieldBegin()
13864 
      if ftype == TType.STOP:
13865 
        break
13866 
      if fid == 0:
13867 
        if ftype == TType.LIST:
13868 
          self.success = []
6850 kshitij.so 13869 
          (_etype259, _size256) = iprot.readListBegin()
13870 
          for _i260 in xrange(_size256):
13871 
            _elem261 = ProductNotificationRequest()
13872 
            _elem261.read(iprot)
13873 
            self.success.append(_elem261)
5944 mandeep.dh 13874 
          iprot.readListEnd()
13875 
        else:
13876 
          iprot.skip(ftype)
13877 
      else:
13878 
        iprot.skip(ftype)
13879 
      iprot.readFieldEnd()
13880 
    iprot.readStructEnd()
13881 
 
13882 
  def write(self, oprot):
13883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13885 
      return
13886 
    oprot.writeStructBegin('getProductNotifications_result')
13887 
    if self.success is not None:
13888 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13889 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13890 
      for iter262 in self.success:
13891 
        iter262.write(oprot)
5944 mandeep.dh 13892 
      oprot.writeListEnd()
13893 
      oprot.writeFieldEnd()
13894 
    oprot.writeFieldStop()
13895 
    oprot.writeStructEnd()
13896 
 
13897 
  def validate(self):
13898 
    return
13899 
 
13900 
 
13901 
  def __repr__(self):
13902 
    L = ['%s=%r' % (key, value)
13903 
      for key, value in self.__dict__.iteritems()]
13904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13905 
 
13906 
  def __eq__(self, other):
13907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13908 
 
13909 
  def __ne__(self, other):
13910 
    return not (self == other)
13911 
 
13912 
class getProductNotificationRequestCount_args:
13913 
  """
13914 
  Attributes:
13915 
   - startDateTime
13916 
  """
13917 
 
13918 
  thrift_spec = (
13919 
    None, # 0
13920 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13921 
  )
13922 
 
13923 
  def __init__(self, startDateTime=None,):
13924 
    self.startDateTime = startDateTime
13925 
 
13926 
  def read(self, iprot):
13927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13929 
      return
13930 
    iprot.readStructBegin()
13931 
    while True:
13932 
      (fname, ftype, fid) = iprot.readFieldBegin()
13933 
      if ftype == TType.STOP:
13934 
        break
13935 
      if fid == 1:
13936 
        if ftype == TType.I64:
13937 
          self.startDateTime = iprot.readI64();
13938 
        else:
13939 
          iprot.skip(ftype)
13940 
      else:
13941 
        iprot.skip(ftype)
13942 
      iprot.readFieldEnd()
13943 
    iprot.readStructEnd()
13944 
 
13945 
  def write(self, oprot):
13946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13948 
      return
13949 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
13950 
    if self.startDateTime is not None:
13951 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13952 
      oprot.writeI64(self.startDateTime)
13953 
      oprot.writeFieldEnd()
13954 
    oprot.writeFieldStop()
13955 
    oprot.writeStructEnd()
13956 
 
13957 
  def validate(self):
13958 
    return
13959 
 
13960 
 
13961 
  def __repr__(self):
13962 
    L = ['%s=%r' % (key, value)
13963 
      for key, value in self.__dict__.iteritems()]
13964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13965 
 
13966 
  def __eq__(self, other):
13967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13968 
 
13969 
  def __ne__(self, other):
13970 
    return not (self == other)
13971 
 
13972 
class getProductNotificationRequestCount_result:
13973 
  """
13974 
  Attributes:
13975 
   - success
13976 
  """
13977 
 
13978 
  thrift_spec = (
13979 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
13980 
  )
13981 
 
13982 
  def __init__(self, success=None,):
13983 
    self.success = success
13984 
 
13985 
  def read(self, iprot):
13986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13988 
      return
13989 
    iprot.readStructBegin()
13990 
    while True:
13991 
      (fname, ftype, fid) = iprot.readFieldBegin()
13992 
      if ftype == TType.STOP:
13993 
        break
13994 
      if fid == 0:
13995 
        if ftype == TType.LIST:
13996 
          self.success = []
6850 kshitij.so 13997 
          (_etype266, _size263) = iprot.readListBegin()
13998 
          for _i267 in xrange(_size263):
13999 
            _elem268 = ProductNotificationRequestCount()
14000 
            _elem268.read(iprot)
14001 
            self.success.append(_elem268)
5944 mandeep.dh 14002 
          iprot.readListEnd()
14003 
        else:
14004 
          iprot.skip(ftype)
14005 
      else:
14006 
        iprot.skip(ftype)
14007 
      iprot.readFieldEnd()
14008 
    iprot.readStructEnd()
14009 
 
14010 
  def write(self, oprot):
14011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14013 
      return
14014 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14015 
    if self.success is not None:
14016 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14017 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 14018 
      for iter269 in self.success:
14019 
        iter269.write(oprot)
5944 mandeep.dh 14020 
      oprot.writeListEnd()
14021 
      oprot.writeFieldEnd()
14022 
    oprot.writeFieldStop()
14023 
    oprot.writeStructEnd()
14024 
 
14025 
  def validate(self):
14026 
    return
14027 
 
14028 
 
14029 
  def __repr__(self):
14030 
    L = ['%s=%r' % (key, value)
14031 
      for key, value in self.__dict__.iteritems()]
14032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14033 
 
14034 
  def __eq__(self, other):
14035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14036 
 
14037 
  def __ne__(self, other):
14038 
    return not (self == other)
14039 
 
14040 
class addAuthorizationLog_args:
14041 
  """
14042 
  Attributes:
14043 
   - itemId
14044 
   - username
14045 
   - reason
14046 
  """
14047 
 
14048 
  thrift_spec = (
14049 
    None, # 0
14050 
    (1, TType.I64, 'itemId', None, None, ), # 1
14051 
    (2, TType.STRING, 'username', None, None, ), # 2
14052 
    (3, TType.STRING, 'reason', None, None, ), # 3
14053 
  )
14054 
 
14055 
  def __init__(self, itemId=None, username=None, reason=None,):
14056 
    self.itemId = itemId
14057 
    self.username = username
14058 
    self.reason = reason
14059 
 
14060 
  def read(self, iprot):
14061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14063 
      return
14064 
    iprot.readStructBegin()
14065 
    while True:
14066 
      (fname, ftype, fid) = iprot.readFieldBegin()
14067 
      if ftype == TType.STOP:
14068 
        break
14069 
      if fid == 1:
14070 
        if ftype == TType.I64:
14071 
          self.itemId = iprot.readI64();
14072 
        else:
14073 
          iprot.skip(ftype)
14074 
      elif fid == 2:
14075 
        if ftype == TType.STRING:
14076 
          self.username = iprot.readString();
14077 
        else:
14078 
          iprot.skip(ftype)
14079 
      elif fid == 3:
14080 
        if ftype == TType.STRING:
14081 
          self.reason = iprot.readString();
14082 
        else:
14083 
          iprot.skip(ftype)
14084 
      else:
14085 
        iprot.skip(ftype)
14086 
      iprot.readFieldEnd()
14087 
    iprot.readStructEnd()
14088 
 
14089 
  def write(self, oprot):
14090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14092 
      return
14093 
    oprot.writeStructBegin('addAuthorizationLog_args')
14094 
    if self.itemId is not None:
14095 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14096 
      oprot.writeI64(self.itemId)
14097 
      oprot.writeFieldEnd()
14098 
    if self.username is not None:
14099 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14100 
      oprot.writeString(self.username)
14101 
      oprot.writeFieldEnd()
14102 
    if self.reason is not None:
14103 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14104 
      oprot.writeString(self.reason)
14105 
      oprot.writeFieldEnd()
14106 
    oprot.writeFieldStop()
14107 
    oprot.writeStructEnd()
14108 
 
14109 
  def validate(self):
14110 
    return
14111 
 
14112 
 
14113 
  def __repr__(self):
14114 
    L = ['%s=%r' % (key, value)
14115 
      for key, value in self.__dict__.iteritems()]
14116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14117 
 
14118 
  def __eq__(self, other):
14119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14120 
 
14121 
  def __ne__(self, other):
14122 
    return not (self == other)
14123 
 
14124 
class addAuthorizationLog_result:
14125 
  """
14126 
  Attributes:
14127 
   - success
14128 
   - cex
14129 
  """
14130 
 
14131 
  thrift_spec = (
14132 
    (0, TType.BOOL, 'success', None, None, ), # 0
14133 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14134 
  )
14135 
 
14136 
  def __init__(self, success=None, cex=None,):
14137 
    self.success = success
14138 
    self.cex = cex
14139 
 
14140 
  def read(self, iprot):
14141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14143 
      return
14144 
    iprot.readStructBegin()
14145 
    while True:
14146 
      (fname, ftype, fid) = iprot.readFieldBegin()
14147 
      if ftype == TType.STOP:
14148 
        break
14149 
      if fid == 0:
14150 
        if ftype == TType.BOOL:
14151 
          self.success = iprot.readBool();
14152 
        else:
14153 
          iprot.skip(ftype)
14154 
      elif fid == 1:
14155 
        if ftype == TType.STRUCT:
14156 
          self.cex = CatalogServiceException()
14157 
          self.cex.read(iprot)
14158 
        else:
14159 
          iprot.skip(ftype)
14160 
      else:
14161 
        iprot.skip(ftype)
14162 
      iprot.readFieldEnd()
14163 
    iprot.readStructEnd()
14164 
 
14165 
  def write(self, oprot):
14166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14168 
      return
14169 
    oprot.writeStructBegin('addAuthorizationLog_result')
14170 
    if self.success is not None:
14171 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14172 
      oprot.writeBool(self.success)
14173 
      oprot.writeFieldEnd()
14174 
    if self.cex is not None:
14175 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14176 
      self.cex.write(oprot)
14177 
      oprot.writeFieldEnd()
14178 
    oprot.writeFieldStop()
14179 
    oprot.writeStructEnd()
14180 
 
14181 
  def validate(self):
14182 
    return
14183 
 
14184 
 
14185 
  def __repr__(self):
14186 
    L = ['%s=%r' % (key, value)
14187 
      for key, value in self.__dict__.iteritems()]
14188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14189 
 
14190 
  def __eq__(self, other):
14191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14192 
 
14193 
  def __ne__(self, other):
14194 
    return not (self == other)
14195 
 
14196 
class addupdateVoucherForItem_args:
14197 
  """
14198 
  Attributes:
14199 
   - catalog_item_id
14200 
   - voucherType
14201 
   - voucherAmount
14202 
  """
14203 
 
14204 
  thrift_spec = (
14205 
    None, # 0
14206 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14207 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14208 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14209 
  )
14210 
 
14211 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14212 
    self.catalog_item_id = catalog_item_id
14213 
    self.voucherType = voucherType
14214 
    self.voucherAmount = voucherAmount
14215 
 
14216 
  def read(self, iprot):
14217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14219 
      return
14220 
    iprot.readStructBegin()
14221 
    while True:
14222 
      (fname, ftype, fid) = iprot.readFieldBegin()
14223 
      if ftype == TType.STOP:
14224 
        break
14225 
      if fid == 1:
14226 
        if ftype == TType.I64:
14227 
          self.catalog_item_id = iprot.readI64();
14228 
        else:
14229 
          iprot.skip(ftype)
14230 
      elif fid == 2:
14231 
        if ftype == TType.I64:
14232 
          self.voucherType = iprot.readI64();
14233 
        else:
14234 
          iprot.skip(ftype)
14235 
      elif fid == 3:
14236 
        if ftype == TType.I64:
14237 
          self.voucherAmount = iprot.readI64();
14238 
        else:
14239 
          iprot.skip(ftype)
14240 
      else:
14241 
        iprot.skip(ftype)
14242 
      iprot.readFieldEnd()
14243 
    iprot.readStructEnd()
14244 
 
14245 
  def write(self, oprot):
14246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14248 
      return
14249 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14250 
    if self.catalog_item_id is not None:
14251 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14252 
      oprot.writeI64(self.catalog_item_id)
14253 
      oprot.writeFieldEnd()
14254 
    if self.voucherType is not None:
14255 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14256 
      oprot.writeI64(self.voucherType)
14257 
      oprot.writeFieldEnd()
14258 
    if self.voucherAmount is not None:
14259 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14260 
      oprot.writeI64(self.voucherAmount)
14261 
      oprot.writeFieldEnd()
14262 
    oprot.writeFieldStop()
14263 
    oprot.writeStructEnd()
14264 
 
14265 
  def validate(self):
14266 
    return
14267 
 
14268 
 
14269 
  def __repr__(self):
14270 
    L = ['%s=%r' % (key, value)
14271 
      for key, value in self.__dict__.iteritems()]
14272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14273 
 
14274 
  def __eq__(self, other):
14275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14276 
 
14277 
  def __ne__(self, other):
14278 
    return not (self == other)
14279 
 
14280 
class addupdateVoucherForItem_result:
14281 
  """
14282 
  Attributes:
14283 
   - success
14284 
   - cex
14285 
  """
14286 
 
14287 
  thrift_spec = (
14288 
    (0, TType.BOOL, 'success', None, None, ), # 0
14289 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14290 
  )
14291 
 
14292 
  def __init__(self, success=None, cex=None,):
14293 
    self.success = success
14294 
    self.cex = cex
14295 
 
14296 
  def read(self, iprot):
14297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14299 
      return
14300 
    iprot.readStructBegin()
14301 
    while True:
14302 
      (fname, ftype, fid) = iprot.readFieldBegin()
14303 
      if ftype == TType.STOP:
14304 
        break
14305 
      if fid == 0:
14306 
        if ftype == TType.BOOL:
14307 
          self.success = iprot.readBool();
14308 
        else:
14309 
          iprot.skip(ftype)
14310 
      elif fid == 1:
14311 
        if ftype == TType.STRUCT:
14312 
          self.cex = CatalogServiceException()
14313 
          self.cex.read(iprot)
14314 
        else:
14315 
          iprot.skip(ftype)
14316 
      else:
14317 
        iprot.skip(ftype)
14318 
      iprot.readFieldEnd()
14319 
    iprot.readStructEnd()
14320 
 
14321 
  def write(self, oprot):
14322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14324 
      return
14325 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14326 
    if self.success is not None:
14327 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14328 
      oprot.writeBool(self.success)
14329 
      oprot.writeFieldEnd()
14330 
    if self.cex is not None:
14331 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14332 
      self.cex.write(oprot)
14333 
      oprot.writeFieldEnd()
14334 
    oprot.writeFieldStop()
14335 
    oprot.writeStructEnd()
14336 
 
14337 
  def validate(self):
14338 
    return
14339 
 
14340 
 
14341 
  def __repr__(self):
14342 
    L = ['%s=%r' % (key, value)
14343 
      for key, value in self.__dict__.iteritems()]
14344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14345 
 
14346 
  def __eq__(self, other):
14347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14348 
 
14349 
  def __ne__(self, other):
14350 
    return not (self == other)
14351 
 
14352 
class deleteVoucherForItem_args:
14353 
  """
14354 
  Attributes:
14355 
   - catalog_item_id
14356 
   - voucherType
14357 
  """
14358 
 
14359 
  thrift_spec = (
14360 
    None, # 0
14361 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14362 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14363 
  )
14364 
 
14365 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14366 
    self.catalog_item_id = catalog_item_id
14367 
    self.voucherType = voucherType
14368 
 
14369 
  def read(self, iprot):
14370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14372 
      return
14373 
    iprot.readStructBegin()
14374 
    while True:
14375 
      (fname, ftype, fid) = iprot.readFieldBegin()
14376 
      if ftype == TType.STOP:
14377 
        break
14378 
      if fid == 1:
14379 
        if ftype == TType.I64:
14380 
          self.catalog_item_id = iprot.readI64();
14381 
        else:
14382 
          iprot.skip(ftype)
14383 
      elif fid == 2:
14384 
        if ftype == TType.I64:
14385 
          self.voucherType = iprot.readI64();
14386 
        else:
14387 
          iprot.skip(ftype)
14388 
      else:
14389 
        iprot.skip(ftype)
14390 
      iprot.readFieldEnd()
14391 
    iprot.readStructEnd()
14392 
 
14393 
  def write(self, oprot):
14394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14396 
      return
14397 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14398 
    if self.catalog_item_id is not None:
14399 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14400 
      oprot.writeI64(self.catalog_item_id)
14401 
      oprot.writeFieldEnd()
14402 
    if self.voucherType is not None:
14403 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14404 
      oprot.writeI64(self.voucherType)
14405 
      oprot.writeFieldEnd()
14406 
    oprot.writeFieldStop()
14407 
    oprot.writeStructEnd()
14408 
 
14409 
  def validate(self):
14410 
    return
14411 
 
14412 
 
14413 
  def __repr__(self):
14414 
    L = ['%s=%r' % (key, value)
14415 
      for key, value in self.__dict__.iteritems()]
14416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14417 
 
14418 
  def __eq__(self, other):
14419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14420 
 
14421 
  def __ne__(self, other):
14422 
    return not (self == other)
14423 
 
14424 
class deleteVoucherForItem_result:
14425 
  """
14426 
  Attributes:
14427 
   - success
14428 
   - cex
14429 
  """
14430 
 
14431 
  thrift_spec = (
14432 
    (0, TType.BOOL, 'success', None, None, ), # 0
14433 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14434 
  )
14435 
 
14436 
  def __init__(self, success=None, cex=None,):
14437 
    self.success = success
14438 
    self.cex = cex
14439 
 
14440 
  def read(self, iprot):
14441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14443 
      return
14444 
    iprot.readStructBegin()
14445 
    while True:
14446 
      (fname, ftype, fid) = iprot.readFieldBegin()
14447 
      if ftype == TType.STOP:
14448 
        break
14449 
      if fid == 0:
14450 
        if ftype == TType.BOOL:
14451 
          self.success = iprot.readBool();
14452 
        else:
14453 
          iprot.skip(ftype)
14454 
      elif fid == 1:
14455 
        if ftype == TType.STRUCT:
14456 
          self.cex = CatalogServiceException()
14457 
          self.cex.read(iprot)
14458 
        else:
14459 
          iprot.skip(ftype)
14460 
      else:
14461 
        iprot.skip(ftype)
14462 
      iprot.readFieldEnd()
14463 
    iprot.readStructEnd()
14464 
 
14465 
  def write(self, oprot):
14466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14468 
      return
14469 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14470 
    if self.success is not None:
14471 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14472 
      oprot.writeBool(self.success)
14473 
      oprot.writeFieldEnd()
14474 
    if self.cex is not None:
14475 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14476 
      self.cex.write(oprot)
14477 
      oprot.writeFieldEnd()
14478 
    oprot.writeFieldStop()
14479 
    oprot.writeStructEnd()
14480 
 
14481 
  def validate(self):
14482 
    return
14483 
 
14484 
 
14485 
  def __repr__(self):
14486 
    L = ['%s=%r' % (key, value)
14487 
      for key, value in self.__dict__.iteritems()]
14488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14489 
 
14490 
  def __eq__(self, other):
14491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14492 
 
14493 
  def __ne__(self, other):
14494 
    return not (self == other)
14495 
 
14496 
class getVoucherAmount_args:
14497 
  """
14498 
  Attributes:
14499 
   - itemId
14500 
   - voucherType
14501 
  """
14502 
 
14503 
  thrift_spec = (
14504 
    None, # 0
14505 
    (1, TType.I64, 'itemId', None, None, ), # 1
14506 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14507 
  )
14508 
 
14509 
  def __init__(self, itemId=None, voucherType=None,):
14510 
    self.itemId = itemId
14511 
    self.voucherType = voucherType
14512 
 
14513 
  def read(self, iprot):
14514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14516 
      return
14517 
    iprot.readStructBegin()
14518 
    while True:
14519 
      (fname, ftype, fid) = iprot.readFieldBegin()
14520 
      if ftype == TType.STOP:
14521 
        break
14522 
      if fid == 1:
14523 
        if ftype == TType.I64:
14524 
          self.itemId = iprot.readI64();
14525 
        else:
14526 
          iprot.skip(ftype)
14527 
      elif fid == 2:
14528 
        if ftype == TType.I64:
14529 
          self.voucherType = iprot.readI64();
14530 
        else:
14531 
          iprot.skip(ftype)
14532 
      else:
14533 
        iprot.skip(ftype)
14534 
      iprot.readFieldEnd()
14535 
    iprot.readStructEnd()
14536 
 
14537 
  def write(self, oprot):
14538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14540 
      return
14541 
    oprot.writeStructBegin('getVoucherAmount_args')
14542 
    if self.itemId is not None:
14543 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14544 
      oprot.writeI64(self.itemId)
14545 
      oprot.writeFieldEnd()
14546 
    if self.voucherType is not None:
14547 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14548 
      oprot.writeI64(self.voucherType)
14549 
      oprot.writeFieldEnd()
14550 
    oprot.writeFieldStop()
14551 
    oprot.writeStructEnd()
14552 
 
14553 
  def validate(self):
14554 
    return
14555 
 
14556 
 
14557 
  def __repr__(self):
14558 
    L = ['%s=%r' % (key, value)
14559 
      for key, value in self.__dict__.iteritems()]
14560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14561 
 
14562 
  def __eq__(self, other):
14563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14564 
 
14565 
  def __ne__(self, other):
14566 
    return not (self == other)
14567 
 
14568 
class getVoucherAmount_result:
14569 
  """
14570 
  Attributes:
14571 
   - success
14572 
  """
14573 
 
14574 
  thrift_spec = (
14575 
    (0, TType.I64, 'success', None, None, ), # 0
14576 
  )
14577 
 
14578 
  def __init__(self, success=None,):
14579 
    self.success = success
14580 
 
14581 
  def read(self, iprot):
14582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14584 
      return
14585 
    iprot.readStructBegin()
14586 
    while True:
14587 
      (fname, ftype, fid) = iprot.readFieldBegin()
14588 
      if ftype == TType.STOP:
14589 
        break
14590 
      if fid == 0:
14591 
        if ftype == TType.I64:
14592 
          self.success = iprot.readI64();
14593 
        else:
14594 
          iprot.skip(ftype)
14595 
      else:
14596 
        iprot.skip(ftype)
14597 
      iprot.readFieldEnd()
14598 
    iprot.readStructEnd()
14599 
 
14600 
  def write(self, oprot):
14601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14603 
      return
14604 
    oprot.writeStructBegin('getVoucherAmount_result')
14605 
    if self.success is not None:
14606 
      oprot.writeFieldBegin('success', TType.I64, 0)
14607 
      oprot.writeI64(self.success)
14608 
      oprot.writeFieldEnd()
14609 
    oprot.writeFieldStop()
14610 
    oprot.writeStructEnd()
14611 
 
14612 
  def validate(self):
14613 
    return
14614 
 
14615 
 
14616 
  def __repr__(self):
14617 
    L = ['%s=%r' % (key, value)
14618 
      for key, value in self.__dict__.iteritems()]
14619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14620 
 
14621 
  def __eq__(self, other):
14622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14623 
 
14624 
  def __ne__(self, other):
14625 
    return not (self == other)
14626 
 
14627 
class getAllItemVouchers_args:
14628 
  """
14629 
  Attributes:
14630 
   - itemId
14631 
  """
14632 
 
14633 
  thrift_spec = (
14634 
    None, # 0
14635 
    (1, TType.I64, 'itemId', None, None, ), # 1
14636 
  )
14637 
 
14638 
  def __init__(self, itemId=None,):
14639 
    self.itemId = itemId
14640 
 
14641 
  def read(self, iprot):
14642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14644 
      return
14645 
    iprot.readStructBegin()
14646 
    while True:
14647 
      (fname, ftype, fid) = iprot.readFieldBegin()
14648 
      if ftype == TType.STOP:
14649 
        break
14650 
      if fid == 1:
14651 
        if ftype == TType.I64:
14652 
          self.itemId = iprot.readI64();
14653 
        else:
14654 
          iprot.skip(ftype)
14655 
      else:
14656 
        iprot.skip(ftype)
14657 
      iprot.readFieldEnd()
14658 
    iprot.readStructEnd()
14659 
 
14660 
  def write(self, oprot):
14661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14663 
      return
14664 
    oprot.writeStructBegin('getAllItemVouchers_args')
14665 
    if self.itemId is not None:
14666 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14667 
      oprot.writeI64(self.itemId)
14668 
      oprot.writeFieldEnd()
14669 
    oprot.writeFieldStop()
14670 
    oprot.writeStructEnd()
14671 
 
14672 
  def validate(self):
14673 
    return
14674 
 
14675 
 
14676 
  def __repr__(self):
14677 
    L = ['%s=%r' % (key, value)
14678 
      for key, value in self.__dict__.iteritems()]
14679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14680 
 
14681 
  def __eq__(self, other):
14682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14683 
 
14684 
  def __ne__(self, other):
14685 
    return not (self == other)
14686 
 
14687 
class getAllItemVouchers_result:
14688 
  """
14689 
  Attributes:
14690 
   - success
14691 
  """
14692 
 
14693 
  thrift_spec = (
14694 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14695 
  )
14696 
 
14697 
  def __init__(self, success=None,):
14698 
    self.success = success
14699 
 
14700 
  def read(self, iprot):
14701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14703 
      return
14704 
    iprot.readStructBegin()
14705 
    while True:
14706 
      (fname, ftype, fid) = iprot.readFieldBegin()
14707 
      if ftype == TType.STOP:
14708 
        break
14709 
      if fid == 0:
14710 
        if ftype == TType.LIST:
14711 
          self.success = []
7256 rajveer 14712 
          (_etype273, _size270) = iprot.readListBegin()
14713 
          for _i274 in xrange(_size270):
14714 
            _elem275 = VoucherItemMapping()
14715 
            _elem275.read(iprot)
14716 
            self.success.append(_elem275)
5944 mandeep.dh 14717 
          iprot.readListEnd()
14718 
        else:
14719 
          iprot.skip(ftype)
14720 
      else:
14721 
        iprot.skip(ftype)
14722 
      iprot.readFieldEnd()
14723 
    iprot.readStructEnd()
14724 
 
14725 
  def write(self, oprot):
14726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14728 
      return
14729 
    oprot.writeStructBegin('getAllItemVouchers_result')
14730 
    if self.success is not None:
14731 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14732 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 14733 
      for iter276 in self.success:
14734 
        iter276.write(oprot)
5944 mandeep.dh 14735 
      oprot.writeListEnd()
14736 
      oprot.writeFieldEnd()
14737 
    oprot.writeFieldStop()
14738 
    oprot.writeStructEnd()
14739 
 
14740 
  def validate(self):
14741 
    return
14742 
 
14743 
 
14744 
  def __repr__(self):
14745 
    L = ['%s=%r' % (key, value)
14746 
      for key, value in self.__dict__.iteritems()]
14747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14748 
 
14749 
  def __eq__(self, other):
14750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14751 
 
14752 
  def __ne__(self, other):
14753 
    return not (self == other)
14754 
 
14755 
class isValidCatalogItemId_args:
14756 
  """
14757 
  Attributes:
14758 
   - catalog_item_id
14759 
  """
14760 
 
14761 
  thrift_spec = (
14762 
    None, # 0
14763 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14764 
  )
14765 
 
14766 
  def __init__(self, catalog_item_id=None,):
14767 
    self.catalog_item_id = catalog_item_id
14768 
 
14769 
  def read(self, iprot):
14770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14772 
      return
14773 
    iprot.readStructBegin()
14774 
    while True:
14775 
      (fname, ftype, fid) = iprot.readFieldBegin()
14776 
      if ftype == TType.STOP:
14777 
        break
14778 
      if fid == 1:
14779 
        if ftype == TType.I64:
14780 
          self.catalog_item_id = iprot.readI64();
14781 
        else:
14782 
          iprot.skip(ftype)
14783 
      else:
14784 
        iprot.skip(ftype)
14785 
      iprot.readFieldEnd()
14786 
    iprot.readStructEnd()
14787 
 
14788 
  def write(self, oprot):
14789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14791 
      return
14792 
    oprot.writeStructBegin('isValidCatalogItemId_args')
14793 
    if self.catalog_item_id is not None:
14794 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14795 
      oprot.writeI64(self.catalog_item_id)
14796 
      oprot.writeFieldEnd()
14797 
    oprot.writeFieldStop()
14798 
    oprot.writeStructEnd()
14799 
 
14800 
  def validate(self):
14801 
    return
14802 
 
14803 
 
14804 
  def __repr__(self):
14805 
    L = ['%s=%r' % (key, value)
14806 
      for key, value in self.__dict__.iteritems()]
14807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14808 
 
14809 
  def __eq__(self, other):
14810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14811 
 
14812 
  def __ne__(self, other):
14813 
    return not (self == other)
14814 
 
14815 
class isValidCatalogItemId_result:
14816 
  """
14817 
  Attributes:
14818 
   - success
14819 
  """
14820 
 
14821 
  thrift_spec = (
14822 
    (0, TType.BOOL, 'success', None, None, ), # 0
14823 
  )
14824 
 
14825 
  def __init__(self, success=None,):
14826 
    self.success = success
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 
      else:
14843 
        iprot.skip(ftype)
14844 
      iprot.readFieldEnd()
14845 
    iprot.readStructEnd()
14846 
 
14847 
  def write(self, oprot):
14848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14850 
      return
14851 
    oprot.writeStructBegin('isValidCatalogItemId_result')
14852 
    if self.success is not None:
14853 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14854 
      oprot.writeBool(self.success)
14855 
      oprot.writeFieldEnd()
14856 
    oprot.writeFieldStop()
14857 
    oprot.writeStructEnd()
14858 
 
14859 
  def validate(self):
14860 
    return
14861 
 
14862 
 
14863 
  def __repr__(self):
14864 
    L = ['%s=%r' % (key, value)
14865 
      for key, value in self.__dict__.iteritems()]
14866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14867 
 
14868 
  def __eq__(self, other):
14869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14870 
 
14871 
  def __ne__(self, other):
14872 
    return not (self == other)
6039 amit.gupta 14873 
 
14874 
class getVatPercentageForItem_args:
14875 
  """
14876 
  Attributes:
14877 
   - itemId
14878 
   - price
14879 
  """
14880 
 
14881 
  thrift_spec = (
14882 
    None, # 0
14883 
    (1, TType.I64, 'itemId', None, None, ), # 1
14884 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
14885 
  )
14886 
 
14887 
  def __init__(self, itemId=None, price=None,):
14888 
    self.itemId = itemId
14889 
    self.price = price
14890 
 
14891 
  def read(self, iprot):
14892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14894 
      return
14895 
    iprot.readStructBegin()
14896 
    while True:
14897 
      (fname, ftype, fid) = iprot.readFieldBegin()
14898 
      if ftype == TType.STOP:
14899 
        break
14900 
      if fid == 1:
14901 
        if ftype == TType.I64:
14902 
          self.itemId = iprot.readI64();
14903 
        else:
14904 
          iprot.skip(ftype)
14905 
      elif fid == 2:
14906 
        if ftype == TType.DOUBLE:
14907 
          self.price = iprot.readDouble();
14908 
        else:
14909 
          iprot.skip(ftype)
14910 
      else:
14911 
        iprot.skip(ftype)
14912 
      iprot.readFieldEnd()
14913 
    iprot.readStructEnd()
14914 
 
14915 
  def write(self, oprot):
14916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14918 
      return
14919 
    oprot.writeStructBegin('getVatPercentageForItem_args')
14920 
    if self.itemId is not None:
14921 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14922 
      oprot.writeI64(self.itemId)
14923 
      oprot.writeFieldEnd()
14924 
    if self.price is not None:
14925 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
14926 
      oprot.writeDouble(self.price)
14927 
      oprot.writeFieldEnd()
14928 
    oprot.writeFieldStop()
14929 
    oprot.writeStructEnd()
14930 
 
14931 
  def validate(self):
14932 
    return
14933 
 
14934 
 
14935 
  def __repr__(self):
14936 
    L = ['%s=%r' % (key, value)
14937 
      for key, value in self.__dict__.iteritems()]
14938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14939 
 
14940 
  def __eq__(self, other):
14941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14942 
 
14943 
  def __ne__(self, other):
14944 
    return not (self == other)
14945 
 
14946 
class getVatPercentageForItem_result:
14947 
  """
14948 
  Attributes:
14949 
   - success
14950 
  """
14951 
 
14952 
  thrift_spec = (
14953 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14954 
  )
14955 
 
14956 
  def __init__(self, success=None,):
14957 
    self.success = success
14958 
 
14959 
  def read(self, iprot):
14960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14962 
      return
14963 
    iprot.readStructBegin()
14964 
    while True:
14965 
      (fname, ftype, fid) = iprot.readFieldBegin()
14966 
      if ftype == TType.STOP:
14967 
        break
14968 
      if fid == 0:
14969 
        if ftype == TType.DOUBLE:
14970 
          self.success = iprot.readDouble();
14971 
        else:
14972 
          iprot.skip(ftype)
14973 
      else:
14974 
        iprot.skip(ftype)
14975 
      iprot.readFieldEnd()
14976 
    iprot.readStructEnd()
14977 
 
14978 
  def write(self, oprot):
14979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14981 
      return
14982 
    oprot.writeStructBegin('getVatPercentageForItem_result')
14983 
    if self.success is not None:
14984 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14985 
      oprot.writeDouble(self.success)
14986 
      oprot.writeFieldEnd()
14987 
    oprot.writeFieldStop()
14988 
    oprot.writeStructEnd()
14989 
 
14990 
  def validate(self):
14991 
    return
14992 
 
14993 
 
14994 
  def __repr__(self):
14995 
    L = ['%s=%r' % (key, value)
14996 
      for key, value in self.__dict__.iteritems()]
14997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14998 
 
14999 
  def __eq__(self, other):
15000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15001 
 
15002 
  def __ne__(self, other):
15003 
    return not (self == other)
15004 
 
15005 
class getVatAmountForItem_args:
15006 
  """
15007 
  Attributes:
15008 
   - itemId
15009 
   - price
15010 
  """
15011 
 
15012 
  thrift_spec = (
15013 
    None, # 0
15014 
    (1, TType.I64, 'itemId', None, None, ), # 1
15015 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15016 
  )
15017 
 
15018 
  def __init__(self, itemId=None, price=None,):
15019 
    self.itemId = itemId
15020 
    self.price = price
15021 
 
15022 
  def read(self, iprot):
15023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15025 
      return
15026 
    iprot.readStructBegin()
15027 
    while True:
15028 
      (fname, ftype, fid) = iprot.readFieldBegin()
15029 
      if ftype == TType.STOP:
15030 
        break
15031 
      if fid == 1:
15032 
        if ftype == TType.I64:
15033 
          self.itemId = iprot.readI64();
15034 
        else:
15035 
          iprot.skip(ftype)
15036 
      elif fid == 2:
15037 
        if ftype == TType.DOUBLE:
15038 
          self.price = iprot.readDouble();
15039 
        else:
15040 
          iprot.skip(ftype)
15041 
      else:
15042 
        iprot.skip(ftype)
15043 
      iprot.readFieldEnd()
15044 
    iprot.readStructEnd()
15045 
 
15046 
  def write(self, oprot):
15047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15049 
      return
15050 
    oprot.writeStructBegin('getVatAmountForItem_args')
15051 
    if self.itemId is not None:
15052 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15053 
      oprot.writeI64(self.itemId)
15054 
      oprot.writeFieldEnd()
15055 
    if self.price is not None:
15056 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15057 
      oprot.writeDouble(self.price)
15058 
      oprot.writeFieldEnd()
15059 
    oprot.writeFieldStop()
15060 
    oprot.writeStructEnd()
15061 
 
15062 
  def validate(self):
15063 
    return
15064 
 
15065 
 
15066 
  def __repr__(self):
15067 
    L = ['%s=%r' % (key, value)
15068 
      for key, value in self.__dict__.iteritems()]
15069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15070 
 
15071 
  def __eq__(self, other):
15072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15073 
 
15074 
  def __ne__(self, other):
15075 
    return not (self == other)
15076 
 
15077 
class getVatAmountForItem_result:
15078 
  """
15079 
  Attributes:
15080 
   - success
15081 
  """
15082 
 
15083 
  thrift_spec = (
15084 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15085 
  )
15086 
 
15087 
  def __init__(self, success=None,):
15088 
    self.success = success
15089 
 
15090 
  def read(self, iprot):
15091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15093 
      return
15094 
    iprot.readStructBegin()
15095 
    while True:
15096 
      (fname, ftype, fid) = iprot.readFieldBegin()
15097 
      if ftype == TType.STOP:
15098 
        break
15099 
      if fid == 0:
15100 
        if ftype == TType.DOUBLE:
15101 
          self.success = iprot.readDouble();
15102 
        else:
15103 
          iprot.skip(ftype)
15104 
      else:
15105 
        iprot.skip(ftype)
15106 
      iprot.readFieldEnd()
15107 
    iprot.readStructEnd()
15108 
 
15109 
  def write(self, oprot):
15110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15112 
      return
15113 
    oprot.writeStructBegin('getVatAmountForItem_result')
15114 
    if self.success is not None:
15115 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15116 
      oprot.writeDouble(self.success)
15117 
      oprot.writeFieldEnd()
15118 
    oprot.writeFieldStop()
15119 
    oprot.writeStructEnd()
15120 
 
15121 
  def validate(self):
15122 
    return
15123 
 
15124 
 
15125 
  def __repr__(self):
15126 
    L = ['%s=%r' % (key, value)
15127 
      for key, value in self.__dict__.iteritems()]
15128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15129 
 
15130 
  def __eq__(self, other):
15131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15132 
 
15133 
  def __ne__(self, other):
15134 
    return not (self == other)
6531 vikram.rag 15135 
 
15136 
class getAllIgnoredInventoryUpdateItemsList_args:
15137 
  """
15138 
  Attributes:
15139 
   - offset
15140 
   - limit
15141 
  """
15142 
 
15143 
  thrift_spec = (
15144 
    None, # 0
15145 
    (1, TType.I32, 'offset', None, None, ), # 1
15146 
    (2, TType.I32, 'limit', None, None, ), # 2
15147 
  )
15148 
 
15149 
  def __init__(self, offset=None, limit=None,):
15150 
    self.offset = offset
15151 
    self.limit = limit
15152 
 
15153 
  def read(self, iprot):
15154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15156 
      return
15157 
    iprot.readStructBegin()
15158 
    while True:
15159 
      (fname, ftype, fid) = iprot.readFieldBegin()
15160 
      if ftype == TType.STOP:
15161 
        break
15162 
      if fid == 1:
15163 
        if ftype == TType.I32:
15164 
          self.offset = iprot.readI32();
15165 
        else:
15166 
          iprot.skip(ftype)
15167 
      elif fid == 2:
15168 
        if ftype == TType.I32:
15169 
          self.limit = iprot.readI32();
15170 
        else:
15171 
          iprot.skip(ftype)
15172 
      else:
15173 
        iprot.skip(ftype)
15174 
      iprot.readFieldEnd()
15175 
    iprot.readStructEnd()
15176 
 
15177 
  def write(self, oprot):
15178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15180 
      return
15181 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15182 
    if self.offset is not None:
15183 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15184 
      oprot.writeI32(self.offset)
15185 
      oprot.writeFieldEnd()
15186 
    if self.limit is not None:
15187 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15188 
      oprot.writeI32(self.limit)
15189 
      oprot.writeFieldEnd()
15190 
    oprot.writeFieldStop()
15191 
    oprot.writeStructEnd()
15192 
 
15193 
  def validate(self):
15194 
    return
15195 
 
15196 
 
15197 
  def __repr__(self):
15198 
    L = ['%s=%r' % (key, value)
15199 
      for key, value in self.__dict__.iteritems()]
15200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15201 
 
15202 
  def __eq__(self, other):
15203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15204 
 
15205 
  def __ne__(self, other):
15206 
    return not (self == other)
15207 
 
15208 
class getAllIgnoredInventoryUpdateItemsList_result:
15209 
  """
15210 
  Attributes:
15211 
   - success
15212 
  """
15213 
 
15214 
  thrift_spec = (
15215 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15216 
  )
15217 
 
15218 
  def __init__(self, success=None,):
15219 
    self.success = success
15220 
 
15221 
  def read(self, iprot):
15222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15224 
      return
15225 
    iprot.readStructBegin()
15226 
    while True:
15227 
      (fname, ftype, fid) = iprot.readFieldBegin()
15228 
      if ftype == TType.STOP:
15229 
        break
15230 
      if fid == 0:
15231 
        if ftype == TType.LIST:
15232 
          self.success = []
7256 rajveer 15233 
          (_etype280, _size277) = iprot.readListBegin()
15234 
          for _i281 in xrange(_size277):
15235 
            _elem282 = Item()
15236 
            _elem282.read(iprot)
15237 
            self.success.append(_elem282)
6531 vikram.rag 15238 
          iprot.readListEnd()
15239 
        else:
15240 
          iprot.skip(ftype)
15241 
      else:
15242 
        iprot.skip(ftype)
15243 
      iprot.readFieldEnd()
15244 
    iprot.readStructEnd()
15245 
 
15246 
  def write(self, oprot):
15247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15249 
      return
15250 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15251 
    if self.success is not None:
15252 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15253 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15254 
      for iter283 in self.success:
15255 
        iter283.write(oprot)
6531 vikram.rag 15256 
      oprot.writeListEnd()
15257 
      oprot.writeFieldEnd()
15258 
    oprot.writeFieldStop()
15259 
    oprot.writeStructEnd()
15260 
 
15261 
  def validate(self):
15262 
    return
15263 
 
15264 
 
15265 
  def __repr__(self):
15266 
    L = ['%s=%r' % (key, value)
15267 
      for key, value in self.__dict__.iteritems()]
15268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15269 
 
15270 
  def __eq__(self, other):
15271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15272 
 
15273 
  def __ne__(self, other):
15274 
    return not (self == other)
6805 anupam.sin 15275 
 
6821 amar.kumar 15276 
class getAllAliveItems_args:
15277 
 
15278 
  thrift_spec = (
15279 
  )
15280 
 
15281 
  def read(self, iprot):
15282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15284 
      return
15285 
    iprot.readStructBegin()
15286 
    while True:
15287 
      (fname, ftype, fid) = iprot.readFieldBegin()
15288 
      if ftype == TType.STOP:
15289 
        break
15290 
      else:
15291 
        iprot.skip(ftype)
15292 
      iprot.readFieldEnd()
15293 
    iprot.readStructEnd()
15294 
 
15295 
  def write(self, oprot):
15296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15298 
      return
15299 
    oprot.writeStructBegin('getAllAliveItems_args')
15300 
    oprot.writeFieldStop()
15301 
    oprot.writeStructEnd()
15302 
 
15303 
  def validate(self):
15304 
    return
15305 
 
15306 
 
15307 
  def __repr__(self):
15308 
    L = ['%s=%r' % (key, value)
15309 
      for key, value in self.__dict__.iteritems()]
15310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15311 
 
15312 
  def __eq__(self, other):
15313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15314 
 
15315 
  def __ne__(self, other):
15316 
    return not (self == other)
15317 
 
15318 
class getAllAliveItems_result:
15319 
  """
15320 
  Attributes:
15321 
   - success
15322 
  """
15323 
 
15324 
  thrift_spec = (
15325 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15326 
  )
15327 
 
15328 
  def __init__(self, success=None,):
15329 
    self.success = success
15330 
 
15331 
  def read(self, iprot):
15332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15334 
      return
15335 
    iprot.readStructBegin()
15336 
    while True:
15337 
      (fname, ftype, fid) = iprot.readFieldBegin()
15338 
      if ftype == TType.STOP:
15339 
        break
15340 
      if fid == 0:
15341 
        if ftype == TType.LIST:
15342 
          self.success = []
7256 rajveer 15343 
          (_etype287, _size284) = iprot.readListBegin()
15344 
          for _i288 in xrange(_size284):
15345 
            _elem289 = Item()
15346 
            _elem289.read(iprot)
15347 
            self.success.append(_elem289)
6821 amar.kumar 15348 
          iprot.readListEnd()
15349 
        else:
15350 
          iprot.skip(ftype)
15351 
      else:
15352 
        iprot.skip(ftype)
15353 
      iprot.readFieldEnd()
15354 
    iprot.readStructEnd()
15355 
 
15356 
  def write(self, oprot):
15357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15359 
      return
15360 
    oprot.writeStructBegin('getAllAliveItems_result')
15361 
    if self.success is not None:
15362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15363 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15364 
      for iter290 in self.success:
15365 
        iter290.write(oprot)
6821 amar.kumar 15366 
      oprot.writeListEnd()
15367 
      oprot.writeFieldEnd()
15368 
    oprot.writeFieldStop()
15369 
    oprot.writeStructEnd()
15370 
 
15371 
  def validate(self):
15372 
    return
15373 
 
15374 
 
15375 
  def __repr__(self):
15376 
    L = ['%s=%r' % (key, value)
15377 
      for key, value in self.__dict__.iteritems()]
15378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15379 
 
15380 
  def __eq__(self, other):
15381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15382 
 
15383 
  def __ne__(self, other):
15384 
    return not (self == other)
15385 
 
6805 anupam.sin 15386 
class getInsuranceAmount_args:
15387 
  """
15388 
  Attributes:
15389 
   - itemId
6921 anupam.sin 15390 
   - price
6805 anupam.sin 15391 
   - insurerId
15392 
   - quantity
15393 
  """
15394 
 
15395 
  thrift_spec = (
15396 
    None, # 0
15397 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15398 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15399 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15400 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15401 
  )
15402 
 
6921 anupam.sin 15403 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15404 
    self.itemId = itemId
6921 anupam.sin 15405 
    self.price = price
6805 anupam.sin 15406 
    self.insurerId = insurerId
15407 
    self.quantity = quantity
15408 
 
15409 
  def read(self, iprot):
15410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15412 
      return
15413 
    iprot.readStructBegin()
15414 
    while True:
15415 
      (fname, ftype, fid) = iprot.readFieldBegin()
15416 
      if ftype == TType.STOP:
15417 
        break
15418 
      if fid == 1:
15419 
        if ftype == TType.I64:
15420 
          self.itemId = iprot.readI64();
15421 
        else:
15422 
          iprot.skip(ftype)
15423 
      elif fid == 2:
6921 anupam.sin 15424 
        if ftype == TType.DOUBLE:
15425 
          self.price = iprot.readDouble();
15426 
        else:
15427 
          iprot.skip(ftype)
15428 
      elif fid == 3:
6805 anupam.sin 15429 
        if ftype == TType.I64:
15430 
          self.insurerId = iprot.readI64();
15431 
        else:
15432 
          iprot.skip(ftype)
6921 anupam.sin 15433 
      elif fid == 4:
6805 anupam.sin 15434 
        if ftype == TType.I64:
15435 
          self.quantity = iprot.readI64();
15436 
        else:
15437 
          iprot.skip(ftype)
15438 
      else:
15439 
        iprot.skip(ftype)
15440 
      iprot.readFieldEnd()
15441 
    iprot.readStructEnd()
15442 
 
15443 
  def write(self, oprot):
15444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15446 
      return
15447 
    oprot.writeStructBegin('getInsuranceAmount_args')
15448 
    if self.itemId is not None:
15449 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15450 
      oprot.writeI64(self.itemId)
15451 
      oprot.writeFieldEnd()
6921 anupam.sin 15452 
    if self.price is not None:
15453 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15454 
      oprot.writeDouble(self.price)
15455 
      oprot.writeFieldEnd()
6805 anupam.sin 15456 
    if self.insurerId is not None:
6921 anupam.sin 15457 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15458 
      oprot.writeI64(self.insurerId)
15459 
      oprot.writeFieldEnd()
15460 
    if self.quantity is not None:
6921 anupam.sin 15461 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15462 
      oprot.writeI64(self.quantity)
15463 
      oprot.writeFieldEnd()
15464 
    oprot.writeFieldStop()
15465 
    oprot.writeStructEnd()
15466 
 
15467 
  def validate(self):
15468 
    return
15469 
 
15470 
 
15471 
  def __repr__(self):
15472 
    L = ['%s=%r' % (key, value)
15473 
      for key, value in self.__dict__.iteritems()]
15474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15475 
 
15476 
  def __eq__(self, other):
15477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15478 
 
15479 
  def __ne__(self, other):
15480 
    return not (self == other)
15481 
 
15482 
class getInsuranceAmount_result:
15483 
  """
15484 
  Attributes:
15485 
   - success
15486 
  """
15487 
 
15488 
  thrift_spec = (
15489 
    (0, TType.I64, 'success', None, None, ), # 0
15490 
  )
15491 
 
15492 
  def __init__(self, success=None,):
15493 
    self.success = success
15494 
 
15495 
  def read(self, iprot):
15496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15498 
      return
15499 
    iprot.readStructBegin()
15500 
    while True:
15501 
      (fname, ftype, fid) = iprot.readFieldBegin()
15502 
      if ftype == TType.STOP:
15503 
        break
15504 
      if fid == 0:
15505 
        if ftype == TType.I64:
15506 
          self.success = iprot.readI64();
15507 
        else:
15508 
          iprot.skip(ftype)
15509 
      else:
15510 
        iprot.skip(ftype)
15511 
      iprot.readFieldEnd()
15512 
    iprot.readStructEnd()
15513 
 
15514 
  def write(self, oprot):
15515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15517 
      return
15518 
    oprot.writeStructBegin('getInsuranceAmount_result')
15519 
    if self.success is not None:
15520 
      oprot.writeFieldBegin('success', TType.I64, 0)
15521 
      oprot.writeI64(self.success)
15522 
      oprot.writeFieldEnd()
15523 
    oprot.writeFieldStop()
15524 
    oprot.writeStructEnd()
15525 
 
15526 
  def validate(self):
15527 
    return
15528 
 
15529 
 
15530 
  def __repr__(self):
15531 
    L = ['%s=%r' % (key, value)
15532 
      for key, value in self.__dict__.iteritems()]
15533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15534 
 
15535 
  def __eq__(self, other):
15536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15537 
 
15538 
  def __ne__(self, other):
15539 
    return not (self == other)
15540 
 
15541 
class getInsurer_args:
15542 
  """
15543 
  Attributes:
15544 
   - insurerId
15545 
  """
15546 
 
15547 
  thrift_spec = (
15548 
    None, # 0
15549 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15550 
  )
15551 
 
15552 
  def __init__(self, insurerId=None,):
15553 
    self.insurerId = insurerId
15554 
 
15555 
  def read(self, iprot):
15556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15558 
      return
15559 
    iprot.readStructBegin()
15560 
    while True:
15561 
      (fname, ftype, fid) = iprot.readFieldBegin()
15562 
      if ftype == TType.STOP:
15563 
        break
15564 
      if fid == 1:
15565 
        if ftype == TType.I64:
15566 
          self.insurerId = iprot.readI64();
15567 
        else:
15568 
          iprot.skip(ftype)
15569 
      else:
15570 
        iprot.skip(ftype)
15571 
      iprot.readFieldEnd()
15572 
    iprot.readStructEnd()
15573 
 
15574 
  def write(self, oprot):
15575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15577 
      return
15578 
    oprot.writeStructBegin('getInsurer_args')
15579 
    if self.insurerId is not None:
15580 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15581 
      oprot.writeI64(self.insurerId)
15582 
      oprot.writeFieldEnd()
15583 
    oprot.writeFieldStop()
15584 
    oprot.writeStructEnd()
15585 
 
15586 
  def validate(self):
15587 
    return
15588 
 
15589 
 
15590 
  def __repr__(self):
15591 
    L = ['%s=%r' % (key, value)
15592 
      for key, value in self.__dict__.iteritems()]
15593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15594 
 
15595 
  def __eq__(self, other):
15596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15597 
 
15598 
  def __ne__(self, other):
15599 
    return not (self == other)
15600 
 
15601 
class getInsurer_result:
15602 
  """
15603 
  Attributes:
15604 
   - success
15605 
  """
15606 
 
15607 
  thrift_spec = (
15608 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15609 
  )
15610 
 
15611 
  def __init__(self, success=None,):
15612 
    self.success = success
15613 
 
15614 
  def read(self, iprot):
15615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15617 
      return
15618 
    iprot.readStructBegin()
15619 
    while True:
15620 
      (fname, ftype, fid) = iprot.readFieldBegin()
15621 
      if ftype == TType.STOP:
15622 
        break
15623 
      if fid == 0:
15624 
        if ftype == TType.STRUCT:
15625 
          self.success = Insurer()
15626 
          self.success.read(iprot)
15627 
        else:
15628 
          iprot.skip(ftype)
15629 
      else:
15630 
        iprot.skip(ftype)
15631 
      iprot.readFieldEnd()
15632 
    iprot.readStructEnd()
15633 
 
15634 
  def write(self, oprot):
15635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15637 
      return
15638 
    oprot.writeStructBegin('getInsurer_result')
15639 
    if self.success is not None:
15640 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15641 
      self.success.write(oprot)
15642 
      oprot.writeFieldEnd()
15643 
    oprot.writeFieldStop()
15644 
    oprot.writeStructEnd()
15645 
 
15646 
  def validate(self):
15647 
    return
15648 
 
15649 
 
15650 
  def __repr__(self):
15651 
    L = ['%s=%r' % (key, value)
15652 
      for key, value in self.__dict__.iteritems()]
15653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15654 
 
15655 
  def __eq__(self, other):
15656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15657 
 
15658 
  def __ne__(self, other):
15659 
    return not (self == other)
6838 vikram.rag 15660 
 
15661 
class getAllInsurers_args:
15662 
 
15663 
  thrift_spec = (
15664 
  )
15665 
 
15666 
  def read(self, iprot):
15667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15669 
      return
15670 
    iprot.readStructBegin()
15671 
    while True:
15672 
      (fname, ftype, fid) = iprot.readFieldBegin()
15673 
      if ftype == TType.STOP:
15674 
        break
15675 
      else:
15676 
        iprot.skip(ftype)
15677 
      iprot.readFieldEnd()
15678 
    iprot.readStructEnd()
15679 
 
15680 
  def write(self, oprot):
15681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15683 
      return
15684 
    oprot.writeStructBegin('getAllInsurers_args')
15685 
    oprot.writeFieldStop()
15686 
    oprot.writeStructEnd()
15687 
 
15688 
  def validate(self):
15689 
    return
15690 
 
15691 
 
15692 
  def __repr__(self):
15693 
    L = ['%s=%r' % (key, value)
15694 
      for key, value in self.__dict__.iteritems()]
15695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15696 
 
15697 
  def __eq__(self, other):
15698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15699 
 
15700 
  def __ne__(self, other):
15701 
    return not (self == other)
15702 
 
15703 
class getAllInsurers_result:
15704 
  """
15705 
  Attributes:
15706 
   - success
15707 
  """
15708 
 
15709 
  thrift_spec = (
15710 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15711 
  )
15712 
 
15713 
  def __init__(self, success=None,):
15714 
    self.success = success
15715 
 
15716 
  def read(self, iprot):
15717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15719 
      return
15720 
    iprot.readStructBegin()
15721 
    while True:
15722 
      (fname, ftype, fid) = iprot.readFieldBegin()
15723 
      if ftype == TType.STOP:
15724 
        break
15725 
      if fid == 0:
15726 
        if ftype == TType.LIST:
15727 
          self.success = []
7256 rajveer 15728 
          (_etype294, _size291) = iprot.readListBegin()
15729 
          for _i295 in xrange(_size291):
15730 
            _elem296 = Insurer()
15731 
            _elem296.read(iprot)
15732 
            self.success.append(_elem296)
6838 vikram.rag 15733 
          iprot.readListEnd()
15734 
        else:
15735 
          iprot.skip(ftype)
15736 
      else:
15737 
        iprot.skip(ftype)
15738 
      iprot.readFieldEnd()
15739 
    iprot.readStructEnd()
15740 
 
15741 
  def write(self, oprot):
15742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15744 
      return
15745 
    oprot.writeStructBegin('getAllInsurers_result')
15746 
    if self.success is not None:
15747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15749 
      for iter297 in self.success:
15750 
        iter297.write(oprot)
6838 vikram.rag 15751 
      oprot.writeListEnd()
15752 
      oprot.writeFieldEnd()
15753 
    oprot.writeFieldStop()
15754 
    oprot.writeStructEnd()
15755 
 
15756 
  def validate(self):
15757 
    return
15758 
 
15759 
 
15760 
  def __repr__(self):
15761 
    L = ['%s=%r' % (key, value)
15762 
      for key, value in self.__dict__.iteritems()]
15763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15764 
 
15765 
  def __eq__(self, other):
15766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15767 
 
15768 
  def __ne__(self, other):
15769 
    return not (self == other)
6962 rajveer 15770 
 
15771 
class updateInsuranceDeclaredAmount_args:
15772 
  """
15773 
  Attributes:
15774 
   - insurerId
15775 
   - amount
15776 
  """
15777 
 
15778 
  thrift_spec = (
15779 
    None, # 0
15780 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15781 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
15782 
  )
15783 
 
15784 
  def __init__(self, insurerId=None, amount=None,):
15785 
    self.insurerId = insurerId
15786 
    self.amount = amount
15787 
 
15788 
  def read(self, iprot):
15789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15791 
      return
15792 
    iprot.readStructBegin()
15793 
    while True:
15794 
      (fname, ftype, fid) = iprot.readFieldBegin()
15795 
      if ftype == TType.STOP:
15796 
        break
15797 
      if fid == 1:
15798 
        if ftype == TType.I64:
15799 
          self.insurerId = iprot.readI64();
15800 
        else:
15801 
          iprot.skip(ftype)
15802 
      elif fid == 2:
15803 
        if ftype == TType.DOUBLE:
15804 
          self.amount = iprot.readDouble();
15805 
        else:
15806 
          iprot.skip(ftype)
15807 
      else:
15808 
        iprot.skip(ftype)
15809 
      iprot.readFieldEnd()
15810 
    iprot.readStructEnd()
15811 
 
15812 
  def write(self, oprot):
15813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15815 
      return
15816 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
15817 
    if self.insurerId is not None:
15818 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15819 
      oprot.writeI64(self.insurerId)
15820 
      oprot.writeFieldEnd()
15821 
    if self.amount is not None:
15822 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
15823 
      oprot.writeDouble(self.amount)
15824 
      oprot.writeFieldEnd()
15825 
    oprot.writeFieldStop()
15826 
    oprot.writeStructEnd()
15827 
 
15828 
  def validate(self):
15829 
    return
15830 
 
15831 
 
15832 
  def __repr__(self):
15833 
    L = ['%s=%r' % (key, value)
15834 
      for key, value in self.__dict__.iteritems()]
15835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15836 
 
15837 
  def __eq__(self, other):
15838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15839 
 
15840 
  def __ne__(self, other):
15841 
    return not (self == other)
15842 
 
15843 
class updateInsuranceDeclaredAmount_result:
15844 
 
15845 
  thrift_spec = (
15846 
  )
15847 
 
15848 
  def read(self, iprot):
15849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15851 
      return
15852 
    iprot.readStructBegin()
15853 
    while True:
15854 
      (fname, ftype, fid) = iprot.readFieldBegin()
15855 
      if ftype == TType.STOP:
15856 
        break
15857 
      else:
15858 
        iprot.skip(ftype)
15859 
      iprot.readFieldEnd()
15860 
    iprot.readStructEnd()
15861 
 
15862 
  def write(self, oprot):
15863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15865 
      return
15866 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
15867 
    oprot.writeFieldStop()
15868 
    oprot.writeStructEnd()
15869 
 
15870 
  def validate(self):
15871 
    return
15872 
 
15873 
 
15874 
  def __repr__(self):
15875 
    L = ['%s=%r' % (key, value)
15876 
      for key, value in self.__dict__.iteritems()]
15877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15878 
 
15879 
  def __eq__(self, other):
15880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15881 
 
15882 
  def __ne__(self, other):
15883 
    return not (self == other)
7190 amar.kumar 15884 
 
15885 
class getFreebieForItem_args:
15886 
  """
15887 
  Attributes:
15888 
   - itemId
15889 
  """
15890 
 
15891 
  thrift_spec = (
15892 
    None, # 0
15893 
    (1, TType.I64, 'itemId', None, None, ), # 1
15894 
  )
15895 
 
15896 
  def __init__(self, itemId=None,):
15897 
    self.itemId = itemId
15898 
 
15899 
  def read(self, iprot):
15900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15902 
      return
15903 
    iprot.readStructBegin()
15904 
    while True:
15905 
      (fname, ftype, fid) = iprot.readFieldBegin()
15906 
      if ftype == TType.STOP:
15907 
        break
15908 
      if fid == 1:
15909 
        if ftype == TType.I64:
15910 
          self.itemId = iprot.readI64();
15911 
        else:
15912 
          iprot.skip(ftype)
15913 
      else:
15914 
        iprot.skip(ftype)
15915 
      iprot.readFieldEnd()
15916 
    iprot.readStructEnd()
15917 
 
15918 
  def write(self, oprot):
15919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15921 
      return
15922 
    oprot.writeStructBegin('getFreebieForItem_args')
15923 
    if self.itemId is not None:
15924 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15925 
      oprot.writeI64(self.itemId)
15926 
      oprot.writeFieldEnd()
15927 
    oprot.writeFieldStop()
15928 
    oprot.writeStructEnd()
15929 
 
15930 
  def validate(self):
15931 
    return
15932 
 
15933 
 
15934 
  def __repr__(self):
15935 
    L = ['%s=%r' % (key, value)
15936 
      for key, value in self.__dict__.iteritems()]
15937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15938 
 
15939 
  def __eq__(self, other):
15940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15941 
 
15942 
  def __ne__(self, other):
15943 
    return not (self == other)
15944 
 
15945 
class getFreebieForItem_result:
15946 
  """
15947 
  Attributes:
15948 
   - success
15949 
  """
15950 
 
15951 
  thrift_spec = (
15952 
    (0, TType.I64, 'success', None, None, ), # 0
15953 
  )
15954 
 
15955 
  def __init__(self, success=None,):
15956 
    self.success = success
15957 
 
15958 
  def read(self, iprot):
15959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15961 
      return
15962 
    iprot.readStructBegin()
15963 
    while True:
15964 
      (fname, ftype, fid) = iprot.readFieldBegin()
15965 
      if ftype == TType.STOP:
15966 
        break
15967 
      if fid == 0:
15968 
        if ftype == TType.I64:
15969 
          self.success = iprot.readI64();
15970 
        else:
15971 
          iprot.skip(ftype)
15972 
      else:
15973 
        iprot.skip(ftype)
15974 
      iprot.readFieldEnd()
15975 
    iprot.readStructEnd()
15976 
 
15977 
  def write(self, oprot):
15978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15980 
      return
15981 
    oprot.writeStructBegin('getFreebieForItem_result')
15982 
    if self.success is not None:
15983 
      oprot.writeFieldBegin('success', TType.I64, 0)
15984 
      oprot.writeI64(self.success)
15985 
      oprot.writeFieldEnd()
15986 
    oprot.writeFieldStop()
15987 
    oprot.writeStructEnd()
15988 
 
15989 
  def validate(self):
15990 
    return
15991 
 
15992 
 
15993 
  def __repr__(self):
15994 
    L = ['%s=%r' % (key, value)
15995 
      for key, value in self.__dict__.iteritems()]
15996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15997 
 
15998 
  def __eq__(self, other):
15999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16000 
 
16001 
  def __ne__(self, other):
16002 
    return not (self == other)
16003 
 
16004 
class addOrUpdateFreebieForItem_args:
16005 
  """
16006 
  Attributes:
16007 
   - freebieItem
16008 
  """
16009 
 
16010 
  thrift_spec = (
16011 
    None, # 0
16012 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16013 
  )
16014 
 
16015 
  def __init__(self, freebieItem=None,):
16016 
    self.freebieItem = freebieItem
16017 
 
16018 
  def read(self, iprot):
16019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16021 
      return
16022 
    iprot.readStructBegin()
16023 
    while True:
16024 
      (fname, ftype, fid) = iprot.readFieldBegin()
16025 
      if ftype == TType.STOP:
16026 
        break
16027 
      if fid == 1:
16028 
        if ftype == TType.STRUCT:
16029 
          self.freebieItem = FreebieItem()
16030 
          self.freebieItem.read(iprot)
16031 
        else:
16032 
          iprot.skip(ftype)
16033 
      else:
16034 
        iprot.skip(ftype)
16035 
      iprot.readFieldEnd()
16036 
    iprot.readStructEnd()
16037 
 
16038 
  def write(self, oprot):
16039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16041 
      return
16042 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16043 
    if self.freebieItem is not None:
16044 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16045 
      self.freebieItem.write(oprot)
16046 
      oprot.writeFieldEnd()
16047 
    oprot.writeFieldStop()
16048 
    oprot.writeStructEnd()
16049 
 
16050 
  def validate(self):
16051 
    return
16052 
 
16053 
 
16054 
  def __repr__(self):
16055 
    L = ['%s=%r' % (key, value)
16056 
      for key, value in self.__dict__.iteritems()]
16057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16058 
 
16059 
  def __eq__(self, other):
16060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16061 
 
16062 
  def __ne__(self, other):
16063 
    return not (self == other)
16064 
 
16065 
class addOrUpdateFreebieForItem_result:
16066 
 
16067 
  thrift_spec = (
16068 
  )
16069 
 
16070 
  def read(self, iprot):
16071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16073 
      return
16074 
    iprot.readStructBegin()
16075 
    while True:
16076 
      (fname, ftype, fid) = iprot.readFieldBegin()
16077 
      if ftype == TType.STOP:
16078 
        break
16079 
      else:
16080 
        iprot.skip(ftype)
16081 
      iprot.readFieldEnd()
16082 
    iprot.readStructEnd()
16083 
 
16084 
  def write(self, oprot):
16085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16087 
      return
16088 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16089 
    oprot.writeFieldStop()
16090 
    oprot.writeStructEnd()
16091 
 
16092 
  def validate(self):
16093 
    return
16094 
 
16095 
 
16096 
  def __repr__(self):
16097 
    L = ['%s=%r' % (key, value)
16098 
      for key, value in self.__dict__.iteritems()]
16099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16100 
 
16101 
  def __eq__(self, other):
16102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16103 
 
16104 
  def __ne__(self, other):
16105 
    return not (self == other)
7256 rajveer 16106 
 
7272 amit.gupta 16107 
class addOrUpdateBrandInfo_args:
16108 
  """
16109 
  Attributes:
16110 
   - brandInfo
16111 
  """
16112 
 
16113 
  thrift_spec = (
16114 
    None, # 0
16115 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16116 
  )
16117 
 
16118 
  def __init__(self, brandInfo=None,):
16119 
    self.brandInfo = brandInfo
16120 
 
16121 
  def read(self, iprot):
16122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16124 
      return
16125 
    iprot.readStructBegin()
16126 
    while True:
16127 
      (fname, ftype, fid) = iprot.readFieldBegin()
16128 
      if ftype == TType.STOP:
16129 
        break
16130 
      if fid == 1:
16131 
        if ftype == TType.STRUCT:
16132 
          self.brandInfo = BrandInfo()
16133 
          self.brandInfo.read(iprot)
16134 
        else:
16135 
          iprot.skip(ftype)
16136 
      else:
16137 
        iprot.skip(ftype)
16138 
      iprot.readFieldEnd()
16139 
    iprot.readStructEnd()
16140 
 
16141 
  def write(self, oprot):
16142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16144 
      return
16145 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16146 
    if self.brandInfo is not None:
16147 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16148 
      self.brandInfo.write(oprot)
16149 
      oprot.writeFieldEnd()
16150 
    oprot.writeFieldStop()
16151 
    oprot.writeStructEnd()
16152 
 
16153 
  def validate(self):
16154 
    return
16155 
 
16156 
 
16157 
  def __repr__(self):
16158 
    L = ['%s=%r' % (key, value)
16159 
      for key, value in self.__dict__.iteritems()]
16160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16161 
 
16162 
  def __eq__(self, other):
16163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16164 
 
16165 
  def __ne__(self, other):
16166 
    return not (self == other)
16167 
 
16168 
class addOrUpdateBrandInfo_result:
16169 
 
16170 
  thrift_spec = (
16171 
  )
16172 
 
16173 
  def read(self, iprot):
16174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16176 
      return
16177 
    iprot.readStructBegin()
16178 
    while True:
16179 
      (fname, ftype, fid) = iprot.readFieldBegin()
16180 
      if ftype == TType.STOP:
16181 
        break
16182 
      else:
16183 
        iprot.skip(ftype)
16184 
      iprot.readFieldEnd()
16185 
    iprot.readStructEnd()
16186 
 
16187 
  def write(self, oprot):
16188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16190 
      return
16191 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16192 
    oprot.writeFieldStop()
16193 
    oprot.writeStructEnd()
16194 
 
16195 
  def validate(self):
16196 
    return
16197 
 
16198 
 
16199 
  def __repr__(self):
16200 
    L = ['%s=%r' % (key, value)
16201 
      for key, value in self.__dict__.iteritems()]
16202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16203 
 
16204 
  def __eq__(self, other):
16205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16206 
 
16207 
  def __ne__(self, other):
16208 
    return not (self == other)
16209 
 
16210 
class getBrandInfo_args:
16211 
 
16212 
  thrift_spec = (
16213 
  )
16214 
 
16215 
  def read(self, iprot):
16216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16218 
      return
16219 
    iprot.readStructBegin()
16220 
    while True:
16221 
      (fname, ftype, fid) = iprot.readFieldBegin()
16222 
      if ftype == TType.STOP:
16223 
        break
16224 
      else:
16225 
        iprot.skip(ftype)
16226 
      iprot.readFieldEnd()
16227 
    iprot.readStructEnd()
16228 
 
16229 
  def write(self, oprot):
16230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16232 
      return
16233 
    oprot.writeStructBegin('getBrandInfo_args')
16234 
    oprot.writeFieldStop()
16235 
    oprot.writeStructEnd()
16236 
 
16237 
  def validate(self):
16238 
    return
16239 
 
16240 
 
16241 
  def __repr__(self):
16242 
    L = ['%s=%r' % (key, value)
16243 
      for key, value in self.__dict__.iteritems()]
16244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16245 
 
16246 
  def __eq__(self, other):
16247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16248 
 
16249 
  def __ne__(self, other):
16250 
    return not (self == other)
16251 
 
16252 
class getBrandInfo_result:
16253 
  """
16254 
  Attributes:
16255 
   - success
16256 
  """
16257 
 
16258 
  thrift_spec = (
16259 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16260 
  )
16261 
 
16262 
  def __init__(self, success=None,):
16263 
    self.success = success
16264 
 
16265 
  def read(self, iprot):
16266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16268 
      return
16269 
    iprot.readStructBegin()
16270 
    while True:
16271 
      (fname, ftype, fid) = iprot.readFieldBegin()
16272 
      if ftype == TType.STOP:
16273 
        break
16274 
      if fid == 0:
16275 
        if ftype == TType.MAP:
16276 
          self.success = {}
16277 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
16278 
          for _i302 in xrange(_size298):
16279 
            _key303 = iprot.readString();
16280 
            _val304 = BrandInfo()
16281 
            _val304.read(iprot)
16282 
            self.success[_key303] = _val304
16283 
          iprot.readMapEnd()
16284 
        else:
16285 
          iprot.skip(ftype)
16286 
      else:
16287 
        iprot.skip(ftype)
16288 
      iprot.readFieldEnd()
16289 
    iprot.readStructEnd()
16290 
 
16291 
  def write(self, oprot):
16292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16294 
      return
16295 
    oprot.writeStructBegin('getBrandInfo_result')
16296 
    if self.success is not None:
16297 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16298 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
16299 
      for kiter305,viter306 in self.success.items():
16300 
        oprot.writeString(kiter305)
16301 
        viter306.write(oprot)
16302 
      oprot.writeMapEnd()
16303 
      oprot.writeFieldEnd()
16304 
    oprot.writeFieldStop()
16305 
    oprot.writeStructEnd()
16306 
 
16307 
  def validate(self):
16308 
    return
16309 
 
16310 
 
16311 
  def __repr__(self):
16312 
    L = ['%s=%r' % (key, value)
16313 
      for key, value in self.__dict__.iteritems()]
16314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16315 
 
16316 
  def __eq__(self, other):
16317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16318 
 
16319 
  def __ne__(self, other):
16320 
    return not (self == other)
16321 
 
7256 rajveer 16322 
class getStorePricing_args:
16323 
  """
16324 
  Attributes:
16325 
   - itemId
16326 
  """
16327 
 
16328 
  thrift_spec = (
16329 
    None, # 0
16330 
    (1, TType.I64, 'itemId', None, None, ), # 1
16331 
  )
16332 
 
16333 
  def __init__(self, itemId=None,):
16334 
    self.itemId = itemId
16335 
 
16336 
  def read(self, iprot):
16337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16339 
      return
16340 
    iprot.readStructBegin()
16341 
    while True:
16342 
      (fname, ftype, fid) = iprot.readFieldBegin()
16343 
      if ftype == TType.STOP:
16344 
        break
16345 
      if fid == 1:
16346 
        if ftype == TType.I64:
16347 
          self.itemId = iprot.readI64();
16348 
        else:
16349 
          iprot.skip(ftype)
16350 
      else:
16351 
        iprot.skip(ftype)
16352 
      iprot.readFieldEnd()
16353 
    iprot.readStructEnd()
16354 
 
16355 
  def write(self, oprot):
16356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16358 
      return
16359 
    oprot.writeStructBegin('getStorePricing_args')
16360 
    if self.itemId is not None:
16361 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16362 
      oprot.writeI64(self.itemId)
16363 
      oprot.writeFieldEnd()
16364 
    oprot.writeFieldStop()
16365 
    oprot.writeStructEnd()
16366 
 
16367 
  def validate(self):
16368 
    return
16369 
 
16370 
 
16371 
  def __repr__(self):
16372 
    L = ['%s=%r' % (key, value)
16373 
      for key, value in self.__dict__.iteritems()]
16374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16375 
 
16376 
  def __eq__(self, other):
16377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16378 
 
16379 
  def __ne__(self, other):
16380 
    return not (self == other)
16381 
 
16382 
class getStorePricing_result:
16383 
  """
16384 
  Attributes:
16385 
   - success
16386 
  """
16387 
 
16388 
  thrift_spec = (
16389 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16390 
  )
16391 
 
16392 
  def __init__(self, success=None,):
16393 
    self.success = success
16394 
 
16395 
  def read(self, iprot):
16396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16398 
      return
16399 
    iprot.readStructBegin()
16400 
    while True:
16401 
      (fname, ftype, fid) = iprot.readFieldBegin()
16402 
      if ftype == TType.STOP:
16403 
        break
16404 
      if fid == 0:
16405 
        if ftype == TType.STRUCT:
16406 
          self.success = StorePricing()
16407 
          self.success.read(iprot)
16408 
        else:
16409 
          iprot.skip(ftype)
16410 
      else:
16411 
        iprot.skip(ftype)
16412 
      iprot.readFieldEnd()
16413 
    iprot.readStructEnd()
16414 
 
16415 
  def write(self, oprot):
16416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16418 
      return
16419 
    oprot.writeStructBegin('getStorePricing_result')
16420 
    if self.success is not None:
16421 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16422 
      self.success.write(oprot)
16423 
      oprot.writeFieldEnd()
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)
7265 rajveer 16441 
 
7306 rajveer 16442 
class getStorePricings_args:
16443 
  """
16444 
  Attributes:
16445 
   - itemIds
16446 
  """
16447 
 
16448 
  thrift_spec = (
16449 
    None, # 0
16450 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16451 
  )
16452 
 
16453 
  def __init__(self, itemIds=None,):
16454 
    self.itemIds = itemIds
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.LIST:
16467 
          self.itemIds = []
16468 
          (_etype310, _size307) = iprot.readListBegin()
16469 
          for _i311 in xrange(_size307):
16470 
            _elem312 = iprot.readI64();
16471 
            self.itemIds.append(_elem312)
16472 
          iprot.readListEnd()
16473 
        else:
16474 
          iprot.skip(ftype)
16475 
      else:
16476 
        iprot.skip(ftype)
16477 
      iprot.readFieldEnd()
16478 
    iprot.readStructEnd()
16479 
 
16480 
  def write(self, oprot):
16481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16483 
      return
16484 
    oprot.writeStructBegin('getStorePricings_args')
16485 
    if self.itemIds is not None:
16486 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16487 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
16488 
      for iter313 in self.itemIds:
16489 
        oprot.writeI64(iter313)
16490 
      oprot.writeListEnd()
16491 
      oprot.writeFieldEnd()
16492 
    oprot.writeFieldStop()
16493 
    oprot.writeStructEnd()
16494 
 
16495 
  def validate(self):
16496 
    return
16497 
 
16498 
 
16499 
  def __repr__(self):
16500 
    L = ['%s=%r' % (key, value)
16501 
      for key, value in self.__dict__.iteritems()]
16502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16503 
 
16504 
  def __eq__(self, other):
16505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16506 
 
16507 
  def __ne__(self, other):
16508 
    return not (self == other)
16509 
 
16510 
class getStorePricings_result:
16511 
  """
16512 
  Attributes:
16513 
   - success
16514 
  """
16515 
 
16516 
  thrift_spec = (
16517 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16518 
  )
16519 
 
16520 
  def __init__(self, success=None,):
16521 
    self.success = success
16522 
 
16523 
  def read(self, iprot):
16524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16526 
      return
16527 
    iprot.readStructBegin()
16528 
    while True:
16529 
      (fname, ftype, fid) = iprot.readFieldBegin()
16530 
      if ftype == TType.STOP:
16531 
        break
16532 
      if fid == 0:
16533 
        if ftype == TType.LIST:
16534 
          self.success = []
16535 
          (_etype317, _size314) = iprot.readListBegin()
16536 
          for _i318 in xrange(_size314):
16537 
            _elem319 = StorePricing()
16538 
            _elem319.read(iprot)
16539 
            self.success.append(_elem319)
16540 
          iprot.readListEnd()
16541 
        else:
16542 
          iprot.skip(ftype)
16543 
      else:
16544 
        iprot.skip(ftype)
16545 
      iprot.readFieldEnd()
16546 
    iprot.readStructEnd()
16547 
 
16548 
  def write(self, oprot):
16549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16551 
      return
16552 
    oprot.writeStructBegin('getStorePricings_result')
16553 
    if self.success is not None:
16554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16556 
      for iter320 in self.success:
16557 
        iter320.write(oprot)
16558 
      oprot.writeListEnd()
16559 
      oprot.writeFieldEnd()
16560 
    oprot.writeFieldStop()
16561 
    oprot.writeStructEnd()
16562 
 
16563 
  def validate(self):
16564 
    return
16565 
 
16566 
 
16567 
  def __repr__(self):
16568 
    L = ['%s=%r' % (key, value)
16569 
      for key, value in self.__dict__.iteritems()]
16570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16571 
 
16572 
  def __eq__(self, other):
16573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16574 
 
16575 
  def __ne__(self, other):
16576 
    return not (self == other)
16577 
 
7265 rajveer 16578 
class updateStorePricing_args:
16579 
  """
16580 
  Attributes:
16581 
   - sp
16582 
  """
16583 
 
16584 
  thrift_spec = (
16585 
    None, # 0
16586 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
16587 
  )
16588 
 
16589 
  def __init__(self, sp=None,):
16590 
    self.sp = sp
16591 
 
16592 
  def read(self, iprot):
16593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16595 
      return
16596 
    iprot.readStructBegin()
16597 
    while True:
16598 
      (fname, ftype, fid) = iprot.readFieldBegin()
16599 
      if ftype == TType.STOP:
16600 
        break
16601 
      if fid == 1:
16602 
        if ftype == TType.STRUCT:
16603 
          self.sp = StorePricing()
16604 
          self.sp.read(iprot)
16605 
        else:
16606 
          iprot.skip(ftype)
16607 
      else:
16608 
        iprot.skip(ftype)
16609 
      iprot.readFieldEnd()
16610 
    iprot.readStructEnd()
16611 
 
16612 
  def write(self, oprot):
16613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16615 
      return
16616 
    oprot.writeStructBegin('updateStorePricing_args')
16617 
    if self.sp is not None:
16618 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16619 
      self.sp.write(oprot)
16620 
      oprot.writeFieldEnd()
16621 
    oprot.writeFieldStop()
16622 
    oprot.writeStructEnd()
16623 
 
16624 
  def validate(self):
16625 
    return
16626 
 
16627 
 
16628 
  def __repr__(self):
16629 
    L = ['%s=%r' % (key, value)
16630 
      for key, value in self.__dict__.iteritems()]
16631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16632 
 
16633 
  def __eq__(self, other):
16634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16635 
 
16636 
  def __ne__(self, other):
16637 
    return not (self == other)
16638 
 
16639 
class updateStorePricing_result:
16640 
 
16641 
  thrift_spec = (
16642 
  )
16643 
 
16644 
  def read(self, iprot):
16645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16647 
      return
16648 
    iprot.readStructBegin()
16649 
    while True:
16650 
      (fname, ftype, fid) = iprot.readFieldBegin()
16651 
      if ftype == TType.STOP:
16652 
        break
16653 
      else:
16654 
        iprot.skip(ftype)
16655 
      iprot.readFieldEnd()
16656 
    iprot.readStructEnd()
16657 
 
16658 
  def write(self, oprot):
16659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16661 
      return
16662 
    oprot.writeStructBegin('updateStorePricing_result')
16663 
    oprot.writeFieldStop()
16664 
    oprot.writeStructEnd()
16665 
 
16666 
  def validate(self):
16667 
    return
16668 
 
16669 
 
16670 
  def __repr__(self):
16671 
    L = ['%s=%r' % (key, value)
16672 
      for key, value in self.__dict__.iteritems()]
16673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16674 
 
16675 
  def __eq__(self, other):
16676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16677 
 
16678 
  def __ne__(self, other):
16679 
    return not (self == other)
7281 kshitij.so 16680 
 
16681 
class getAllAmazonListedItems_args:
16682 
 
16683 
  thrift_spec = (
16684 
  )
16685 
 
16686 
  def read(self, iprot):
16687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16689 
      return
16690 
    iprot.readStructBegin()
16691 
    while True:
16692 
      (fname, ftype, fid) = iprot.readFieldBegin()
16693 
      if ftype == TType.STOP:
16694 
        break
16695 
      else:
16696 
        iprot.skip(ftype)
16697 
      iprot.readFieldEnd()
16698 
    iprot.readStructEnd()
16699 
 
16700 
  def write(self, oprot):
16701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16703 
      return
16704 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16705 
    oprot.writeFieldStop()
16706 
    oprot.writeStructEnd()
16707 
 
16708 
  def validate(self):
16709 
    return
16710 
 
16711 
 
16712 
  def __repr__(self):
16713 
    L = ['%s=%r' % (key, value)
16714 
      for key, value in self.__dict__.iteritems()]
16715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16716 
 
16717 
  def __eq__(self, other):
16718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16719 
 
16720 
  def __ne__(self, other):
16721 
    return not (self == other)
16722 
 
16723 
class getAllAmazonListedItems_result:
16724 
  """
16725 
  Attributes:
16726 
   - success
16727 
  """
16728 
 
16729 
  thrift_spec = (
16730 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16731 
  )
16732 
 
16733 
  def __init__(self, success=None,):
16734 
    self.success = success
16735 
 
16736 
  def read(self, iprot):
16737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16739 
      return
16740 
    iprot.readStructBegin()
16741 
    while True:
16742 
      (fname, ftype, fid) = iprot.readFieldBegin()
16743 
      if ftype == TType.STOP:
16744 
        break
16745 
      if fid == 0:
16746 
        if ftype == TType.LIST:
16747 
          self.success = []
7306 rajveer 16748 
          (_etype324, _size321) = iprot.readListBegin()
16749 
          for _i325 in xrange(_size321):
16750 
            _elem326 = Amazonlisted()
16751 
            _elem326.read(iprot)
16752 
            self.success.append(_elem326)
7281 kshitij.so 16753 
          iprot.readListEnd()
16754 
        else:
16755 
          iprot.skip(ftype)
16756 
      else:
16757 
        iprot.skip(ftype)
16758 
      iprot.readFieldEnd()
16759 
    iprot.readStructEnd()
16760 
 
16761 
  def write(self, oprot):
16762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16764 
      return
16765 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
16766 
    if self.success is not None:
16767 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16768 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 16769 
      for iter327 in self.success:
16770 
        iter327.write(oprot)
7281 kshitij.so 16771 
      oprot.writeListEnd()
16772 
      oprot.writeFieldEnd()
16773 
    oprot.writeFieldStop()
16774 
    oprot.writeStructEnd()
16775 
 
16776 
  def validate(self):
16777 
    return
16778 
 
16779 
 
16780 
  def __repr__(self):
16781 
    L = ['%s=%r' % (key, value)
16782 
      for key, value in self.__dict__.iteritems()]
16783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16784 
 
16785 
  def __eq__(self, other):
16786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16787 
 
16788 
  def __ne__(self, other):
16789 
    return not (self == other)
16790 
 
16791 
class getAmazonItemDetails_args:
16792 
  """
16793 
  Attributes:
16794 
   - itemId
16795 
  """
16796 
 
16797 
  thrift_spec = (
16798 
    None, # 0
16799 
    (1, TType.I64, 'itemId', None, None, ), # 1
16800 
  )
16801 
 
16802 
  def __init__(self, itemId=None,):
16803 
    self.itemId = itemId
16804 
 
16805 
  def read(self, iprot):
16806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16808 
      return
16809 
    iprot.readStructBegin()
16810 
    while True:
16811 
      (fname, ftype, fid) = iprot.readFieldBegin()
16812 
      if ftype == TType.STOP:
16813 
        break
16814 
      if fid == 1:
16815 
        if ftype == TType.I64:
16816 
          self.itemId = iprot.readI64();
16817 
        else:
16818 
          iprot.skip(ftype)
16819 
      else:
16820 
        iprot.skip(ftype)
16821 
      iprot.readFieldEnd()
16822 
    iprot.readStructEnd()
16823 
 
16824 
  def write(self, oprot):
16825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16827 
      return
16828 
    oprot.writeStructBegin('getAmazonItemDetails_args')
16829 
    if self.itemId is not None:
16830 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16831 
      oprot.writeI64(self.itemId)
16832 
      oprot.writeFieldEnd()
16833 
    oprot.writeFieldStop()
16834 
    oprot.writeStructEnd()
16835 
 
16836 
  def validate(self):
16837 
    return
16838 
 
16839 
 
16840 
  def __repr__(self):
16841 
    L = ['%s=%r' % (key, value)
16842 
      for key, value in self.__dict__.iteritems()]
16843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16844 
 
16845 
  def __eq__(self, other):
16846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16847 
 
16848 
  def __ne__(self, other):
16849 
    return not (self == other)
16850 
 
16851 
class getAmazonItemDetails_result:
16852 
  """
16853 
  Attributes:
16854 
   - success
16855 
  """
16856 
 
16857 
  thrift_spec = (
16858 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
16859 
  )
16860 
 
16861 
  def __init__(self, success=None,):
16862 
    self.success = success
16863 
 
16864 
  def read(self, iprot):
16865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16867 
      return
16868 
    iprot.readStructBegin()
16869 
    while True:
16870 
      (fname, ftype, fid) = iprot.readFieldBegin()
16871 
      if ftype == TType.STOP:
16872 
        break
16873 
      if fid == 0:
16874 
        if ftype == TType.STRUCT:
16875 
          self.success = Amazonlisted()
16876 
          self.success.read(iprot)
16877 
        else:
16878 
          iprot.skip(ftype)
16879 
      else:
16880 
        iprot.skip(ftype)
16881 
      iprot.readFieldEnd()
16882 
    iprot.readStructEnd()
16883 
 
16884 
  def write(self, oprot):
16885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16887 
      return
16888 
    oprot.writeStructBegin('getAmazonItemDetails_result')
16889 
    if self.success is not None:
16890 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16891 
      self.success.write(oprot)
16892 
      oprot.writeFieldEnd()
16893 
    oprot.writeFieldStop()
16894 
    oprot.writeStructEnd()
16895 
 
16896 
  def validate(self):
16897 
    return
16898 
 
16899 
 
16900 
  def __repr__(self):
16901 
    L = ['%s=%r' % (key, value)
16902 
      for key, value in self.__dict__.iteritems()]
16903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16904 
 
16905 
  def __eq__(self, other):
16906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16907 
 
16908 
  def __ne__(self, other):
16909 
    return not (self == other)
16910 
 
16911 
class updateAmazonItemDetails_args:
16912 
  """
16913 
  Attributes:
16914 
   - itemId
16915 
   - fbaPrice
16916 
   - sellingPrice
16917 
   - isFba
16918 
   - isNonFba
16919 
   - isInventoryOverride
16920 
  """
16921 
 
16922 
  thrift_spec = (
16923 
    None, # 0
16924 
    (1, TType.I64, 'itemId', None, None, ), # 1
16925 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
16926 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
16927 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
16928 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
16929 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
16930 
  )
16931 
 
16932 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None,):
16933 
    self.itemId = itemId
16934 
    self.fbaPrice = fbaPrice
16935 
    self.sellingPrice = sellingPrice
16936 
    self.isFba = isFba
16937 
    self.isNonFba = isNonFba
16938 
    self.isInventoryOverride = isInventoryOverride
16939 
 
16940 
  def read(self, iprot):
16941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16943 
      return
16944 
    iprot.readStructBegin()
16945 
    while True:
16946 
      (fname, ftype, fid) = iprot.readFieldBegin()
16947 
      if ftype == TType.STOP:
16948 
        break
16949 
      if fid == 1:
16950 
        if ftype == TType.I64:
16951 
          self.itemId = iprot.readI64();
16952 
        else:
16953 
          iprot.skip(ftype)
16954 
      elif fid == 2:
16955 
        if ftype == TType.DOUBLE:
16956 
          self.fbaPrice = iprot.readDouble();
16957 
        else:
16958 
          iprot.skip(ftype)
16959 
      elif fid == 3:
16960 
        if ftype == TType.DOUBLE:
16961 
          self.sellingPrice = iprot.readDouble();
16962 
        else:
16963 
          iprot.skip(ftype)
16964 
      elif fid == 4:
16965 
        if ftype == TType.BOOL:
16966 
          self.isFba = iprot.readBool();
16967 
        else:
16968 
          iprot.skip(ftype)
16969 
      elif fid == 5:
16970 
        if ftype == TType.BOOL:
16971 
          self.isNonFba = iprot.readBool();
16972 
        else:
16973 
          iprot.skip(ftype)
16974 
      elif fid == 6:
16975 
        if ftype == TType.BOOL:
16976 
          self.isInventoryOverride = iprot.readBool();
16977 
        else:
16978 
          iprot.skip(ftype)
16979 
      else:
16980 
        iprot.skip(ftype)
16981 
      iprot.readFieldEnd()
16982 
    iprot.readStructEnd()
16983 
 
16984 
  def write(self, oprot):
16985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16987 
      return
16988 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
16989 
    if self.itemId is not None:
16990 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16991 
      oprot.writeI64(self.itemId)
16992 
      oprot.writeFieldEnd()
16993 
    if self.fbaPrice is not None:
16994 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
16995 
      oprot.writeDouble(self.fbaPrice)
16996 
      oprot.writeFieldEnd()
16997 
    if self.sellingPrice is not None:
16998 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
16999 
      oprot.writeDouble(self.sellingPrice)
17000 
      oprot.writeFieldEnd()
17001 
    if self.isFba is not None:
17002 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17003 
      oprot.writeBool(self.isFba)
17004 
      oprot.writeFieldEnd()
17005 
    if self.isNonFba is not None:
17006 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17007 
      oprot.writeBool(self.isNonFba)
17008 
      oprot.writeFieldEnd()
17009 
    if self.isInventoryOverride is not None:
17010 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17011 
      oprot.writeBool(self.isInventoryOverride)
17012 
      oprot.writeFieldEnd()
17013 
    oprot.writeFieldStop()
17014 
    oprot.writeStructEnd()
17015 
 
17016 
  def validate(self):
17017 
    return
17018 
 
17019 
 
17020 
  def __repr__(self):
17021 
    L = ['%s=%r' % (key, value)
17022 
      for key, value in self.__dict__.iteritems()]
17023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17024 
 
17025 
  def __eq__(self, other):
17026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17027 
 
17028 
  def __ne__(self, other):
17029 
    return not (self == other)
17030 
 
17031 
class updateAmazonItemDetails_result:
17032 
 
17033 
  thrift_spec = (
17034 
  )
17035 
 
17036 
  def read(self, iprot):
17037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17039 
      return
17040 
    iprot.readStructBegin()
17041 
    while True:
17042 
      (fname, ftype, fid) = iprot.readFieldBegin()
17043 
      if ftype == TType.STOP:
17044 
        break
17045 
      else:
17046 
        iprot.skip(ftype)
17047 
      iprot.readFieldEnd()
17048 
    iprot.readStructEnd()
17049 
 
17050 
  def write(self, oprot):
17051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17053 
      return
17054 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17055 
    oprot.writeFieldStop()
17056 
    oprot.writeStructEnd()
17057 
 
17058 
  def validate(self):
17059 
    return
17060 
 
17061 
 
17062 
  def __repr__(self):
17063 
    L = ['%s=%r' % (key, value)
17064 
      for key, value in self.__dict__.iteritems()]
17065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17066 
 
17067 
  def __eq__(self, other):
17068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17069 
 
17070 
  def __ne__(self, other):
17071 
    return not (self == other)
17072 
 
17073 
class addAmazonItem_args:
17074 
  """
17075 
  Attributes:
17076 
   - amazonlisted
17077 
  """
17078 
 
17079 
  thrift_spec = (
17080 
    None, # 0
17081 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17082 
  )
17083 
 
17084 
  def __init__(self, amazonlisted=None,):
17085 
    self.amazonlisted = amazonlisted
17086 
 
17087 
  def read(self, iprot):
17088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17090 
      return
17091 
    iprot.readStructBegin()
17092 
    while True:
17093 
      (fname, ftype, fid) = iprot.readFieldBegin()
17094 
      if ftype == TType.STOP:
17095 
        break
17096 
      if fid == 1:
17097 
        if ftype == TType.STRUCT:
17098 
          self.amazonlisted = Amazonlisted()
17099 
          self.amazonlisted.read(iprot)
17100 
        else:
17101 
          iprot.skip(ftype)
17102 
      else:
17103 
        iprot.skip(ftype)
17104 
      iprot.readFieldEnd()
17105 
    iprot.readStructEnd()
17106 
 
17107 
  def write(self, oprot):
17108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17110 
      return
17111 
    oprot.writeStructBegin('addAmazonItem_args')
17112 
    if self.amazonlisted is not None:
17113 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17114 
      self.amazonlisted.write(oprot)
17115 
      oprot.writeFieldEnd()
17116 
    oprot.writeFieldStop()
17117 
    oprot.writeStructEnd()
17118 
 
17119 
  def validate(self):
17120 
    return
17121 
 
17122 
 
17123 
  def __repr__(self):
17124 
    L = ['%s=%r' % (key, value)
17125 
      for key, value in self.__dict__.iteritems()]
17126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17127 
 
17128 
  def __eq__(self, other):
17129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17130 
 
17131 
  def __ne__(self, other):
17132 
    return not (self == other)
17133 
 
17134 
class addAmazonItem_result:
17135 
 
17136 
  thrift_spec = (
17137 
  )
17138 
 
17139 
  def read(self, iprot):
17140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17142 
      return
17143 
    iprot.readStructBegin()
17144 
    while True:
17145 
      (fname, ftype, fid) = iprot.readFieldBegin()
17146 
      if ftype == TType.STOP:
17147 
        break
17148 
      else:
17149 
        iprot.skip(ftype)
17150 
      iprot.readFieldEnd()
17151 
    iprot.readStructEnd()
17152 
 
17153 
  def write(self, oprot):
17154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17156 
      return
17157 
    oprot.writeStructBegin('addAmazonItem_result')
17158 
    oprot.writeFieldStop()
17159 
    oprot.writeStructEnd()
17160 
 
17161 
  def validate(self):
17162 
    return
17163 
 
17164 
 
17165 
  def __repr__(self):
17166 
    L = ['%s=%r' % (key, value)
17167 
      for key, value in self.__dict__.iteritems()]
17168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17169 
 
17170 
  def __eq__(self, other):
17171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17172 
 
17173 
  def __ne__(self, other):
17174 
    return not (self == other)
7291 vikram.rag 17175 
 
17176 
class getAsinItems_args:
17177 
 
17178 
  thrift_spec = (
17179 
  )
17180 
 
17181 
  def read(self, iprot):
17182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17184 
      return
17185 
    iprot.readStructBegin()
17186 
    while True:
17187 
      (fname, ftype, fid) = iprot.readFieldBegin()
17188 
      if ftype == TType.STOP:
17189 
        break
17190 
      else:
17191 
        iprot.skip(ftype)
17192 
      iprot.readFieldEnd()
17193 
    iprot.readStructEnd()
17194 
 
17195 
  def write(self, oprot):
17196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17198 
      return
17199 
    oprot.writeStructBegin('getAsinItems_args')
17200 
    oprot.writeFieldStop()
17201 
    oprot.writeStructEnd()
17202 
 
17203 
  def validate(self):
17204 
    return
17205 
 
17206 
 
17207 
  def __repr__(self):
17208 
    L = ['%s=%r' % (key, value)
17209 
      for key, value in self.__dict__.iteritems()]
17210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17211 
 
17212 
  def __eq__(self, other):
17213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17214 
 
17215 
  def __ne__(self, other):
17216 
    return not (self == other)
17217 
 
17218 
class getAsinItems_result:
17219 
  """
17220 
  Attributes:
17221 
   - success
17222 
  """
17223 
 
17224 
  thrift_spec = (
17225 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17226 
  )
17227 
 
17228 
  def __init__(self, success=None,):
17229 
    self.success = success
17230 
 
17231 
  def read(self, iprot):
17232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17234 
      return
17235 
    iprot.readStructBegin()
17236 
    while True:
17237 
      (fname, ftype, fid) = iprot.readFieldBegin()
17238 
      if ftype == TType.STOP:
17239 
        break
17240 
      if fid == 0:
17241 
        if ftype == TType.LIST:
17242 
          self.success = []
7306 rajveer 17243 
          (_etype331, _size328) = iprot.readListBegin()
17244 
          for _i332 in xrange(_size328):
17245 
            _elem333 = Item()
17246 
            _elem333.read(iprot)
17247 
            self.success.append(_elem333)
7291 vikram.rag 17248 
          iprot.readListEnd()
17249 
        else:
17250 
          iprot.skip(ftype)
17251 
      else:
17252 
        iprot.skip(ftype)
17253 
      iprot.readFieldEnd()
17254 
    iprot.readStructEnd()
17255 
 
17256 
  def write(self, oprot):
17257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17259 
      return
17260 
    oprot.writeStructBegin('getAsinItems_result')
17261 
    if self.success is not None:
17262 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17263 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17264 
      for iter334 in self.success:
17265 
        iter334.write(oprot)
7291 vikram.rag 17266 
      oprot.writeListEnd()
17267 
      oprot.writeFieldEnd()
17268 
    oprot.writeFieldStop()
17269 
    oprot.writeStructEnd()
17270 
 
17271 
  def validate(self):
17272 
    return
17273 
 
17274 
 
17275 
  def __repr__(self):
17276 
    L = ['%s=%r' % (key, value)
17277 
      for key, value in self.__dict__.iteritems()]
17278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17279 
 
17280 
  def __eq__(self, other):
17281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17282 
 
17283 
  def __ne__(self, other):
17284 
    return not (self == other)
17285 
 
17286 
class getAllFbaListedItems_args:
17287 
 
17288 
  thrift_spec = (
17289 
  )
17290 
 
17291 
  def read(self, iprot):
17292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17294 
      return
17295 
    iprot.readStructBegin()
17296 
    while True:
17297 
      (fname, ftype, fid) = iprot.readFieldBegin()
17298 
      if ftype == TType.STOP:
17299 
        break
17300 
      else:
17301 
        iprot.skip(ftype)
17302 
      iprot.readFieldEnd()
17303 
    iprot.readStructEnd()
17304 
 
17305 
  def write(self, oprot):
17306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17308 
      return
17309 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17310 
    oprot.writeFieldStop()
17311 
    oprot.writeStructEnd()
17312 
 
17313 
  def validate(self):
17314 
    return
17315 
 
17316 
 
17317 
  def __repr__(self):
17318 
    L = ['%s=%r' % (key, value)
17319 
      for key, value in self.__dict__.iteritems()]
17320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17321 
 
17322 
  def __eq__(self, other):
17323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17324 
 
17325 
  def __ne__(self, other):
17326 
    return not (self == other)
17327 
 
17328 
class getAllFbaListedItems_result:
17329 
  """
17330 
  Attributes:
17331 
   - success
17332 
  """
17333 
 
17334 
  thrift_spec = (
17335 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17336 
  )
17337 
 
17338 
  def __init__(self, success=None,):
17339 
    self.success = success
17340 
 
17341 
  def read(self, iprot):
17342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17344 
      return
17345 
    iprot.readStructBegin()
17346 
    while True:
17347 
      (fname, ftype, fid) = iprot.readFieldBegin()
17348 
      if ftype == TType.STOP:
17349 
        break
17350 
      if fid == 0:
17351 
        if ftype == TType.LIST:
17352 
          self.success = []
7306 rajveer 17353 
          (_etype338, _size335) = iprot.readListBegin()
17354 
          for _i339 in xrange(_size335):
17355 
            _elem340 = Amazonlisted()
17356 
            _elem340.read(iprot)
17357 
            self.success.append(_elem340)
7291 vikram.rag 17358 
          iprot.readListEnd()
17359 
        else:
17360 
          iprot.skip(ftype)
17361 
      else:
17362 
        iprot.skip(ftype)
17363 
      iprot.readFieldEnd()
17364 
    iprot.readStructEnd()
17365 
 
17366 
  def write(self, oprot):
17367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17369 
      return
17370 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17371 
    if self.success is not None:
17372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17374 
      for iter341 in self.success:
17375 
        iter341.write(oprot)
7291 vikram.rag 17376 
      oprot.writeListEnd()
17377 
      oprot.writeFieldEnd()
17378 
    oprot.writeFieldStop()
17379 
    oprot.writeStructEnd()
17380 
 
17381 
  def validate(self):
17382 
    return
17383 
 
17384 
 
17385 
  def __repr__(self):
17386 
    L = ['%s=%r' % (key, value)
17387 
      for key, value in self.__dict__.iteritems()]
17388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17389 
 
17390 
  def __eq__(self, other):
17391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17392 
 
17393 
  def __ne__(self, other):
17394 
    return not (self == other)
17395 
 
17396 
class getAllNonFbaListedItems_args:
17397 
 
17398 
  thrift_spec = (
17399 
  )
17400 
 
17401 
  def read(self, iprot):
17402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17404 
      return
17405 
    iprot.readStructBegin()
17406 
    while True:
17407 
      (fname, ftype, fid) = iprot.readFieldBegin()
17408 
      if ftype == TType.STOP:
17409 
        break
17410 
      else:
17411 
        iprot.skip(ftype)
17412 
      iprot.readFieldEnd()
17413 
    iprot.readStructEnd()
17414 
 
17415 
  def write(self, oprot):
17416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17418 
      return
17419 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17420 
    oprot.writeFieldStop()
17421 
    oprot.writeStructEnd()
17422 
 
17423 
  def validate(self):
17424 
    return
17425 
 
17426 
 
17427 
  def __repr__(self):
17428 
    L = ['%s=%r' % (key, value)
17429 
      for key, value in self.__dict__.iteritems()]
17430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17431 
 
17432 
  def __eq__(self, other):
17433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17434 
 
17435 
  def __ne__(self, other):
17436 
    return not (self == other)
17437 
 
17438 
class getAllNonFbaListedItems_result:
17439 
  """
17440 
  Attributes:
17441 
   - success
17442 
  """
17443 
 
17444 
  thrift_spec = (
17445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17446 
  )
17447 
 
17448 
  def __init__(self, success=None,):
17449 
    self.success = success
17450 
 
17451 
  def read(self, iprot):
17452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17454 
      return
17455 
    iprot.readStructBegin()
17456 
    while True:
17457 
      (fname, ftype, fid) = iprot.readFieldBegin()
17458 
      if ftype == TType.STOP:
17459 
        break
17460 
      if fid == 0:
17461 
        if ftype == TType.LIST:
17462 
          self.success = []
7306 rajveer 17463 
          (_etype345, _size342) = iprot.readListBegin()
17464 
          for _i346 in xrange(_size342):
17465 
            _elem347 = Amazonlisted()
17466 
            _elem347.read(iprot)
17467 
            self.success.append(_elem347)
7291 vikram.rag 17468 
          iprot.readListEnd()
17469 
        else:
17470 
          iprot.skip(ftype)
17471 
      else:
17472 
        iprot.skip(ftype)
17473 
      iprot.readFieldEnd()
17474 
    iprot.readStructEnd()
17475 
 
17476 
  def write(self, oprot):
17477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17479 
      return
17480 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17481 
    if self.success is not None:
17482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17484 
      for iter348 in self.success:
17485 
        iter348.write(oprot)
7291 vikram.rag 17486 
      oprot.writeListEnd()
17487 
      oprot.writeFieldEnd()
17488 
    oprot.writeFieldStop()
17489 
    oprot.writeStructEnd()
17490 
 
17491 
  def validate(self):
17492 
    return
17493 
 
17494 
 
17495 
  def __repr__(self):
17496 
    L = ['%s=%r' % (key, value)
17497 
      for key, value in self.__dict__.iteritems()]
17498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17499 
 
17500 
  def __eq__(self, other):
17501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17502 
 
17503 
  def __ne__(self, other):
17504 
    return not (self == other)