Subversion Repositories SmartDukaan

Rev

Rev 7367 | Rev 7438 | 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 
 
7330 amit.gupta 598 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 599 
    """
600 
    Parameters:
601 
     - itemId
7330 amit.gupta 602 
     - stateId
6039 amit.gupta 603 
     - price
604 
    """
605 
    pass
5944 mandeep.dh 606 
 
6039 amit.gupta 607 
  def getVatAmountForItem(self, itemId, price):
608 
    """
609 
    Parameters:
610 
     - itemId
611 
     - price
612 
    """
613 
    pass
614 
 
6531 vikram.rag 615 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
616 
    """
617 
    Parameters:
618 
     - offset
619 
     - limit
620 
    """
621 
    pass
6039 amit.gupta 622 
 
6821 amar.kumar 623 
  def getAllAliveItems(self, ):
624 
    pass
625 
 
6921 anupam.sin 626 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 627 
    """
628 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 629 
 
6805 anupam.sin 630 
    Parameters:
631 
     - itemId
6921 anupam.sin 632 
     - price
6805 anupam.sin 633 
     - insurerId
634 
     - quantity
635 
    """
636 
    pass
637 
 
638 
  def getInsurer(self, insurerId):
639 
    """
640 
    Parameters:
641 
     - insurerId
642 
    """
643 
    pass
644 
 
6838 vikram.rag 645 
  def getAllInsurers(self, ):
646 
    pass
6805 anupam.sin 647 
 
6962 rajveer 648 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
649 
    """
650 
    Parameters:
651 
     - insurerId
652 
     - amount
653 
    """
654 
    pass
6838 vikram.rag 655 
 
7190 amar.kumar 656 
  def getFreebieForItem(self, itemId):
657 
    """
658 
    Parameters:
659 
     - itemId
660 
    """
661 
    pass
6962 rajveer 662 
 
7190 amar.kumar 663 
  def addOrUpdateFreebieForItem(self, freebieItem):
664 
    """
665 
    Parameters:
666 
     - freebieItem
667 
    """
668 
    pass
669 
 
7272 amit.gupta 670 
  def addOrUpdateBrandInfo(self, brandInfo):
671 
    """
672 
    Parameters:
673 
     - brandInfo
674 
    """
675 
    pass
676 
 
677 
  def getBrandInfo(self, ):
678 
    pass
679 
 
7256 rajveer 680 
  def getStorePricing(self, itemId):
681 
    """
682 
    Parameters:
683 
     - itemId
684 
    """
685 
    pass
7190 amar.kumar 686 
 
7306 rajveer 687 
  def getStorePricings(self, itemIds):
688 
    """
689 
    Parameters:
690 
     - itemIds
691 
    """
692 
    pass
693 
 
7382 rajveer 694 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 695 
    """
696 
    Parameters:
697 
     - sp
7382 rajveer 698 
     - allColors
7265 rajveer 699 
    """
700 
    pass
7256 rajveer 701 
 
7281 kshitij.so 702 
  def getAllAmazonListedItems(self, ):
703 
    pass
7265 rajveer 704 
 
7281 kshitij.so 705 
  def getAmazonItemDetails(self, itemId):
706 
    """
707 
    Parameters:
708 
     - itemId
709 
    """
710 
    pass
711 
 
7367 kshitij.so 712 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 713 
    """
714 
    Parameters:
715 
     - itemId
716 
     - fbaPrice
717 
     - sellingPrice
718 
     - isFba
719 
     - isNonFba
720 
     - isInventoryOverride
7367 kshitij.so 721 
     - handlingTime
722 
     - isCustomTime
7281 kshitij.so 723 
    """
724 
    pass
725 
 
726 
  def addAmazonItem(self, amazonlisted):
727 
    """
728 
    Parameters:
729 
     - amazonlisted
730 
    """
731 
    pass
732 
 
7291 vikram.rag 733 
  def getAsinItems(self, ):
734 
    pass
7281 kshitij.so 735 
 
7291 vikram.rag 736 
  def getAllFbaListedItems(self, ):
737 
    pass
738 
 
739 
  def getAllNonFbaListedItems(self, ):
740 
    pass
741 
 
742 
 
5944 mandeep.dh 743 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
744 
  def __init__(self, iprot, oprot=None):
745 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
746 
 
747 
  def addItem(self, item):
748 
    """
749 
    Availability and inventory attributes
750 
 
751 
    Parameters:
752 
     - item
753 
    """
754 
    self.send_addItem(item)
755 
    return self.recv_addItem()
756 
 
757 
  def send_addItem(self, item):
758 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
759 
    args = addItem_args()
760 
    args.item = item
761 
    args.write(self._oprot)
762 
    self._oprot.writeMessageEnd()
763 
    self._oprot.trans.flush()
764 
 
765 
  def recv_addItem(self, ):
766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
767 
    if mtype == TMessageType.EXCEPTION:
768 
      x = TApplicationException()
769 
      x.read(self._iprot)
770 
      self._iprot.readMessageEnd()
771 
      raise x
772 
    result = addItem_result()
773 
    result.read(self._iprot)
774 
    self._iprot.readMessageEnd()
775 
    if result.success is not None:
776 
      return result.success
777 
    if result.cex is not None:
778 
      raise result.cex
779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
780 
 
781 
  def updateItem(self, item):
782 
    """
783 
    Parameters:
784 
     - item
785 
    """
786 
    self.send_updateItem(item)
787 
    return self.recv_updateItem()
788 
 
789 
  def send_updateItem(self, item):
790 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
791 
    args = updateItem_args()
792 
    args.item = item
793 
    args.write(self._oprot)
794 
    self._oprot.writeMessageEnd()
795 
    self._oprot.trans.flush()
796 
 
797 
  def recv_updateItem(self, ):
798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
799 
    if mtype == TMessageType.EXCEPTION:
800 
      x = TApplicationException()
801 
      x.read(self._iprot)
802 
      self._iprot.readMessageEnd()
803 
      raise x
804 
    result = updateItem_result()
805 
    result.read(self._iprot)
806 
    self._iprot.readMessageEnd()
807 
    if result.success is not None:
808 
      return result.success
809 
    if result.cex is not None:
810 
      raise result.cex
811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
812 
 
813 
  def isActive(self, itemId):
814 
    """
815 
    Checks if the item given to the corresponding itemId is active. If it's active,
816 
    whether it's risky and if it's risky, its inventory position.
817 
 
818 
    Parameters:
819 
     - itemId
820 
    """
821 
    self.send_isActive(itemId)
822 
    return self.recv_isActive()
823 
 
824 
  def send_isActive(self, itemId):
825 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
826 
    args = isActive_args()
827 
    args.itemId = itemId
828 
    args.write(self._oprot)
829 
    self._oprot.writeMessageEnd()
830 
    self._oprot.trans.flush()
831 
 
832 
  def recv_isActive(self, ):
833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
834 
    if mtype == TMessageType.EXCEPTION:
835 
      x = TApplicationException()
836 
      x.read(self._iprot)
837 
      self._iprot.readMessageEnd()
838 
      raise x
839 
    result = isActive_result()
840 
    result.read(self._iprot)
841 
    self._iprot.readMessageEnd()
842 
    if result.success is not None:
843 
      return result.success
844 
    if result.isex is not None:
845 
      raise result.isex
846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
847 
 
848 
  def getItemStatusDescription(self, itemId):
849 
    """
850 
    Parameters:
851 
     - itemId
852 
    """
853 
    self.send_getItemStatusDescription(itemId)
854 
    return self.recv_getItemStatusDescription()
855 
 
856 
  def send_getItemStatusDescription(self, itemId):
857 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
858 
    args = getItemStatusDescription_args()
859 
    args.itemId = itemId
860 
    args.write(self._oprot)
861 
    self._oprot.writeMessageEnd()
862 
    self._oprot.trans.flush()
863 
 
864 
  def recv_getItemStatusDescription(self, ):
865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
866 
    if mtype == TMessageType.EXCEPTION:
867 
      x = TApplicationException()
868 
      x.read(self._iprot)
869 
      self._iprot.readMessageEnd()
870 
      raise x
871 
    result = getItemStatusDescription_result()
872 
    result.read(self._iprot)
873 
    self._iprot.readMessageEnd()
874 
    if result.success is not None:
875 
      return result.success
876 
    if result.isex is not None:
877 
      raise result.isex
878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
879 
 
880 
  def startItemOn(self, item_id, timestamp):
881 
    """
882 
    Parameters:
883 
     - item_id
884 
     - timestamp
885 
    """
886 
    self.send_startItemOn(item_id, timestamp)
887 
    self.recv_startItemOn()
888 
 
889 
  def send_startItemOn(self, item_id, timestamp):
890 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
891 
    args = startItemOn_args()
892 
    args.item_id = item_id
893 
    args.timestamp = timestamp
894 
    args.write(self._oprot)
895 
    self._oprot.writeMessageEnd()
896 
    self._oprot.trans.flush()
897 
 
898 
  def recv_startItemOn(self, ):
899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
900 
    if mtype == TMessageType.EXCEPTION:
901 
      x = TApplicationException()
902 
      x.read(self._iprot)
903 
      self._iprot.readMessageEnd()
904 
      raise x
905 
    result = startItemOn_result()
906 
    result.read(self._iprot)
907 
    self._iprot.readMessageEnd()
908 
    if result.cex is not None:
909 
      raise result.cex
910 
    return
911 
 
912 
  def retireItemOn(self, item_id, timestamp):
913 
    """
914 
    Parameters:
915 
     - item_id
916 
     - timestamp
917 
    """
918 
    self.send_retireItemOn(item_id, timestamp)
919 
    self.recv_retireItemOn()
920 
 
921 
  def send_retireItemOn(self, item_id, timestamp):
922 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
923 
    args = retireItemOn_args()
924 
    args.item_id = item_id
925 
    args.timestamp = timestamp
926 
    args.write(self._oprot)
927 
    self._oprot.writeMessageEnd()
928 
    self._oprot.trans.flush()
929 
 
930 
  def recv_retireItemOn(self, ):
931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
932 
    if mtype == TMessageType.EXCEPTION:
933 
      x = TApplicationException()
934 
      x.read(self._iprot)
935 
      self._iprot.readMessageEnd()
936 
      raise x
937 
    result = retireItemOn_result()
938 
    result.read(self._iprot)
939 
    self._iprot.readMessageEnd()
940 
    if result.cex is not None:
941 
      raise result.cex
942 
    return
943 
 
944 
  def changeItemStatus(self, item_id, timestamp, newstatus):
945 
    """
946 
    Parameters:
947 
     - item_id
948 
     - timestamp
949 
     - newstatus
950 
    """
951 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
952 
    self.recv_changeItemStatus()
953 
 
954 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
955 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
956 
    args = changeItemStatus_args()
957 
    args.item_id = item_id
958 
    args.timestamp = timestamp
959 
    args.newstatus = newstatus
960 
    args.write(self._oprot)
961 
    self._oprot.writeMessageEnd()
962 
    self._oprot.trans.flush()
963 
 
964 
  def recv_changeItemStatus(self, ):
965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
966 
    if mtype == TMessageType.EXCEPTION:
967 
      x = TApplicationException()
968 
      x.read(self._iprot)
969 
      self._iprot.readMessageEnd()
970 
      raise x
971 
    result = changeItemStatus_result()
972 
    result.read(self._iprot)
973 
    self._iprot.readMessageEnd()
974 
    if result.cex is not None:
975 
      raise result.cex
976 
    return
977 
 
978 
  def getItem(self, item_id):
979 
    """
980 
    Parameters:
981 
     - item_id
982 
    """
983 
    self.send_getItem(item_id)
984 
    return self.recv_getItem()
985 
 
986 
  def send_getItem(self, item_id):
987 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
988 
    args = getItem_args()
989 
    args.item_id = item_id
990 
    args.write(self._oprot)
991 
    self._oprot.writeMessageEnd()
992 
    self._oprot.trans.flush()
993 
 
994 
  def recv_getItem(self, ):
995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
996 
    if mtype == TMessageType.EXCEPTION:
997 
      x = TApplicationException()
998 
      x.read(self._iprot)
999 
      self._iprot.readMessageEnd()
1000 
      raise x
1001 
    result = getItem_result()
1002 
    result.read(self._iprot)
1003 
    self._iprot.readMessageEnd()
1004 
    if result.success is not None:
1005 
      return result.success
1006 
    if result.cex is not None:
1007 
      raise result.cex
1008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1009 
 
1010 
  def getItemsByCatalogId(self, catalog_item_id):
1011 
    """
1012 
    Parameters:
1013 
     - catalog_item_id
1014 
    """
1015 
    self.send_getItemsByCatalogId(catalog_item_id)
1016 
    return self.recv_getItemsByCatalogId()
1017 
 
1018 
  def send_getItemsByCatalogId(self, catalog_item_id):
1019 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1020 
    args = getItemsByCatalogId_args()
1021 
    args.catalog_item_id = catalog_item_id
1022 
    args.write(self._oprot)
1023 
    self._oprot.writeMessageEnd()
1024 
    self._oprot.trans.flush()
1025 
 
1026 
  def recv_getItemsByCatalogId(self, ):
1027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1028 
    if mtype == TMessageType.EXCEPTION:
1029 
      x = TApplicationException()
1030 
      x.read(self._iprot)
1031 
      self._iprot.readMessageEnd()
1032 
      raise x
1033 
    result = getItemsByCatalogId_result()
1034 
    result.read(self._iprot)
1035 
    self._iprot.readMessageEnd()
1036 
    if result.success is not None:
1037 
      return result.success
1038 
    if result.cex is not None:
1039 
      raise result.cex
1040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1041 
 
1042 
  def getValidItemsByCatalogId(self, catalog_item_id):
1043 
    """
1044 
    Parameters:
1045 
     - catalog_item_id
1046 
    """
1047 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1048 
    return self.recv_getValidItemsByCatalogId()
1049 
 
1050 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1051 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1052 
    args = getValidItemsByCatalogId_args()
1053 
    args.catalog_item_id = catalog_item_id
1054 
    args.write(self._oprot)
1055 
    self._oprot.writeMessageEnd()
1056 
    self._oprot.trans.flush()
1057 
 
1058 
  def recv_getValidItemsByCatalogId(self, ):
1059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1060 
    if mtype == TMessageType.EXCEPTION:
1061 
      x = TApplicationException()
1062 
      x.read(self._iprot)
1063 
      self._iprot.readMessageEnd()
1064 
      raise x
1065 
    result = getValidItemsByCatalogId_result()
1066 
    result.read(self._iprot)
1067 
    self._iprot.readMessageEnd()
1068 
    if result.success is not None:
1069 
      return result.success
1070 
    if result.cex is not None:
1071 
      raise result.cex
1072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1073 
 
1074 
  def getAllItems(self, isActive):
1075 
    """
1076 
    Parameters:
1077 
     - isActive
1078 
    """
1079 
    self.send_getAllItems(isActive)
1080 
    return self.recv_getAllItems()
1081 
 
1082 
  def send_getAllItems(self, isActive):
1083 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1084 
    args = getAllItems_args()
1085 
    args.isActive = isActive
1086 
    args.write(self._oprot)
1087 
    self._oprot.writeMessageEnd()
1088 
    self._oprot.trans.flush()
1089 
 
1090 
  def recv_getAllItems(self, ):
1091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1092 
    if mtype == TMessageType.EXCEPTION:
1093 
      x = TApplicationException()
1094 
      x.read(self._iprot)
1095 
      self._iprot.readMessageEnd()
1096 
      raise x
1097 
    result = getAllItems_result()
1098 
    result.read(self._iprot)
1099 
    self._iprot.readMessageEnd()
1100 
    if result.success is not None:
1101 
      return result.success
1102 
    if result.cex is not None:
1103 
      raise result.cex
1104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1105 
 
1106 
  def getAllItemsByStatus(self, itemStatus):
1107 
    """
1108 
    Parameters:
1109 
     - itemStatus
1110 
    """
1111 
    self.send_getAllItemsByStatus(itemStatus)
1112 
    return self.recv_getAllItemsByStatus()
1113 
 
1114 
  def send_getAllItemsByStatus(self, itemStatus):
1115 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1116 
    args = getAllItemsByStatus_args()
1117 
    args.itemStatus = itemStatus
1118 
    args.write(self._oprot)
1119 
    self._oprot.writeMessageEnd()
1120 
    self._oprot.trans.flush()
1121 
 
1122 
  def recv_getAllItemsByStatus(self, ):
1123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1124 
    if mtype == TMessageType.EXCEPTION:
1125 
      x = TApplicationException()
1126 
      x.read(self._iprot)
1127 
      self._iprot.readMessageEnd()
1128 
      raise x
1129 
    result = getAllItemsByStatus_result()
1130 
    result.read(self._iprot)
1131 
    self._iprot.readMessageEnd()
1132 
    if result.success is not None:
1133 
      return result.success
1134 
    if result.cex is not None:
1135 
      raise result.cex
1136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1137 
 
1138 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1139 
    """
1140 
    Parameters:
1141 
     - entityId
1142 
     - category
1143 
     - brand
1144 
     - modelName
1145 
     - modelNumber
1146 
    """
1147 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1148 
    return self.recv_markItemAsContentComplete()
1149 
 
1150 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1151 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1152 
    args = markItemAsContentComplete_args()
1153 
    args.entityId = entityId
1154 
    args.category = category
1155 
    args.brand = brand
1156 
    args.modelName = modelName
1157 
    args.modelNumber = modelNumber
1158 
    args.write(self._oprot)
1159 
    self._oprot.writeMessageEnd()
1160 
    self._oprot.trans.flush()
1161 
 
1162 
  def recv_markItemAsContentComplete(self, ):
1163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1164 
    if mtype == TMessageType.EXCEPTION:
1165 
      x = TApplicationException()
1166 
      x.read(self._iprot)
1167 
      self._iprot.readMessageEnd()
1168 
      raise x
1169 
    result = markItemAsContentComplete_result()
1170 
    result.read(self._iprot)
1171 
    self._iprot.readMessageEnd()
1172 
    if result.success is not None:
1173 
      return result.success
1174 
    if result.cex is not None:
1175 
      raise result.cex
1176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1177 
 
1178 
  def getAllItemsInRange(self, offset, limit):
1179 
    """
1180 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1181 
 
1182 
    Parameters:
1183 
     - offset
1184 
     - limit
1185 
    """
1186 
    self.send_getAllItemsInRange(offset, limit)
1187 
    return self.recv_getAllItemsInRange()
1188 
 
1189 
  def send_getAllItemsInRange(self, offset, limit):
1190 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1191 
    args = getAllItemsInRange_args()
1192 
    args.offset = offset
1193 
    args.limit = limit
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_getAllItemsInRange(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = getAllItemsInRange_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
1208 
    if result.success is not None:
1209 
      return result.success
1210 
    if result.cex is not None:
1211 
      raise result.cex
1212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1213 
 
1214 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1215 
    """
1216 
    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.
1217 
 
1218 
    Parameters:
1219 
     - itemStatus
1220 
     - offset
1221 
     - limit
1222 
    """
1223 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1224 
    return self.recv_getAllItemsByStatusInRange()
1225 
 
1226 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1227 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1228 
    args = getAllItemsByStatusInRange_args()
1229 
    args.itemStatus = itemStatus
1230 
    args.offset = offset
1231 
    args.limit = limit
1232 
    args.write(self._oprot)
1233 
    self._oprot.writeMessageEnd()
1234 
    self._oprot.trans.flush()
1235 
 
1236 
  def recv_getAllItemsByStatusInRange(self, ):
1237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1238 
    if mtype == TMessageType.EXCEPTION:
1239 
      x = TApplicationException()
1240 
      x.read(self._iprot)
1241 
      self._iprot.readMessageEnd()
1242 
      raise x
1243 
    result = getAllItemsByStatusInRange_result()
1244 
    result.read(self._iprot)
1245 
    self._iprot.readMessageEnd()
1246 
    if result.success is not None:
1247 
      return result.success
1248 
    if result.cex is not None:
1249 
      raise result.cex
1250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1251 
 
1252 
  def getItemCountByStatus(self, useStatus, itemStatus):
1253 
    """
1254 
    Gets a count of all items by status
1255 
 
1256 
    Parameters:
1257 
     - useStatus
1258 
     - itemStatus
1259 
    """
1260 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1261 
    return self.recv_getItemCountByStatus()
1262 
 
1263 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1264 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1265 
    args = getItemCountByStatus_args()
1266 
    args.useStatus = useStatus
1267 
    args.itemStatus = itemStatus
1268 
    args.write(self._oprot)
1269 
    self._oprot.writeMessageEnd()
1270 
    self._oprot.trans.flush()
1271 
 
1272 
  def recv_getItemCountByStatus(self, ):
1273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1274 
    if mtype == TMessageType.EXCEPTION:
1275 
      x = TApplicationException()
1276 
      x.read(self._iprot)
1277 
      self._iprot.readMessageEnd()
1278 
      raise x
1279 
    result = getItemCountByStatus_result()
1280 
    result.read(self._iprot)
1281 
    self._iprot.readMessageEnd()
1282 
    if result.success is not None:
1283 
      return result.success
1284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1285 
 
1286 
  def getBestSellers(self, ):
1287 
    self.send_getBestSellers()
1288 
    return self.recv_getBestSellers()
1289 
 
1290 
  def send_getBestSellers(self, ):
1291 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1292 
    args = getBestSellers_args()
1293 
    args.write(self._oprot)
1294 
    self._oprot.writeMessageEnd()
1295 
    self._oprot.trans.flush()
1296 
 
1297 
  def recv_getBestSellers(self, ):
1298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1299 
    if mtype == TMessageType.EXCEPTION:
1300 
      x = TApplicationException()
1301 
      x.read(self._iprot)
1302 
      self._iprot.readMessageEnd()
1303 
      raise x
1304 
    result = getBestSellers_result()
1305 
    result.read(self._iprot)
1306 
    self._iprot.readMessageEnd()
1307 
    if result.success is not None:
1308 
      return result.success
1309 
    if result.isex is not None:
1310 
      raise result.isex
1311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1312 
 
1313 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1314 
    """
1315 
    Parameters:
1316 
     - beginIndex
1317 
     - totalItems
1318 
     - brand
1319 
     - category
1320 
    """
1321 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1322 
    return self.recv_getBestSellersCatalogIds()
1323 
 
1324 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1325 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1326 
    args = getBestSellersCatalogIds_args()
1327 
    args.beginIndex = beginIndex
1328 
    args.totalItems = totalItems
1329 
    args.brand = brand
1330 
    args.category = category
1331 
    args.write(self._oprot)
1332 
    self._oprot.writeMessageEnd()
1333 
    self._oprot.trans.flush()
1334 
 
1335 
  def recv_getBestSellersCatalogIds(self, ):
1336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1337 
    if mtype == TMessageType.EXCEPTION:
1338 
      x = TApplicationException()
1339 
      x.read(self._iprot)
1340 
      self._iprot.readMessageEnd()
1341 
      raise x
1342 
    result = getBestSellersCatalogIds_result()
1343 
    result.read(self._iprot)
1344 
    self._iprot.readMessageEnd()
1345 
    if result.success is not None:
1346 
      return result.success
1347 
    if result.cex is not None:
1348 
      raise result.cex
1349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1350 
 
1351 
  def getBestSellersCount(self, ):
1352 
    self.send_getBestSellersCount()
1353 
    return self.recv_getBestSellersCount()
1354 
 
1355 
  def send_getBestSellersCount(self, ):
1356 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1357 
    args = getBestSellersCount_args()
1358 
    args.write(self._oprot)
1359 
    self._oprot.writeMessageEnd()
1360 
    self._oprot.trans.flush()
1361 
 
1362 
  def recv_getBestSellersCount(self, ):
1363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1364 
    if mtype == TMessageType.EXCEPTION:
1365 
      x = TApplicationException()
1366 
      x.read(self._iprot)
1367 
      self._iprot.readMessageEnd()
1368 
      raise x
1369 
    result = getBestSellersCount_result()
1370 
    result.read(self._iprot)
1371 
    self._iprot.readMessageEnd()
1372 
    if result.success is not None:
1373 
      return result.success
1374 
    if result.cex is not None:
1375 
      raise result.cex
1376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1377 
 
1378 
  def getBestDeals(self, ):
1379 
    self.send_getBestDeals()
1380 
    return self.recv_getBestDeals()
1381 
 
1382 
  def send_getBestDeals(self, ):
1383 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1384 
    args = getBestDeals_args()
1385 
    args.write(self._oprot)
1386 
    self._oprot.writeMessageEnd()
1387 
    self._oprot.trans.flush()
1388 
 
1389 
  def recv_getBestDeals(self, ):
1390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1391 
    if mtype == TMessageType.EXCEPTION:
1392 
      x = TApplicationException()
1393 
      x.read(self._iprot)
1394 
      self._iprot.readMessageEnd()
1395 
      raise x
1396 
    result = getBestDeals_result()
1397 
    result.read(self._iprot)
1398 
    self._iprot.readMessageEnd()
1399 
    if result.success is not None:
1400 
      return result.success
1401 
    if result.isex is not None:
1402 
      raise result.isex
1403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1404 
 
1405 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1406 
    """
1407 
    Parameters:
1408 
     - beginIndex
1409 
     - totalItems
1410 
     - brand
1411 
     - category
1412 
    """
1413 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1414 
    return self.recv_getBestDealsCatalogIds()
1415 
 
1416 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1417 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1418 
    args = getBestDealsCatalogIds_args()
1419 
    args.beginIndex = beginIndex
1420 
    args.totalItems = totalItems
1421 
    args.brand = brand
1422 
    args.category = category
1423 
    args.write(self._oprot)
1424 
    self._oprot.writeMessageEnd()
1425 
    self._oprot.trans.flush()
1426 
 
1427 
  def recv_getBestDealsCatalogIds(self, ):
1428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1429 
    if mtype == TMessageType.EXCEPTION:
1430 
      x = TApplicationException()
1431 
      x.read(self._iprot)
1432 
      self._iprot.readMessageEnd()
1433 
      raise x
1434 
    result = getBestDealsCatalogIds_result()
1435 
    result.read(self._iprot)
1436 
    self._iprot.readMessageEnd()
1437 
    if result.success is not None:
1438 
      return result.success
1439 
    if result.cex is not None:
1440 
      raise result.cex
1441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1442 
 
1443 
  def getBestDealsCount(self, ):
1444 
    self.send_getBestDealsCount()
1445 
    return self.recv_getBestDealsCount()
1446 
 
1447 
  def send_getBestDealsCount(self, ):
1448 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1449 
    args = getBestDealsCount_args()
1450 
    args.write(self._oprot)
1451 
    self._oprot.writeMessageEnd()
1452 
    self._oprot.trans.flush()
1453 
 
1454 
  def recv_getBestDealsCount(self, ):
1455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1456 
    if mtype == TMessageType.EXCEPTION:
1457 
      x = TApplicationException()
1458 
      x.read(self._iprot)
1459 
      self._iprot.readMessageEnd()
1460 
      raise x
1461 
    result = getBestDealsCount_result()
1462 
    result.read(self._iprot)
1463 
    self._iprot.readMessageEnd()
1464 
    if result.success is not None:
1465 
      return result.success
1466 
    if result.cex is not None:
1467 
      raise result.cex
1468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1469 
 
1470 
  def getComingSoon(self, ):
1471 
    self.send_getComingSoon()
1472 
    return self.recv_getComingSoon()
1473 
 
1474 
  def send_getComingSoon(self, ):
1475 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1476 
    args = getComingSoon_args()
1477 
    args.write(self._oprot)
1478 
    self._oprot.writeMessageEnd()
1479 
    self._oprot.trans.flush()
1480 
 
1481 
  def recv_getComingSoon(self, ):
1482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1483 
    if mtype == TMessageType.EXCEPTION:
1484 
      x = TApplicationException()
1485 
      x.read(self._iprot)
1486 
      self._iprot.readMessageEnd()
1487 
      raise x
1488 
    result = getComingSoon_result()
1489 
    result.read(self._iprot)
1490 
    self._iprot.readMessageEnd()
1491 
    if result.success is not None:
1492 
      return result.success
1493 
    if result.isex is not None:
1494 
      raise result.isex
1495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1496 
 
1497 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1498 
    """
1499 
    Parameters:
1500 
     - beginIndex
1501 
     - totalItems
1502 
     - brand
1503 
     - category
1504 
    """
1505 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1506 
    return self.recv_getComingSoonCatalogIds()
1507 
 
1508 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1509 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1510 
    args = getComingSoonCatalogIds_args()
1511 
    args.beginIndex = beginIndex
1512 
    args.totalItems = totalItems
1513 
    args.brand = brand
1514 
    args.category = category
1515 
    args.write(self._oprot)
1516 
    self._oprot.writeMessageEnd()
1517 
    self._oprot.trans.flush()
1518 
 
1519 
  def recv_getComingSoonCatalogIds(self, ):
1520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1521 
    if mtype == TMessageType.EXCEPTION:
1522 
      x = TApplicationException()
1523 
      x.read(self._iprot)
1524 
      self._iprot.readMessageEnd()
1525 
      raise x
1526 
    result = getComingSoonCatalogIds_result()
1527 
    result.read(self._iprot)
1528 
    self._iprot.readMessageEnd()
1529 
    if result.success is not None:
1530 
      return result.success
1531 
    if result.cex is not None:
1532 
      raise result.cex
1533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1534 
 
1535 
  def getComingSoonCount(self, ):
1536 
    self.send_getComingSoonCount()
1537 
    return self.recv_getComingSoonCount()
1538 
 
1539 
  def send_getComingSoonCount(self, ):
1540 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1541 
    args = getComingSoonCount_args()
1542 
    args.write(self._oprot)
1543 
    self._oprot.writeMessageEnd()
1544 
    self._oprot.trans.flush()
1545 
 
1546 
  def recv_getComingSoonCount(self, ):
1547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1548 
    if mtype == TMessageType.EXCEPTION:
1549 
      x = TApplicationException()
1550 
      x.read(self._iprot)
1551 
      self._iprot.readMessageEnd()
1552 
      raise x
1553 
    result = getComingSoonCount_result()
1554 
    result.read(self._iprot)
1555 
    self._iprot.readMessageEnd()
1556 
    if result.success is not None:
1557 
      return result.success
1558 
    if result.cex is not None:
1559 
      raise result.cex
1560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1561 
 
1562 
  def getLatestArrivals(self, ):
1563 
    """
1564 
    Returns a list of items sorted in the descending order by start date.
1565 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1566 
    """
1567 
    self.send_getLatestArrivals()
1568 
    return self.recv_getLatestArrivals()
1569 
 
1570 
  def send_getLatestArrivals(self, ):
1571 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1572 
    args = getLatestArrivals_args()
1573 
    args.write(self._oprot)
1574 
    self._oprot.writeMessageEnd()
1575 
    self._oprot.trans.flush()
1576 
 
1577 
  def recv_getLatestArrivals(self, ):
1578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1579 
    if mtype == TMessageType.EXCEPTION:
1580 
      x = TApplicationException()
1581 
      x.read(self._iprot)
1582 
      self._iprot.readMessageEnd()
1583 
      raise x
1584 
    result = getLatestArrivals_result()
1585 
    result.read(self._iprot)
1586 
    self._iprot.readMessageEnd()
1587 
    if result.success is not None:
1588 
      return result.success
1589 
    if result.isex is not None:
1590 
      raise result.isex
1591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1592 
 
1593 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1594 
    """
1595 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1596 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1597 
 
1598 
    Parameters:
1599 
     - beginIndex
1600 
     - totalItems
1601 
     - brand
1602 
     - categories
1603 
    """
1604 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1605 
    return self.recv_getLatestArrivalsCatalogIds()
1606 
 
1607 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1608 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1609 
    args = getLatestArrivalsCatalogIds_args()
1610 
    args.beginIndex = beginIndex
1611 
    args.totalItems = totalItems
1612 
    args.brand = brand
1613 
    args.categories = categories
1614 
    args.write(self._oprot)
1615 
    self._oprot.writeMessageEnd()
1616 
    self._oprot.trans.flush()
1617 
 
1618 
  def recv_getLatestArrivalsCatalogIds(self, ):
1619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1620 
    if mtype == TMessageType.EXCEPTION:
1621 
      x = TApplicationException()
1622 
      x.read(self._iprot)
1623 
      self._iprot.readMessageEnd()
1624 
      raise x
1625 
    result = getLatestArrivalsCatalogIds_result()
1626 
    result.read(self._iprot)
1627 
    self._iprot.readMessageEnd()
1628 
    if result.success is not None:
1629 
      return result.success
1630 
    if result.cex is not None:
1631 
      raise result.cex
1632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1633 
 
1634 
  def getLatestArrivalsCount(self, ):
1635 
    """
1636 
    Get the total number of latest arrivals we are willing to show.
1637 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1638 
    """
1639 
    self.send_getLatestArrivalsCount()
1640 
    return self.recv_getLatestArrivalsCount()
1641 
 
1642 
  def send_getLatestArrivalsCount(self, ):
1643 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1644 
    args = getLatestArrivalsCount_args()
1645 
    args.write(self._oprot)
1646 
    self._oprot.writeMessageEnd()
1647 
    self._oprot.trans.flush()
1648 
 
1649 
  def recv_getLatestArrivalsCount(self, ):
1650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1651 
    if mtype == TMessageType.EXCEPTION:
1652 
      x = TApplicationException()
1653 
      x.read(self._iprot)
1654 
      self._iprot.readMessageEnd()
1655 
      raise x
1656 
    result = getLatestArrivalsCount_result()
1657 
    result.read(self._iprot)
1658 
    self._iprot.readMessageEnd()
1659 
    if result.success is not None:
1660 
      return result.success
1661 
    if result.cex is not None:
1662 
      raise result.cex
1663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1664 
 
1665 
  def generateNewEntityID(self, ):
1666 
    self.send_generateNewEntityID()
1667 
    return self.recv_generateNewEntityID()
1668 
 
1669 
  def send_generateNewEntityID(self, ):
1670 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1671 
    args = generateNewEntityID_args()
1672 
    args.write(self._oprot)
1673 
    self._oprot.writeMessageEnd()
1674 
    self._oprot.trans.flush()
1675 
 
1676 
  def recv_generateNewEntityID(self, ):
1677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1678 
    if mtype == TMessageType.EXCEPTION:
1679 
      x = TApplicationException()
1680 
      x.read(self._iprot)
1681 
      self._iprot.readMessageEnd()
1682 
      raise x
1683 
    result = generateNewEntityID_result()
1684 
    result.read(self._iprot)
1685 
    self._iprot.readMessageEnd()
1686 
    if result.success is not None:
1687 
      return result.success
1688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1689 
 
1690 
  def addCategory(self, category):
1691 
    """
1692 
    All category related functions
1693 
 
1694 
    Parameters:
1695 
     - category
1696 
    """
1697 
    self.send_addCategory(category)
1698 
    return self.recv_addCategory()
1699 
 
1700 
  def send_addCategory(self, category):
1701 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1702 
    args = addCategory_args()
1703 
    args.category = category
1704 
    args.write(self._oprot)
1705 
    self._oprot.writeMessageEnd()
1706 
    self._oprot.trans.flush()
1707 
 
1708 
  def recv_addCategory(self, ):
1709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1710 
    if mtype == TMessageType.EXCEPTION:
1711 
      x = TApplicationException()
1712 
      x.read(self._iprot)
1713 
      self._iprot.readMessageEnd()
1714 
      raise x
1715 
    result = addCategory_result()
1716 
    result.read(self._iprot)
1717 
    self._iprot.readMessageEnd()
1718 
    if result.success is not None:
1719 
      return result.success
1720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1721 
 
1722 
  def getCategory(self, id):
1723 
    """
1724 
    Parameters:
1725 
     - id
1726 
    """
1727 
    self.send_getCategory(id)
1728 
    return self.recv_getCategory()
1729 
 
1730 
  def send_getCategory(self, id):
1731 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1732 
    args = getCategory_args()
1733 
    args.id = id
1734 
    args.write(self._oprot)
1735 
    self._oprot.writeMessageEnd()
1736 
    self._oprot.trans.flush()
1737 
 
1738 
  def recv_getCategory(self, ):
1739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1740 
    if mtype == TMessageType.EXCEPTION:
1741 
      x = TApplicationException()
1742 
      x.read(self._iprot)
1743 
      self._iprot.readMessageEnd()
1744 
      raise x
1745 
    result = getCategory_result()
1746 
    result.read(self._iprot)
1747 
    self._iprot.readMessageEnd()
1748 
    if result.success is not None:
1749 
      return result.success
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1751 
 
1752 
  def getAllCategories(self, ):
1753 
    self.send_getAllCategories()
1754 
    return self.recv_getAllCategories()
1755 
 
1756 
  def send_getAllCategories(self, ):
1757 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1758 
    args = getAllCategories_args()
1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_getAllCategories(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = getAllCategories_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
1773 
    if result.success is not None:
1774 
      return result.success
1775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1776 
 
1777 
  def getAllSimilarItems(self, itemId):
1778 
    """
1779 
    Returns the list of similar items.
1780 
 
1781 
    Parameters:
1782 
     - itemId
1783 
    """
1784 
    self.send_getAllSimilarItems(itemId)
1785 
    return self.recv_getAllSimilarItems()
1786 
 
1787 
  def send_getAllSimilarItems(self, itemId):
1788 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1789 
    args = getAllSimilarItems_args()
1790 
    args.itemId = itemId
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_getAllSimilarItems(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = getAllSimilarItems_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
1805 
    if result.success is not None:
1806 
      return result.success
1807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1808 
 
1809 
  def addSimilarItem(self, itemId, catalogItemId):
1810 
    """
1811 
    Adds similar item.
1812 
 
1813 
    Parameters:
1814 
     - itemId
1815 
     - catalogItemId
1816 
    """
1817 
    self.send_addSimilarItem(itemId, catalogItemId)
1818 
    return self.recv_addSimilarItem()
1819 
 
1820 
  def send_addSimilarItem(self, itemId, catalogItemId):
1821 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1822 
    args = addSimilarItem_args()
1823 
    args.itemId = itemId
1824 
    args.catalogItemId = catalogItemId
1825 
    args.write(self._oprot)
1826 
    self._oprot.writeMessageEnd()
1827 
    self._oprot.trans.flush()
1828 
 
1829 
  def recv_addSimilarItem(self, ):
1830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1831 
    if mtype == TMessageType.EXCEPTION:
1832 
      x = TApplicationException()
1833 
      x.read(self._iprot)
1834 
      self._iprot.readMessageEnd()
1835 
      raise x
1836 
    result = addSimilarItem_result()
1837 
    result.read(self._iprot)
1838 
    self._iprot.readMessageEnd()
1839 
    if result.success is not None:
1840 
      return result.success
1841 
    if result.cex is not None:
1842 
      raise result.cex
1843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1844 
 
6512 kshitij.so 1845 
  def addTag(self, displayName, itemId):
1846 
    """
1847 
    Tag Related
1848 
 
1849 
    Parameters:
1850 
     - displayName
1851 
     - itemId
1852 
    """
1853 
    self.send_addTag(displayName, itemId)
1854 
    return self.recv_addTag()
1855 
 
1856 
  def send_addTag(self, displayName, itemId):
1857 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1858 
    args = addTag_args()
1859 
    args.displayName = displayName
1860 
    args.itemId = itemId
1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
1865 
  def recv_addTag(self, ):
1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
1872 
    result = addTag_result()
1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
1875 
    if result.success is not None:
1876 
      return result.success
1877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1878 
 
1879 
  def deleteEntityTag(self, displayName, itemId):
1880 
    """
1881 
    Parameters:
1882 
     - displayName
1883 
     - itemId
1884 
    """
1885 
    self.send_deleteEntityTag(displayName, itemId)
1886 
    return self.recv_deleteEntityTag()
1887 
 
1888 
  def send_deleteEntityTag(self, displayName, itemId):
1889 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1890 
    args = deleteEntityTag_args()
1891 
    args.displayName = displayName
1892 
    args.itemId = itemId
1893 
    args.write(self._oprot)
1894 
    self._oprot.writeMessageEnd()
1895 
    self._oprot.trans.flush()
1896 
 
1897 
  def recv_deleteEntityTag(self, ):
1898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1899 
    if mtype == TMessageType.EXCEPTION:
1900 
      x = TApplicationException()
1901 
      x.read(self._iprot)
1902 
      self._iprot.readMessageEnd()
1903 
      raise x
1904 
    result = deleteEntityTag_result()
1905 
    result.read(self._iprot)
1906 
    self._iprot.readMessageEnd()
1907 
    if result.success is not None:
1908 
      return result.success
1909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1910 
 
1911 
  def deleteTag(self, displayName):
1912 
    """
1913 
    Parameters:
1914 
     - displayName
1915 
    """
1916 
    self.send_deleteTag(displayName)
1917 
    return self.recv_deleteTag()
1918 
 
1919 
  def send_deleteTag(self, displayName):
1920 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1921 
    args = deleteTag_args()
1922 
    args.displayName = displayName
1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
1927 
  def recv_deleteTag(self, ):
1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
1934 
    result = deleteTag_result()
1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
1937 
    if result.success is not None:
1938 
      return result.success
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1940 
 
1941 
  def getAllTags(self, ):
1942 
    self.send_getAllTags()
1943 
    return self.recv_getAllTags()
1944 
 
1945 
  def send_getAllTags(self, ):
1946 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1947 
    args = getAllTags_args()
1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
1952 
  def recv_getAllTags(self, ):
1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
1959 
    result = getAllTags_result()
1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
1962 
    if result.success is not None:
1963 
      return result.success
1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
1965 
 
1966 
  def getAllEntitiesByTagName(self, displayName):
1967 
    """
1968 
    Parameters:
1969 
     - displayName
1970 
    """
1971 
    self.send_getAllEntitiesByTagName(displayName)
1972 
    return self.recv_getAllEntitiesByTagName()
1973 
 
1974 
  def send_getAllEntitiesByTagName(self, displayName):
1975 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
1976 
    args = getAllEntitiesByTagName_args()
1977 
    args.displayName = displayName
1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_getAllEntitiesByTagName(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = getAllEntitiesByTagName_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
1992 
    if result.success is not None:
1993 
      return result.success
1994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
1995 
 
6845 amit.gupta 1996 
  def getAllEntityTags(self, ):
1997 
    self.send_getAllEntityTags()
1998 
    return self.recv_getAllEntityTags()
1999 
 
2000 
  def send_getAllEntityTags(self, ):
2001 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2002 
    args = getAllEntityTags_args()
2003 
    args.write(self._oprot)
2004 
    self._oprot.writeMessageEnd()
2005 
    self._oprot.trans.flush()
2006 
 
2007 
  def recv_getAllEntityTags(self, ):
2008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2009 
    if mtype == TMessageType.EXCEPTION:
2010 
      x = TApplicationException()
2011 
      x.read(self._iprot)
2012 
      self._iprot.readMessageEnd()
2013 
      raise x
2014 
    result = getAllEntityTags_result()
2015 
    result.read(self._iprot)
2016 
    self._iprot.readMessageEnd()
2017 
    if result.success is not None:
2018 
      return result.success
2019 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2020 
 
6850 kshitij.so 2021 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2022 
    """
2023 
    Parameters:
2024 
     - bannerName
2025 
     - imageName
2026 
     - link
2027 
     - priority
2028 
     - isActive
2029 
     - hasMap
2030 
    """
2031 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2032 
    return self.recv_addBanner()
2033 
 
2034 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2035 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2036 
    args = addBanner_args()
2037 
    args.bannerName = bannerName
2038 
    args.imageName = imageName
2039 
    args.link = link
2040 
    args.priority = priority
2041 
    args.isActive = isActive
2042 
    args.hasMap = hasMap
2043 
    args.write(self._oprot)
2044 
    self._oprot.writeMessageEnd()
2045 
    self._oprot.trans.flush()
2046 
 
2047 
  def recv_addBanner(self, ):
2048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2049 
    if mtype == TMessageType.EXCEPTION:
2050 
      x = TApplicationException()
2051 
      x.read(self._iprot)
2052 
      self._iprot.readMessageEnd()
2053 
      raise x
2054 
    result = addBanner_result()
2055 
    result.read(self._iprot)
2056 
    self._iprot.readMessageEnd()
2057 
    if result.success is not None:
2058 
      return result.success
2059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2060 
 
2061 
  def getAllBanners(self, ):
2062 
    self.send_getAllBanners()
2063 
    return self.recv_getAllBanners()
2064 
 
2065 
  def send_getAllBanners(self, ):
2066 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2067 
    args = getAllBanners_args()
2068 
    args.write(self._oprot)
2069 
    self._oprot.writeMessageEnd()
2070 
    self._oprot.trans.flush()
2071 
 
2072 
  def recv_getAllBanners(self, ):
2073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2074 
    if mtype == TMessageType.EXCEPTION:
2075 
      x = TApplicationException()
2076 
      x.read(self._iprot)
2077 
      self._iprot.readMessageEnd()
2078 
      raise x
2079 
    result = getAllBanners_result()
2080 
    result.read(self._iprot)
2081 
    self._iprot.readMessageEnd()
2082 
    if result.success is not None:
2083 
      return result.success
2084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2085 
 
2086 
  def deleteBanner(self, bannerName):
2087 
    """
2088 
    Parameters:
2089 
     - bannerName
2090 
    """
2091 
    self.send_deleteBanner(bannerName)
2092 
    return self.recv_deleteBanner()
2093 
 
2094 
  def send_deleteBanner(self, bannerName):
2095 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2096 
    args = deleteBanner_args()
2097 
    args.bannerName = bannerName
2098 
    args.write(self._oprot)
2099 
    self._oprot.writeMessageEnd()
2100 
    self._oprot.trans.flush()
2101 
 
2102 
  def recv_deleteBanner(self, ):
2103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2104 
    if mtype == TMessageType.EXCEPTION:
2105 
      x = TApplicationException()
2106 
      x.read(self._iprot)
2107 
      self._iprot.readMessageEnd()
2108 
      raise x
2109 
    result = deleteBanner_result()
2110 
    result.read(self._iprot)
2111 
    self._iprot.readMessageEnd()
2112 
    if result.success is not None:
2113 
      return result.success
2114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2115 
 
2116 
  def getBannerDetails(self, bannerName):
2117 
    """
2118 
    Parameters:
2119 
     - bannerName
2120 
    """
2121 
    self.send_getBannerDetails(bannerName)
2122 
    return self.recv_getBannerDetails()
2123 
 
2124 
  def send_getBannerDetails(self, bannerName):
2125 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2126 
    args = getBannerDetails_args()
2127 
    args.bannerName = bannerName
2128 
    args.write(self._oprot)
2129 
    self._oprot.writeMessageEnd()
2130 
    self._oprot.trans.flush()
2131 
 
2132 
  def recv_getBannerDetails(self, ):
2133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2134 
    if mtype == TMessageType.EXCEPTION:
2135 
      x = TApplicationException()
2136 
      x.read(self._iprot)
2137 
      self._iprot.readMessageEnd()
2138 
      raise x
2139 
    result = getBannerDetails_result()
2140 
    result.read(self._iprot)
2141 
    self._iprot.readMessageEnd()
2142 
    if result.success is not None:
2143 
      return result.success
2144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2145 
 
2146 
  def getActiveBanners(self, ):
2147 
    self.send_getActiveBanners()
2148 
    return self.recv_getActiveBanners()
2149 
 
2150 
  def send_getActiveBanners(self, ):
2151 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2152 
    args = getActiveBanners_args()
2153 
    args.write(self._oprot)
2154 
    self._oprot.writeMessageEnd()
2155 
    self._oprot.trans.flush()
2156 
 
2157 
  def recv_getActiveBanners(self, ):
2158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2159 
    if mtype == TMessageType.EXCEPTION:
2160 
      x = TApplicationException()
2161 
      x.read(self._iprot)
2162 
      self._iprot.readMessageEnd()
2163 
      raise x
2164 
    result = getActiveBanners_result()
2165 
    result.read(self._iprot)
2166 
    self._iprot.readMessageEnd()
2167 
    if result.success is not None:
2168 
      return result.success
2169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2170 
 
6849 kshitij.so 2171 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2172 
    """
2173 
    Parameters:
2174 
     - bannerName
2175 
     - mapLink
2176 
     - coordinates
2177 
    """
2178 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2179 
    return self.recv_addBannerMap()
2180 
 
2181 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2182 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2183 
    args = addBannerMap_args()
2184 
    args.bannerName = bannerName
2185 
    args.mapLink = mapLink
2186 
    args.coordinates = coordinates
2187 
    args.write(self._oprot)
2188 
    self._oprot.writeMessageEnd()
2189 
    self._oprot.trans.flush()
2190 
 
2191 
  def recv_addBannerMap(self, ):
2192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2193 
    if mtype == TMessageType.EXCEPTION:
2194 
      x = TApplicationException()
2195 
      x.read(self._iprot)
2196 
      self._iprot.readMessageEnd()
2197 
      raise x
2198 
    result = addBannerMap_result()
2199 
    result.read(self._iprot)
2200 
    self._iprot.readMessageEnd()
2201 
    if result.success is not None:
2202 
      return result.success
2203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2204 
 
2205 
  def deleteBannerMap(self, bannerName):
2206 
    """
2207 
    Parameters:
2208 
     - bannerName
2209 
    """
2210 
    self.send_deleteBannerMap(bannerName)
2211 
    return self.recv_deleteBannerMap()
2212 
 
2213 
  def send_deleteBannerMap(self, bannerName):
2214 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2215 
    args = deleteBannerMap_args()
2216 
    args.bannerName = bannerName
2217 
    args.write(self._oprot)
2218 
    self._oprot.writeMessageEnd()
2219 
    self._oprot.trans.flush()
2220 
 
2221 
  def recv_deleteBannerMap(self, ):
2222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2223 
    if mtype == TMessageType.EXCEPTION:
2224 
      x = TApplicationException()
2225 
      x.read(self._iprot)
2226 
      self._iprot.readMessageEnd()
2227 
      raise x
2228 
    result = deleteBannerMap_result()
2229 
    result.read(self._iprot)
2230 
    self._iprot.readMessageEnd()
2231 
    if result.success is not None:
2232 
      return result.success
2233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2234 
 
2235 
  def getBannerMapDetails(self, bannerName):
2236 
    """
2237 
    Parameters:
2238 
     - bannerName
2239 
    """
2240 
    self.send_getBannerMapDetails(bannerName)
2241 
    return self.recv_getBannerMapDetails()
2242 
 
2243 
  def send_getBannerMapDetails(self, bannerName):
2244 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2245 
    args = getBannerMapDetails_args()
2246 
    args.bannerName = bannerName
2247 
    args.write(self._oprot)
2248 
    self._oprot.writeMessageEnd()
2249 
    self._oprot.trans.flush()
2250 
 
2251 
  def recv_getBannerMapDetails(self, ):
2252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2253 
    if mtype == TMessageType.EXCEPTION:
2254 
      x = TApplicationException()
2255 
      x.read(self._iprot)
2256 
      self._iprot.readMessageEnd()
2257 
      raise x
2258 
    result = getBannerMapDetails_result()
2259 
    result.read(self._iprot)
2260 
    self._iprot.readMessageEnd()
2261 
    if result.success is not None:
2262 
      return result.success
2263 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2264 
 
5944 mandeep.dh 2265 
  def deleteSimilarItem(self, itemId, catalogItemId):
2266 
    """
2267 
    Delete similar item.
2268 
 
2269 
    Parameters:
2270 
     - itemId
2271 
     - catalogItemId
2272 
    """
2273 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2274 
    return self.recv_deleteSimilarItem()
2275 
 
2276 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2277 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2278 
    args = deleteSimilarItem_args()
2279 
    args.itemId = itemId
2280 
    args.catalogItemId = catalogItemId
2281 
    args.write(self._oprot)
2282 
    self._oprot.writeMessageEnd()
2283 
    self._oprot.trans.flush()
2284 
 
2285 
  def recv_deleteSimilarItem(self, ):
2286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2287 
    if mtype == TMessageType.EXCEPTION:
2288 
      x = TApplicationException()
2289 
      x.read(self._iprot)
2290 
      self._iprot.readMessageEnd()
2291 
      raise x
2292 
    result = deleteSimilarItem_result()
2293 
    result.read(self._iprot)
2294 
    self._iprot.readMessageEnd()
2295 
    if result.success is not None:
2296 
      return result.success
2297 
    if result.cex is not None:
2298 
      raise result.cex
2299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2300 
 
2301 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2302 
    """
2303 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2304 
    If yes, returns the itemId else returns 0
2305 
 
2306 
    Parameters:
2307 
     - brand
2308 
     - modelNumber
2309 
     - modelName
2310 
     - color
2311 
    """
2312 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2313 
    return self.recv_checkSimilarItem()
2314 
 
2315 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2316 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2317 
    args = checkSimilarItem_args()
2318 
    args.brand = brand
2319 
    args.modelNumber = modelNumber
2320 
    args.modelName = modelName
2321 
    args.color = color
2322 
    args.write(self._oprot)
2323 
    self._oprot.writeMessageEnd()
2324 
    self._oprot.trans.flush()
2325 
 
2326 
  def recv_checkSimilarItem(self, ):
2327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2328 
    if mtype == TMessageType.EXCEPTION:
2329 
      x = TApplicationException()
2330 
      x.read(self._iprot)
2331 
      self._iprot.readMessageEnd()
2332 
      raise x
2333 
    result = checkSimilarItem_result()
2334 
    result.read(self._iprot)
2335 
    self._iprot.readMessageEnd()
2336 
    if result.success is not None:
2337 
      return result.success
2338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2339 
 
2340 
  def validateRiskyStatus(self, itemId):
2341 
    """
2342 
    Check wether item is risky and change status if inventory is not available for risky items
2343 
 
2344 
    Parameters:
2345 
     - itemId
2346 
    """
2347 
    self.send_validateRiskyStatus(itemId)
2348 
    self.recv_validateRiskyStatus()
2349 
 
2350 
  def send_validateRiskyStatus(self, itemId):
2351 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2352 
    args = validateRiskyStatus_args()
2353 
    args.itemId = itemId
2354 
    args.write(self._oprot)
2355 
    self._oprot.writeMessageEnd()
2356 
    self._oprot.trans.flush()
2357 
 
2358 
  def recv_validateRiskyStatus(self, ):
2359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2360 
    if mtype == TMessageType.EXCEPTION:
2361 
      x = TApplicationException()
2362 
      x.read(self._iprot)
2363 
      self._iprot.readMessageEnd()
2364 
      raise x
2365 
    result = validateRiskyStatus_result()
2366 
    result.read(self._iprot)
2367 
    self._iprot.readMessageEnd()
2368 
    return
2369 
 
2370 
  def changeItemRiskyFlag(self, itemId, risky):
2371 
    """
2372 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2373 
 
2374 
    Parameters:
2375 
     - itemId
2376 
     - risky
2377 
    """
2378 
    self.send_changeItemRiskyFlag(itemId, risky)
2379 
    self.recv_changeItemRiskyFlag()
2380 
 
2381 
  def send_changeItemRiskyFlag(self, itemId, risky):
2382 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2383 
    args = changeItemRiskyFlag_args()
2384 
    args.itemId = itemId
2385 
    args.risky = risky
2386 
    args.write(self._oprot)
2387 
    self._oprot.writeMessageEnd()
2388 
    self._oprot.trans.flush()
2389 
 
2390 
  def recv_changeItemRiskyFlag(self, ):
2391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2392 
    if mtype == TMessageType.EXCEPTION:
2393 
      x = TApplicationException()
2394 
      x.read(self._iprot)
2395 
      self._iprot.readMessageEnd()
2396 
      raise x
2397 
    result = changeItemRiskyFlag_result()
2398 
    result.read(self._iprot)
2399 
    self._iprot.readMessageEnd()
2400 
    return
2401 
 
2402 
  def getItemsByRiskyFlag(self, ):
2403 
    """
2404 
    Returns list of items marked as risky.
2405 
    """
2406 
    self.send_getItemsByRiskyFlag()
2407 
    return self.recv_getItemsByRiskyFlag()
2408 
 
2409 
  def send_getItemsByRiskyFlag(self, ):
2410 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2411 
    args = getItemsByRiskyFlag_args()
2412 
    args.write(self._oprot)
2413 
    self._oprot.writeMessageEnd()
2414 
    self._oprot.trans.flush()
2415 
 
2416 
  def recv_getItemsByRiskyFlag(self, ):
2417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2418 
    if mtype == TMessageType.EXCEPTION:
2419 
      x = TApplicationException()
2420 
      x.read(self._iprot)
2421 
      self._iprot.readMessageEnd()
2422 
      raise x
2423 
    result = getItemsByRiskyFlag_result()
2424 
    result.read(self._iprot)
2425 
    self._iprot.readMessageEnd()
2426 
    if result.success is not None:
2427 
      return result.success
2428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2429 
 
2430 
  def getItemsForMasterSheet(self, category, brand):
2431 
    """
2432 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2433 
 
2434 
    Parameters:
2435 
     - category
2436 
     - brand
2437 
    """
2438 
    self.send_getItemsForMasterSheet(category, brand)
2439 
    return self.recv_getItemsForMasterSheet()
2440 
 
2441 
  def send_getItemsForMasterSheet(self, category, brand):
2442 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2443 
    args = getItemsForMasterSheet_args()
2444 
    args.category = category
2445 
    args.brand = brand
2446 
    args.write(self._oprot)
2447 
    self._oprot.writeMessageEnd()
2448 
    self._oprot.trans.flush()
2449 
 
2450 
  def recv_getItemsForMasterSheet(self, ):
2451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2452 
    if mtype == TMessageType.EXCEPTION:
2453 
      x = TApplicationException()
2454 
      x.read(self._iprot)
2455 
      self._iprot.readMessageEnd()
2456 
      raise x
2457 
    result = getItemsForMasterSheet_result()
2458 
    result.read(self._iprot)
2459 
    self._iprot.readMessageEnd()
2460 
    if result.success is not None:
2461 
      return result.success
2462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2463 
 
2464 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2465 
    """
2466 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2467 
 
2468 
    Parameters:
2469 
     - beginIndex
2470 
     - totalItems
2471 
     - itemId
2472 
    """
2473 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2474 
    return self.recv_getSimilarItemsCatalogIds()
2475 
 
2476 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2477 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2478 
    args = getSimilarItemsCatalogIds_args()
2479 
    args.beginIndex = beginIndex
2480 
    args.totalItems = totalItems
2481 
    args.itemId = itemId
2482 
    args.write(self._oprot)
2483 
    self._oprot.writeMessageEnd()
2484 
    self._oprot.trans.flush()
2485 
 
2486 
  def recv_getSimilarItemsCatalogIds(self, ):
2487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2488 
    if mtype == TMessageType.EXCEPTION:
2489 
      x = TApplicationException()
2490 
      x.read(self._iprot)
2491 
      self._iprot.readMessageEnd()
2492 
      raise x
2493 
    result = getSimilarItemsCatalogIds_result()
2494 
    result.read(self._iprot)
2495 
    self._iprot.readMessageEnd()
2496 
    if result.success is not None:
2497 
      return result.success
2498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2499 
 
2500 
  def addProductNotification(self, itemId, email):
2501 
    """
2502 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2503 
 
2504 
    Parameters:
2505 
     - itemId
2506 
     - email
2507 
    """
2508 
    self.send_addProductNotification(itemId, email)
2509 
    return self.recv_addProductNotification()
2510 
 
2511 
  def send_addProductNotification(self, itemId, email):
2512 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2513 
    args = addProductNotification_args()
2514 
    args.itemId = itemId
2515 
    args.email = email
2516 
    args.write(self._oprot)
2517 
    self._oprot.writeMessageEnd()
2518 
    self._oprot.trans.flush()
2519 
 
2520 
  def recv_addProductNotification(self, ):
2521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2522 
    if mtype == TMessageType.EXCEPTION:
2523 
      x = TApplicationException()
2524 
      x.read(self._iprot)
2525 
      self._iprot.readMessageEnd()
2526 
      raise x
2527 
    result = addProductNotification_result()
2528 
    result.read(self._iprot)
2529 
    self._iprot.readMessageEnd()
2530 
    if result.success is not None:
2531 
      return result.success
2532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2533 
 
2534 
  def sendProductNotifications(self, ):
2535 
    """
2536 
    Send the product notifications to the users for items which has stock.
2537 
    """
2538 
    self.send_sendProductNotifications()
2539 
    return self.recv_sendProductNotifications()
2540 
 
2541 
  def send_sendProductNotifications(self, ):
2542 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2543 
    args = sendProductNotifications_args()
2544 
    args.write(self._oprot)
2545 
    self._oprot.writeMessageEnd()
2546 
    self._oprot.trans.flush()
2547 
 
2548 
  def recv_sendProductNotifications(self, ):
2549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2550 
    if mtype == TMessageType.EXCEPTION:
2551 
      x = TApplicationException()
2552 
      x.read(self._iprot)
2553 
      self._iprot.readMessageEnd()
2554 
      raise x
2555 
    result = sendProductNotifications_result()
2556 
    result.read(self._iprot)
2557 
    self._iprot.readMessageEnd()
2558 
    if result.success is not None:
2559 
      return result.success
2560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2561 
 
2562 
  def getAllBrandsByCategory(self, categoryId):
2563 
    """
2564 
    Returns list of brand names for a given category Id
2565 
 
2566 
    Parameters:
2567 
     - categoryId
2568 
    """
2569 
    self.send_getAllBrandsByCategory(categoryId)
2570 
    return self.recv_getAllBrandsByCategory()
2571 
 
2572 
  def send_getAllBrandsByCategory(self, categoryId):
2573 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2574 
    args = getAllBrandsByCategory_args()
2575 
    args.categoryId = categoryId
2576 
    args.write(self._oprot)
2577 
    self._oprot.writeMessageEnd()
2578 
    self._oprot.trans.flush()
2579 
 
2580 
  def recv_getAllBrandsByCategory(self, ):
2581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2582 
    if mtype == TMessageType.EXCEPTION:
2583 
      x = TApplicationException()
2584 
      x.read(self._iprot)
2585 
      self._iprot.readMessageEnd()
2586 
      raise x
2587 
    result = getAllBrandsByCategory_result()
2588 
    result.read(self._iprot)
2589 
    self._iprot.readMessageEnd()
2590 
    if result.success is not None:
2591 
      return result.success
2592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2593 
 
2594 
  def getAllBrands(self, ):
2595 
    """
2596 
    Returns list of brand names
2597 
    """
2598 
    self.send_getAllBrands()
2599 
    return self.recv_getAllBrands()
2600 
 
2601 
  def send_getAllBrands(self, ):
2602 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2603 
    args = getAllBrands_args()
2604 
    args.write(self._oprot)
2605 
    self._oprot.writeMessageEnd()
2606 
    self._oprot.trans.flush()
2607 
 
2608 
  def recv_getAllBrands(self, ):
2609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2610 
    if mtype == TMessageType.EXCEPTION:
2611 
      x = TApplicationException()
2612 
      x.read(self._iprot)
2613 
      self._iprot.readMessageEnd()
2614 
      raise x
2615 
    result = getAllBrands_result()
2616 
    result.read(self._iprot)
2617 
    self._iprot.readMessageEnd()
2618 
    if result.success is not None:
2619 
      return result.success
2620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2621 
 
2622 
  def getAllSources(self, ):
2623 
    """
2624 
    Return list of all sources
2625 
    """
2626 
    self.send_getAllSources()
2627 
    return self.recv_getAllSources()
2628 
 
2629 
  def send_getAllSources(self, ):
2630 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2631 
    args = getAllSources_args()
2632 
    args.write(self._oprot)
2633 
    self._oprot.writeMessageEnd()
2634 
    self._oprot.trans.flush()
2635 
 
2636 
  def recv_getAllSources(self, ):
2637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2638 
    if mtype == TMessageType.EXCEPTION:
2639 
      x = TApplicationException()
2640 
      x.read(self._iprot)
2641 
      self._iprot.readMessageEnd()
2642 
      raise x
2643 
    result = getAllSources_result()
2644 
    result.read(self._iprot)
2645 
    self._iprot.readMessageEnd()
2646 
    if result.success is not None:
2647 
      return result.success
2648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2649 
 
2650 
  def getItemPricingBySource(self, itemId, sourceId):
2651 
    """
2652 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2653 
 
2654 
    Parameters:
2655 
     - itemId
2656 
     - sourceId
2657 
    """
2658 
    self.send_getItemPricingBySource(itemId, sourceId)
2659 
    return self.recv_getItemPricingBySource()
2660 
 
2661 
  def send_getItemPricingBySource(self, itemId, sourceId):
2662 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2663 
    args = getItemPricingBySource_args()
2664 
    args.itemId = itemId
2665 
    args.sourceId = sourceId
2666 
    args.write(self._oprot)
2667 
    self._oprot.writeMessageEnd()
2668 
    self._oprot.trans.flush()
2669 
 
2670 
  def recv_getItemPricingBySource(self, ):
2671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2672 
    if mtype == TMessageType.EXCEPTION:
2673 
      x = TApplicationException()
2674 
      x.read(self._iprot)
2675 
      self._iprot.readMessageEnd()
2676 
      raise x
2677 
    result = getItemPricingBySource_result()
2678 
    result.read(self._iprot)
2679 
    self._iprot.readMessageEnd()
2680 
    if result.success is not None:
2681 
      return result.success
2682 
    if result.cex is not None:
2683 
      raise result.cex
2684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2685 
 
2686 
  def addSourceItemPricing(self, sourceItemPricing):
2687 
    """
2688 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2689 
    If item is not found or source is not found, it will throw exception.
2690 
 
2691 
    Parameters:
2692 
     - sourceItemPricing
2693 
    """
2694 
    self.send_addSourceItemPricing(sourceItemPricing)
2695 
    self.recv_addSourceItemPricing()
2696 
 
2697 
  def send_addSourceItemPricing(self, sourceItemPricing):
2698 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2699 
    args = addSourceItemPricing_args()
2700 
    args.sourceItemPricing = sourceItemPricing
2701 
    args.write(self._oprot)
2702 
    self._oprot.writeMessageEnd()
2703 
    self._oprot.trans.flush()
2704 
 
2705 
  def recv_addSourceItemPricing(self, ):
2706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2707 
    if mtype == TMessageType.EXCEPTION:
2708 
      x = TApplicationException()
2709 
      x.read(self._iprot)
2710 
      self._iprot.readMessageEnd()
2711 
      raise x
2712 
    result = addSourceItemPricing_result()
2713 
    result.read(self._iprot)
2714 
    self._iprot.readMessageEnd()
2715 
    if result.cex is not None:
2716 
      raise result.cex
2717 
    return
2718 
 
2719 
  def getAllSourcePricing(self, itemId):
2720 
    """
2721 
    Returns the list of source pricing information of an item.
2722 
    Raises an exception if item not found corresponding to itemId
2723 
 
2724 
    Parameters:
2725 
     - itemId
2726 
    """
2727 
    self.send_getAllSourcePricing(itemId)
2728 
    return self.recv_getAllSourcePricing()
2729 
 
2730 
  def send_getAllSourcePricing(self, itemId):
2731 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2732 
    args = getAllSourcePricing_args()
2733 
    args.itemId = itemId
2734 
    args.write(self._oprot)
2735 
    self._oprot.writeMessageEnd()
2736 
    self._oprot.trans.flush()
2737 
 
2738 
  def recv_getAllSourcePricing(self, ):
2739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2740 
    if mtype == TMessageType.EXCEPTION:
2741 
      x = TApplicationException()
2742 
      x.read(self._iprot)
2743 
      self._iprot.readMessageEnd()
2744 
      raise x
2745 
    result = getAllSourcePricing_result()
2746 
    result.read(self._iprot)
2747 
    self._iprot.readMessageEnd()
2748 
    if result.success is not None:
2749 
      return result.success
2750 
    if result.cex is not None:
2751 
      raise result.cex
2752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2753 
 
2754 
  def getItemForSource(self, item_id, sourceId):
2755 
    """
2756 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2757 
 
2758 
    Parameters:
2759 
     - item_id
2760 
     - sourceId
2761 
    """
2762 
    self.send_getItemForSource(item_id, sourceId)
2763 
    return self.recv_getItemForSource()
2764 
 
2765 
  def send_getItemForSource(self, item_id, sourceId):
2766 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2767 
    args = getItemForSource_args()
2768 
    args.item_id = item_id
2769 
    args.sourceId = sourceId
2770 
    args.write(self._oprot)
2771 
    self._oprot.writeMessageEnd()
2772 
    self._oprot.trans.flush()
2773 
 
2774 
  def recv_getItemForSource(self, ):
2775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2776 
    if mtype == TMessageType.EXCEPTION:
2777 
      x = TApplicationException()
2778 
      x.read(self._iprot)
2779 
      self._iprot.readMessageEnd()
2780 
      raise x
2781 
    result = getItemForSource_result()
2782 
    result.read(self._iprot)
2783 
    self._iprot.readMessageEnd()
2784 
    if result.success is not None:
2785 
      return result.success
2786 
    if result.cex is not None:
2787 
      raise result.cex
2788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2789 
 
2790 
  def searchItemsInRange(self, searchTerms, offset, limit):
2791 
    """
2792 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2793 
 
2794 
    Parameters:
2795 
     - searchTerms
2796 
     - offset
2797 
     - limit
2798 
    """
2799 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2800 
    return self.recv_searchItemsInRange()
2801 
 
2802 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2803 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2804 
    args = searchItemsInRange_args()
2805 
    args.searchTerms = searchTerms
2806 
    args.offset = offset
2807 
    args.limit = limit
2808 
    args.write(self._oprot)
2809 
    self._oprot.writeMessageEnd()
2810 
    self._oprot.trans.flush()
2811 
 
2812 
  def recv_searchItemsInRange(self, ):
2813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2814 
    if mtype == TMessageType.EXCEPTION:
2815 
      x = TApplicationException()
2816 
      x.read(self._iprot)
2817 
      self._iprot.readMessageEnd()
2818 
      raise x
2819 
    result = searchItemsInRange_result()
2820 
    result.read(self._iprot)
2821 
    self._iprot.readMessageEnd()
2822 
    if result.success is not None:
2823 
      return result.success
2824 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2825 
 
2826 
  def getSearchResultCount(self, searchTerms):
2827 
    """
2828 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2829 
 
2830 
    Parameters:
2831 
     - searchTerms
2832 
    """
2833 
    self.send_getSearchResultCount(searchTerms)
2834 
    return self.recv_getSearchResultCount()
2835 
 
2836 
  def send_getSearchResultCount(self, searchTerms):
2837 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2838 
    args = getSearchResultCount_args()
2839 
    args.searchTerms = searchTerms
2840 
    args.write(self._oprot)
2841 
    self._oprot.writeMessageEnd()
2842 
    self._oprot.trans.flush()
2843 
 
2844 
  def recv_getSearchResultCount(self, ):
2845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2846 
    if mtype == TMessageType.EXCEPTION:
2847 
      x = TApplicationException()
2848 
      x.read(self._iprot)
2849 
      self._iprot.readMessageEnd()
2850 
      raise x
2851 
    result = getSearchResultCount_result()
2852 
    result.read(self._iprot)
2853 
    self._iprot.readMessageEnd()
2854 
    if result.success is not None:
2855 
      return result.success
2856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2857 
 
2858 
  def getProductNotifications(self, startDateTime):
2859 
    """
2860 
    Returns a list of product notifications added after a supplied datetime
2861 
 
2862 
    Parameters:
2863 
     - startDateTime
2864 
    """
2865 
    self.send_getProductNotifications(startDateTime)
2866 
    return self.recv_getProductNotifications()
2867 
 
2868 
  def send_getProductNotifications(self, startDateTime):
2869 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2870 
    args = getProductNotifications_args()
2871 
    args.startDateTime = startDateTime
2872 
    args.write(self._oprot)
2873 
    self._oprot.writeMessageEnd()
2874 
    self._oprot.trans.flush()
2875 
 
2876 
  def recv_getProductNotifications(self, ):
2877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2878 
    if mtype == TMessageType.EXCEPTION:
2879 
      x = TApplicationException()
2880 
      x.read(self._iprot)
2881 
      self._iprot.readMessageEnd()
2882 
      raise x
2883 
    result = getProductNotifications_result()
2884 
    result.read(self._iprot)
2885 
    self._iprot.readMessageEnd()
2886 
    if result.success is not None:
2887 
      return result.success
2888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2889 
 
2890 
  def getProductNotificationRequestCount(self, startDateTime):
2891 
    """
2892 
    Returns a list of count of requests for product notification against each item
2893 
 
2894 
    Parameters:
2895 
     - startDateTime
2896 
    """
2897 
    self.send_getProductNotificationRequestCount(startDateTime)
2898 
    return self.recv_getProductNotificationRequestCount()
2899 
 
2900 
  def send_getProductNotificationRequestCount(self, startDateTime):
2901 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2902 
    args = getProductNotificationRequestCount_args()
2903 
    args.startDateTime = startDateTime
2904 
    args.write(self._oprot)
2905 
    self._oprot.writeMessageEnd()
2906 
    self._oprot.trans.flush()
2907 
 
2908 
  def recv_getProductNotificationRequestCount(self, ):
2909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2910 
    if mtype == TMessageType.EXCEPTION:
2911 
      x = TApplicationException()
2912 
      x.read(self._iprot)
2913 
      self._iprot.readMessageEnd()
2914 
      raise x
2915 
    result = getProductNotificationRequestCount_result()
2916 
    result.read(self._iprot)
2917 
    self._iprot.readMessageEnd()
2918 
    if result.success is not None:
2919 
      return result.success
2920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2921 
 
2922 
  def addAuthorizationLog(self, itemId, username, reason):
2923 
    """
2924 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2925 
 
2926 
    Parameters:
2927 
     - itemId
2928 
     - username
2929 
     - reason
2930 
    """
2931 
    self.send_addAuthorizationLog(itemId, username, reason)
2932 
    return self.recv_addAuthorizationLog()
2933 
 
2934 
  def send_addAuthorizationLog(self, itemId, username, reason):
2935 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2936 
    args = addAuthorizationLog_args()
2937 
    args.itemId = itemId
2938 
    args.username = username
2939 
    args.reason = reason
2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_addAuthorizationLog(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = addAuthorizationLog_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    if result.cex is not None:
2957 
      raise result.cex
2958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2959 
 
2960 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2961 
    """
2962 
    Parameters:
2963 
     - catalog_item_id
2964 
     - voucherType
2965 
     - voucherAmount
2966 
    """
2967 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
2968 
    return self.recv_addupdateVoucherForItem()
2969 
 
2970 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2971 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
2972 
    args = addupdateVoucherForItem_args()
2973 
    args.catalog_item_id = catalog_item_id
2974 
    args.voucherType = voucherType
2975 
    args.voucherAmount = voucherAmount
2976 
    args.write(self._oprot)
2977 
    self._oprot.writeMessageEnd()
2978 
    self._oprot.trans.flush()
2979 
 
2980 
  def recv_addupdateVoucherForItem(self, ):
2981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2982 
    if mtype == TMessageType.EXCEPTION:
2983 
      x = TApplicationException()
2984 
      x.read(self._iprot)
2985 
      self._iprot.readMessageEnd()
2986 
      raise x
2987 
    result = addupdateVoucherForItem_result()
2988 
    result.read(self._iprot)
2989 
    self._iprot.readMessageEnd()
2990 
    if result.success is not None:
2991 
      return result.success
2992 
    if result.cex is not None:
2993 
      raise result.cex
2994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
2995 
 
2996 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
2997 
    """
2998 
    Parameters:
2999 
     - catalog_item_id
3000 
     - voucherType
3001 
    """
3002 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3003 
    return self.recv_deleteVoucherForItem()
3004 
 
3005 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3006 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3007 
    args = deleteVoucherForItem_args()
3008 
    args.catalog_item_id = catalog_item_id
3009 
    args.voucherType = voucherType
3010 
    args.write(self._oprot)
3011 
    self._oprot.writeMessageEnd()
3012 
    self._oprot.trans.flush()
3013 
 
3014 
  def recv_deleteVoucherForItem(self, ):
3015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3016 
    if mtype == TMessageType.EXCEPTION:
3017 
      x = TApplicationException()
3018 
      x.read(self._iprot)
3019 
      self._iprot.readMessageEnd()
3020 
      raise x
3021 
    result = deleteVoucherForItem_result()
3022 
    result.read(self._iprot)
3023 
    self._iprot.readMessageEnd()
3024 
    if result.success is not None:
3025 
      return result.success
3026 
    if result.cex is not None:
3027 
      raise result.cex
3028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3029 
 
3030 
  def getVoucherAmount(self, itemId, voucherType):
3031 
    """
3032 
    Parameters:
3033 
     - itemId
3034 
     - voucherType
3035 
    """
3036 
    self.send_getVoucherAmount(itemId, voucherType)
3037 
    return self.recv_getVoucherAmount()
3038 
 
3039 
  def send_getVoucherAmount(self, itemId, voucherType):
3040 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3041 
    args = getVoucherAmount_args()
3042 
    args.itemId = itemId
3043 
    args.voucherType = voucherType
3044 
    args.write(self._oprot)
3045 
    self._oprot.writeMessageEnd()
3046 
    self._oprot.trans.flush()
3047 
 
3048 
  def recv_getVoucherAmount(self, ):
3049 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3050 
    if mtype == TMessageType.EXCEPTION:
3051 
      x = TApplicationException()
3052 
      x.read(self._iprot)
3053 
      self._iprot.readMessageEnd()
3054 
      raise x
3055 
    result = getVoucherAmount_result()
3056 
    result.read(self._iprot)
3057 
    self._iprot.readMessageEnd()
3058 
    if result.success is not None:
3059 
      return result.success
3060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3061 
 
3062 
  def getAllItemVouchers(self, itemId):
3063 
    """
3064 
    Parameters:
3065 
     - itemId
3066 
    """
3067 
    self.send_getAllItemVouchers(itemId)
3068 
    return self.recv_getAllItemVouchers()
3069 
 
3070 
  def send_getAllItemVouchers(self, itemId):
3071 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3072 
    args = getAllItemVouchers_args()
3073 
    args.itemId = itemId
3074 
    args.write(self._oprot)
3075 
    self._oprot.writeMessageEnd()
3076 
    self._oprot.trans.flush()
3077 
 
3078 
  def recv_getAllItemVouchers(self, ):
3079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3080 
    if mtype == TMessageType.EXCEPTION:
3081 
      x = TApplicationException()
3082 
      x.read(self._iprot)
3083 
      self._iprot.readMessageEnd()
3084 
      raise x
3085 
    result = getAllItemVouchers_result()
3086 
    result.read(self._iprot)
3087 
    self._iprot.readMessageEnd()
3088 
    if result.success is not None:
3089 
      return result.success
3090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3091 
 
3092 
  def isValidCatalogItemId(self, catalog_item_id):
3093 
    """
3094 
    Parameters:
3095 
     - catalog_item_id
3096 
    """
3097 
    self.send_isValidCatalogItemId(catalog_item_id)
3098 
    return self.recv_isValidCatalogItemId()
3099 
 
3100 
  def send_isValidCatalogItemId(self, catalog_item_id):
3101 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3102 
    args = isValidCatalogItemId_args()
3103 
    args.catalog_item_id = catalog_item_id
3104 
    args.write(self._oprot)
3105 
    self._oprot.writeMessageEnd()
3106 
    self._oprot.trans.flush()
3107 
 
3108 
  def recv_isValidCatalogItemId(self, ):
3109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3110 
    if mtype == TMessageType.EXCEPTION:
3111 
      x = TApplicationException()
3112 
      x.read(self._iprot)
3113 
      self._iprot.readMessageEnd()
3114 
      raise x
3115 
    result = isValidCatalogItemId_result()
3116 
    result.read(self._iprot)
3117 
    self._iprot.readMessageEnd()
3118 
    if result.success is not None:
3119 
      return result.success
3120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3121 
 
7330 amit.gupta 3122 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3123 
    """
3124 
    Parameters:
3125 
     - itemId
7330 amit.gupta 3126 
     - stateId
6039 amit.gupta 3127 
     - price
3128 
    """
7330 amit.gupta 3129 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3130 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3131 
 
7330 amit.gupta 3132 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3133 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3134 
    args = getVatPercentageForItem_args()
3135 
    args.itemId = itemId
7330 amit.gupta 3136 
    args.stateId = stateId
6039 amit.gupta 3137 
    args.price = price
3138 
    args.write(self._oprot)
3139 
    self._oprot.writeMessageEnd()
3140 
    self._oprot.trans.flush()
3141 
 
3142 
  def recv_getVatPercentageForItem(self, ):
3143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3144 
    if mtype == TMessageType.EXCEPTION:
3145 
      x = TApplicationException()
3146 
      x.read(self._iprot)
3147 
      self._iprot.readMessageEnd()
3148 
      raise x
3149 
    result = getVatPercentageForItem_result()
3150 
    result.read(self._iprot)
3151 
    self._iprot.readMessageEnd()
3152 
    if result.success is not None:
3153 
      return result.success
7340 amit.gupta 3154 
    if result.cex is not None:
3155 
      raise result.cex
6039 amit.gupta 3156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3157 
 
3158 
  def getVatAmountForItem(self, itemId, price):
3159 
    """
3160 
    Parameters:
3161 
     - itemId
3162 
     - price
3163 
    """
3164 
    self.send_getVatAmountForItem(itemId, price)
3165 
    return self.recv_getVatAmountForItem()
3166 
 
3167 
  def send_getVatAmountForItem(self, itemId, price):
3168 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3169 
    args = getVatAmountForItem_args()
3170 
    args.itemId = itemId
3171 
    args.price = price
3172 
    args.write(self._oprot)
3173 
    self._oprot.writeMessageEnd()
3174 
    self._oprot.trans.flush()
3175 
 
3176 
  def recv_getVatAmountForItem(self, ):
3177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3178 
    if mtype == TMessageType.EXCEPTION:
3179 
      x = TApplicationException()
3180 
      x.read(self._iprot)
3181 
      self._iprot.readMessageEnd()
3182 
      raise x
3183 
    result = getVatAmountForItem_result()
3184 
    result.read(self._iprot)
3185 
    self._iprot.readMessageEnd()
3186 
    if result.success is not None:
3187 
      return result.success
3188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3189 
 
6531 vikram.rag 3190 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3191 
    """
3192 
    Parameters:
3193 
     - offset
3194 
     - limit
3195 
    """
3196 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3197 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3198 
 
6531 vikram.rag 3199 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3200 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3201 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3202 
    args.offset = offset
3203 
    args.limit = limit
3204 
    args.write(self._oprot)
3205 
    self._oprot.writeMessageEnd()
3206 
    self._oprot.trans.flush()
3207 
 
3208 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3210 
    if mtype == TMessageType.EXCEPTION:
3211 
      x = TApplicationException()
3212 
      x.read(self._iprot)
3213 
      self._iprot.readMessageEnd()
3214 
      raise x
3215 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3216 
    result.read(self._iprot)
3217 
    self._iprot.readMessageEnd()
3218 
    if result.success is not None:
3219 
      return result.success
3220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3221 
 
6821 amar.kumar 3222 
  def getAllAliveItems(self, ):
3223 
    self.send_getAllAliveItems()
3224 
    return self.recv_getAllAliveItems()
3225 
 
3226 
  def send_getAllAliveItems(self, ):
3227 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3228 
    args = getAllAliveItems_args()
3229 
    args.write(self._oprot)
3230 
    self._oprot.writeMessageEnd()
3231 
    self._oprot.trans.flush()
3232 
 
3233 
  def recv_getAllAliveItems(self, ):
3234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3235 
    if mtype == TMessageType.EXCEPTION:
3236 
      x = TApplicationException()
3237 
      x.read(self._iprot)
3238 
      self._iprot.readMessageEnd()
3239 
      raise x
3240 
    result = getAllAliveItems_result()
3241 
    result.read(self._iprot)
3242 
    self._iprot.readMessageEnd()
3243 
    if result.success is not None:
3244 
      return result.success
3245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3246 
 
6921 anupam.sin 3247 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3248 
    """
3249 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3250 
 
6805 anupam.sin 3251 
    Parameters:
3252 
     - itemId
6921 anupam.sin 3253 
     - price
6805 anupam.sin 3254 
     - insurerId
3255 
     - quantity
3256 
    """
6921 anupam.sin 3257 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3258 
    return self.recv_getInsuranceAmount()
3259 
 
6921 anupam.sin 3260 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3261 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3262 
    args = getInsuranceAmount_args()
3263 
    args.itemId = itemId
6921 anupam.sin 3264 
    args.price = price
6805 anupam.sin 3265 
    args.insurerId = insurerId
3266 
    args.quantity = quantity
3267 
    args.write(self._oprot)
3268 
    self._oprot.writeMessageEnd()
3269 
    self._oprot.trans.flush()
3270 
 
3271 
  def recv_getInsuranceAmount(self, ):
3272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3273 
    if mtype == TMessageType.EXCEPTION:
3274 
      x = TApplicationException()
3275 
      x.read(self._iprot)
3276 
      self._iprot.readMessageEnd()
3277 
      raise x
3278 
    result = getInsuranceAmount_result()
3279 
    result.read(self._iprot)
3280 
    self._iprot.readMessageEnd()
3281 
    if result.success is not None:
3282 
      return result.success
3283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3284 
 
3285 
  def getInsurer(self, insurerId):
3286 
    """
3287 
    Parameters:
3288 
     - insurerId
3289 
    """
3290 
    self.send_getInsurer(insurerId)
3291 
    return self.recv_getInsurer()
3292 
 
3293 
  def send_getInsurer(self, insurerId):
3294 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3295 
    args = getInsurer_args()
3296 
    args.insurerId = insurerId
3297 
    args.write(self._oprot)
3298 
    self._oprot.writeMessageEnd()
3299 
    self._oprot.trans.flush()
3300 
 
3301 
  def recv_getInsurer(self, ):
3302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3303 
    if mtype == TMessageType.EXCEPTION:
3304 
      x = TApplicationException()
3305 
      x.read(self._iprot)
3306 
      self._iprot.readMessageEnd()
3307 
      raise x
3308 
    result = getInsurer_result()
3309 
    result.read(self._iprot)
3310 
    self._iprot.readMessageEnd()
3311 
    if result.success is not None:
3312 
      return result.success
3313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3314 
 
6838 vikram.rag 3315 
  def getAllInsurers(self, ):
3316 
    self.send_getAllInsurers()
3317 
    return self.recv_getAllInsurers()
6805 anupam.sin 3318 
 
6838 vikram.rag 3319 
  def send_getAllInsurers(self, ):
3320 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3321 
    args = getAllInsurers_args()
3322 
    args.write(self._oprot)
3323 
    self._oprot.writeMessageEnd()
3324 
    self._oprot.trans.flush()
3325 
 
3326 
  def recv_getAllInsurers(self, ):
3327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3328 
    if mtype == TMessageType.EXCEPTION:
3329 
      x = TApplicationException()
3330 
      x.read(self._iprot)
3331 
      self._iprot.readMessageEnd()
3332 
      raise x
3333 
    result = getAllInsurers_result()
3334 
    result.read(self._iprot)
3335 
    self._iprot.readMessageEnd()
3336 
    if result.success is not None:
3337 
      return result.success
3338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3339 
 
6962 rajveer 3340 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3341 
    """
3342 
    Parameters:
3343 
     - insurerId
3344 
     - amount
3345 
    """
3346 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3347 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3348 
 
6962 rajveer 3349 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3350 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3351 
    args = updateInsuranceDeclaredAmount_args()
3352 
    args.insurerId = insurerId
3353 
    args.amount = amount
3354 
    args.write(self._oprot)
3355 
    self._oprot.writeMessageEnd()
3356 
    self._oprot.trans.flush()
3357 
 
3358 
  def recv_updateInsuranceDeclaredAmount(self, ):
3359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3360 
    if mtype == TMessageType.EXCEPTION:
3361 
      x = TApplicationException()
3362 
      x.read(self._iprot)
3363 
      self._iprot.readMessageEnd()
3364 
      raise x
3365 
    result = updateInsuranceDeclaredAmount_result()
3366 
    result.read(self._iprot)
3367 
    self._iprot.readMessageEnd()
3368 
    return
3369 
 
7190 amar.kumar 3370 
  def getFreebieForItem(self, itemId):
3371 
    """
3372 
    Parameters:
3373 
     - itemId
3374 
    """
3375 
    self.send_getFreebieForItem(itemId)
3376 
    return self.recv_getFreebieForItem()
6962 rajveer 3377 
 
7190 amar.kumar 3378 
  def send_getFreebieForItem(self, itemId):
3379 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3380 
    args = getFreebieForItem_args()
3381 
    args.itemId = itemId
3382 
    args.write(self._oprot)
3383 
    self._oprot.writeMessageEnd()
3384 
    self._oprot.trans.flush()
3385 
 
3386 
  def recv_getFreebieForItem(self, ):
3387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3388 
    if mtype == TMessageType.EXCEPTION:
3389 
      x = TApplicationException()
3390 
      x.read(self._iprot)
3391 
      self._iprot.readMessageEnd()
3392 
      raise x
3393 
    result = getFreebieForItem_result()
3394 
    result.read(self._iprot)
3395 
    self._iprot.readMessageEnd()
3396 
    if result.success is not None:
3397 
      return result.success
3398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3399 
 
3400 
  def addOrUpdateFreebieForItem(self, freebieItem):
3401 
    """
3402 
    Parameters:
3403 
     - freebieItem
3404 
    """
3405 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3406 
    self.recv_addOrUpdateFreebieForItem()
3407 
 
3408 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3409 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3410 
    args = addOrUpdateFreebieForItem_args()
3411 
    args.freebieItem = freebieItem
3412 
    args.write(self._oprot)
3413 
    self._oprot.writeMessageEnd()
3414 
    self._oprot.trans.flush()
3415 
 
3416 
  def recv_addOrUpdateFreebieForItem(self, ):
3417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3418 
    if mtype == TMessageType.EXCEPTION:
3419 
      x = TApplicationException()
3420 
      x.read(self._iprot)
3421 
      self._iprot.readMessageEnd()
3422 
      raise x
3423 
    result = addOrUpdateFreebieForItem_result()
3424 
    result.read(self._iprot)
3425 
    self._iprot.readMessageEnd()
3426 
    return
3427 
 
7272 amit.gupta 3428 
  def addOrUpdateBrandInfo(self, brandInfo):
3429 
    """
3430 
    Parameters:
3431 
     - brandInfo
3432 
    """
3433 
    self.send_addOrUpdateBrandInfo(brandInfo)
3434 
    self.recv_addOrUpdateBrandInfo()
3435 
 
3436 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3437 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3438 
    args = addOrUpdateBrandInfo_args()
3439 
    args.brandInfo = brandInfo
3440 
    args.write(self._oprot)
3441 
    self._oprot.writeMessageEnd()
3442 
    self._oprot.trans.flush()
3443 
 
3444 
  def recv_addOrUpdateBrandInfo(self, ):
3445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3446 
    if mtype == TMessageType.EXCEPTION:
3447 
      x = TApplicationException()
3448 
      x.read(self._iprot)
3449 
      self._iprot.readMessageEnd()
3450 
      raise x
3451 
    result = addOrUpdateBrandInfo_result()
3452 
    result.read(self._iprot)
3453 
    self._iprot.readMessageEnd()
3454 
    return
3455 
 
3456 
  def getBrandInfo(self, ):
3457 
    self.send_getBrandInfo()
3458 
    return self.recv_getBrandInfo()
3459 
 
3460 
  def send_getBrandInfo(self, ):
3461 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3462 
    args = getBrandInfo_args()
3463 
    args.write(self._oprot)
3464 
    self._oprot.writeMessageEnd()
3465 
    self._oprot.trans.flush()
3466 
 
3467 
  def recv_getBrandInfo(self, ):
3468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3469 
    if mtype == TMessageType.EXCEPTION:
3470 
      x = TApplicationException()
3471 
      x.read(self._iprot)
3472 
      self._iprot.readMessageEnd()
3473 
      raise x
3474 
    result = getBrandInfo_result()
3475 
    result.read(self._iprot)
3476 
    self._iprot.readMessageEnd()
3477 
    if result.success is not None:
3478 
      return result.success
3479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3480 
 
7256 rajveer 3481 
  def getStorePricing(self, itemId):
3482 
    """
3483 
    Parameters:
3484 
     - itemId
3485 
    """
3486 
    self.send_getStorePricing(itemId)
3487 
    return self.recv_getStorePricing()
7190 amar.kumar 3488 
 
7256 rajveer 3489 
  def send_getStorePricing(self, itemId):
3490 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3491 
    args = getStorePricing_args()
3492 
    args.itemId = itemId
3493 
    args.write(self._oprot)
3494 
    self._oprot.writeMessageEnd()
3495 
    self._oprot.trans.flush()
3496 
 
3497 
  def recv_getStorePricing(self, ):
3498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3499 
    if mtype == TMessageType.EXCEPTION:
3500 
      x = TApplicationException()
3501 
      x.read(self._iprot)
3502 
      self._iprot.readMessageEnd()
3503 
      raise x
3504 
    result = getStorePricing_result()
3505 
    result.read(self._iprot)
3506 
    self._iprot.readMessageEnd()
3507 
    if result.success is not None:
3508 
      return result.success
3509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3510 
 
7306 rajveer 3511 
  def getStorePricings(self, itemIds):
3512 
    """
3513 
    Parameters:
3514 
     - itemIds
3515 
    """
3516 
    self.send_getStorePricings(itemIds)
3517 
    return self.recv_getStorePricings()
3518 
 
3519 
  def send_getStorePricings(self, itemIds):
3520 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3521 
    args = getStorePricings_args()
3522 
    args.itemIds = itemIds
3523 
    args.write(self._oprot)
3524 
    self._oprot.writeMessageEnd()
3525 
    self._oprot.trans.flush()
3526 
 
3527 
  def recv_getStorePricings(self, ):
3528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3529 
    if mtype == TMessageType.EXCEPTION:
3530 
      x = TApplicationException()
3531 
      x.read(self._iprot)
3532 
      self._iprot.readMessageEnd()
3533 
      raise x
3534 
    result = getStorePricings_result()
3535 
    result.read(self._iprot)
3536 
    self._iprot.readMessageEnd()
3537 
    if result.success is not None:
3538 
      return result.success
3539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3540 
 
7382 rajveer 3541 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3542 
    """
3543 
    Parameters:
3544 
     - sp
7382 rajveer 3545 
     - allColors
7265 rajveer 3546 
    """
7382 rajveer 3547 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3548 
    self.recv_updateStorePricing()
7256 rajveer 3549 
 
7382 rajveer 3550 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3551 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3552 
    args = updateStorePricing_args()
3553 
    args.sp = sp
7382 rajveer 3554 
    args.allColors = allColors
7265 rajveer 3555 
    args.write(self._oprot)
3556 
    self._oprot.writeMessageEnd()
3557 
    self._oprot.trans.flush()
3558 
 
3559 
  def recv_updateStorePricing(self, ):
3560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3561 
    if mtype == TMessageType.EXCEPTION:
3562 
      x = TApplicationException()
3563 
      x.read(self._iprot)
3564 
      self._iprot.readMessageEnd()
3565 
      raise x
3566 
    result = updateStorePricing_result()
3567 
    result.read(self._iprot)
3568 
    self._iprot.readMessageEnd()
3569 
    return
3570 
 
7281 kshitij.so 3571 
  def getAllAmazonListedItems(self, ):
3572 
    self.send_getAllAmazonListedItems()
3573 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3574 
 
7281 kshitij.so 3575 
  def send_getAllAmazonListedItems(self, ):
3576 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3577 
    args = getAllAmazonListedItems_args()
3578 
    args.write(self._oprot)
3579 
    self._oprot.writeMessageEnd()
3580 
    self._oprot.trans.flush()
3581 
 
3582 
  def recv_getAllAmazonListedItems(self, ):
3583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3584 
    if mtype == TMessageType.EXCEPTION:
3585 
      x = TApplicationException()
3586 
      x.read(self._iprot)
3587 
      self._iprot.readMessageEnd()
3588 
      raise x
3589 
    result = getAllAmazonListedItems_result()
3590 
    result.read(self._iprot)
3591 
    self._iprot.readMessageEnd()
3592 
    if result.success is not None:
3593 
      return result.success
3594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3595 
 
3596 
  def getAmazonItemDetails(self, itemId):
3597 
    """
3598 
    Parameters:
3599 
     - itemId
3600 
    """
3601 
    self.send_getAmazonItemDetails(itemId)
3602 
    return self.recv_getAmazonItemDetails()
3603 
 
3604 
  def send_getAmazonItemDetails(self, itemId):
3605 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3606 
    args = getAmazonItemDetails_args()
3607 
    args.itemId = itemId
3608 
    args.write(self._oprot)
3609 
    self._oprot.writeMessageEnd()
3610 
    self._oprot.trans.flush()
3611 
 
3612 
  def recv_getAmazonItemDetails(self, ):
3613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3614 
    if mtype == TMessageType.EXCEPTION:
3615 
      x = TApplicationException()
3616 
      x.read(self._iprot)
3617 
      self._iprot.readMessageEnd()
3618 
      raise x
3619 
    result = getAmazonItemDetails_result()
3620 
    result.read(self._iprot)
3621 
    self._iprot.readMessageEnd()
3622 
    if result.success is not None:
3623 
      return result.success
3624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3625 
 
7367 kshitij.so 3626 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3627 
    """
3628 
    Parameters:
3629 
     - itemId
3630 
     - fbaPrice
3631 
     - sellingPrice
3632 
     - isFba
3633 
     - isNonFba
3634 
     - isInventoryOverride
7367 kshitij.so 3635 
     - handlingTime
3636 
     - isCustomTime
7281 kshitij.so 3637 
    """
7367 kshitij.so 3638 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3639 
    self.recv_updateAmazonItemDetails()
3640 
 
7367 kshitij.so 3641 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3642 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3643 
    args = updateAmazonItemDetails_args()
3644 
    args.itemId = itemId
3645 
    args.fbaPrice = fbaPrice
3646 
    args.sellingPrice = sellingPrice
3647 
    args.isFba = isFba
3648 
    args.isNonFba = isNonFba
3649 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3650 
    args.handlingTime = handlingTime
3651 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3652 
    args.write(self._oprot)
3653 
    self._oprot.writeMessageEnd()
3654 
    self._oprot.trans.flush()
3655 
 
3656 
  def recv_updateAmazonItemDetails(self, ):
3657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3658 
    if mtype == TMessageType.EXCEPTION:
3659 
      x = TApplicationException()
3660 
      x.read(self._iprot)
3661 
      self._iprot.readMessageEnd()
3662 
      raise x
3663 
    result = updateAmazonItemDetails_result()
3664 
    result.read(self._iprot)
3665 
    self._iprot.readMessageEnd()
3666 
    return
3667 
 
3668 
  def addAmazonItem(self, amazonlisted):
3669 
    """
3670 
    Parameters:
3671 
     - amazonlisted
3672 
    """
3673 
    self.send_addAmazonItem(amazonlisted)
3674 
    self.recv_addAmazonItem()
3675 
 
3676 
  def send_addAmazonItem(self, amazonlisted):
3677 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3678 
    args = addAmazonItem_args()
3679 
    args.amazonlisted = amazonlisted
3680 
    args.write(self._oprot)
3681 
    self._oprot.writeMessageEnd()
3682 
    self._oprot.trans.flush()
3683 
 
3684 
  def recv_addAmazonItem(self, ):
3685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3686 
    if mtype == TMessageType.EXCEPTION:
3687 
      x = TApplicationException()
3688 
      x.read(self._iprot)
3689 
      self._iprot.readMessageEnd()
3690 
      raise x
3691 
    result = addAmazonItem_result()
3692 
    result.read(self._iprot)
3693 
    self._iprot.readMessageEnd()
3694 
    return
3695 
 
7291 vikram.rag 3696 
  def getAsinItems(self, ):
3697 
    self.send_getAsinItems()
3698 
    return self.recv_getAsinItems()
7281 kshitij.so 3699 
 
7291 vikram.rag 3700 
  def send_getAsinItems(self, ):
3701 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3702 
    args = getAsinItems_args()
3703 
    args.write(self._oprot)
3704 
    self._oprot.writeMessageEnd()
3705 
    self._oprot.trans.flush()
3706 
 
3707 
  def recv_getAsinItems(self, ):
3708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3709 
    if mtype == TMessageType.EXCEPTION:
3710 
      x = TApplicationException()
3711 
      x.read(self._iprot)
3712 
      self._iprot.readMessageEnd()
3713 
      raise x
3714 
    result = getAsinItems_result()
3715 
    result.read(self._iprot)
3716 
    self._iprot.readMessageEnd()
3717 
    if result.success is not None:
3718 
      return result.success
3719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3720 
 
3721 
  def getAllFbaListedItems(self, ):
3722 
    self.send_getAllFbaListedItems()
3723 
    return self.recv_getAllFbaListedItems()
3724 
 
3725 
  def send_getAllFbaListedItems(self, ):
3726 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3727 
    args = getAllFbaListedItems_args()
3728 
    args.write(self._oprot)
3729 
    self._oprot.writeMessageEnd()
3730 
    self._oprot.trans.flush()
3731 
 
3732 
  def recv_getAllFbaListedItems(self, ):
3733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3734 
    if mtype == TMessageType.EXCEPTION:
3735 
      x = TApplicationException()
3736 
      x.read(self._iprot)
3737 
      self._iprot.readMessageEnd()
3738 
      raise x
3739 
    result = getAllFbaListedItems_result()
3740 
    result.read(self._iprot)
3741 
    self._iprot.readMessageEnd()
3742 
    if result.success is not None:
3743 
      return result.success
3744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3745 
 
3746 
  def getAllNonFbaListedItems(self, ):
3747 
    self.send_getAllNonFbaListedItems()
3748 
    return self.recv_getAllNonFbaListedItems()
3749 
 
3750 
  def send_getAllNonFbaListedItems(self, ):
3751 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3752 
    args = getAllNonFbaListedItems_args()
3753 
    args.write(self._oprot)
3754 
    self._oprot.writeMessageEnd()
3755 
    self._oprot.trans.flush()
3756 
 
3757 
  def recv_getAllNonFbaListedItems(self, ):
3758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3759 
    if mtype == TMessageType.EXCEPTION:
3760 
      x = TApplicationException()
3761 
      x.read(self._iprot)
3762 
      self._iprot.readMessageEnd()
3763 
      raise x
3764 
    result = getAllNonFbaListedItems_result()
3765 
    result.read(self._iprot)
3766 
    self._iprot.readMessageEnd()
3767 
    if result.success is not None:
3768 
      return result.success
3769 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3770 
 
3771 
 
5944 mandeep.dh 3772 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3773 
  def __init__(self, handler):
3774 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3775 
    self._processMap["addItem"] = Processor.process_addItem
3776 
    self._processMap["updateItem"] = Processor.process_updateItem
3777 
    self._processMap["isActive"] = Processor.process_isActive
3778 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3779 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3780 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3781 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3782 
    self._processMap["getItem"] = Processor.process_getItem
3783 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3784 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3785 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3786 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3787 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3788 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3789 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3790 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3791 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3792 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3793 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3794 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3795 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3796 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3797 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3798 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3799 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3800 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3801 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3802 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3803 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3804 
    self._processMap["addCategory"] = Processor.process_addCategory
3805 
    self._processMap["getCategory"] = Processor.process_getCategory
3806 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3807 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3808 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3809 
    self._processMap["addTag"] = Processor.process_addTag
3810 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3811 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3812 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3813 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3814 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3815 
    self._processMap["addBanner"] = Processor.process_addBanner
3816 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3817 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3818 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3819 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3820 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3821 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3822 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3823 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3824 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3825 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3826 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3827 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3828 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3829 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3830 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3831 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3832 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3833 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3834 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3835 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3836 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3837 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3838 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3839 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3840 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3841 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3842 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3843 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3844 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3845 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3846 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3847 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3848 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3849 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3850 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3851 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3852 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3853 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3854 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3855 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3856 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3857 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3858 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3859 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3860 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3861 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3862 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3863 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3864 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3865 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3866 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3867 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3868 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3869 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3870 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
5944 mandeep.dh 3871 
 
3872 
  def process(self, iprot, oprot):
3873 
    (name, type, seqid) = iprot.readMessageBegin()
3874 
    if name not in self._processMap:
3875 
      iprot.skip(TType.STRUCT)
3876 
      iprot.readMessageEnd()
3877 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3878 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3879 
      x.write(oprot)
3880 
      oprot.writeMessageEnd()
3881 
      oprot.trans.flush()
3882 
      return
3883 
    else:
3884 
      self._processMap[name](self, seqid, iprot, oprot)
3885 
    return True
3886 
 
3887 
  def process_addItem(self, seqid, iprot, oprot):
3888 
    args = addItem_args()
3889 
    args.read(iprot)
3890 
    iprot.readMessageEnd()
3891 
    result = addItem_result()
3892 
    try:
3893 
      result.success = self._handler.addItem(args.item)
3894 
    except CatalogServiceException, cex:
3895 
      result.cex = cex
3896 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3897 
    result.write(oprot)
3898 
    oprot.writeMessageEnd()
3899 
    oprot.trans.flush()
3900 
 
3901 
  def process_updateItem(self, seqid, iprot, oprot):
3902 
    args = updateItem_args()
3903 
    args.read(iprot)
3904 
    iprot.readMessageEnd()
3905 
    result = updateItem_result()
3906 
    try:
3907 
      result.success = self._handler.updateItem(args.item)
3908 
    except CatalogServiceException, cex:
3909 
      result.cex = cex
3910 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3911 
    result.write(oprot)
3912 
    oprot.writeMessageEnd()
3913 
    oprot.trans.flush()
3914 
 
3915 
  def process_isActive(self, seqid, iprot, oprot):
3916 
    args = isActive_args()
3917 
    args.read(iprot)
3918 
    iprot.readMessageEnd()
3919 
    result = isActive_result()
3920 
    try:
3921 
      result.success = self._handler.isActive(args.itemId)
3922 
    except CatalogServiceException, isex:
3923 
      result.isex = isex
3924 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3925 
    result.write(oprot)
3926 
    oprot.writeMessageEnd()
3927 
    oprot.trans.flush()
3928 
 
3929 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3930 
    args = getItemStatusDescription_args()
3931 
    args.read(iprot)
3932 
    iprot.readMessageEnd()
3933 
    result = getItemStatusDescription_result()
3934 
    try:
3935 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3936 
    except CatalogServiceException, isex:
3937 
      result.isex = isex
3938 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3939 
    result.write(oprot)
3940 
    oprot.writeMessageEnd()
3941 
    oprot.trans.flush()
3942 
 
3943 
  def process_startItemOn(self, seqid, iprot, oprot):
3944 
    args = startItemOn_args()
3945 
    args.read(iprot)
3946 
    iprot.readMessageEnd()
3947 
    result = startItemOn_result()
3948 
    try:
3949 
      self._handler.startItemOn(args.item_id, args.timestamp)
3950 
    except CatalogServiceException, cex:
3951 
      result.cex = cex
3952 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
3953 
    result.write(oprot)
3954 
    oprot.writeMessageEnd()
3955 
    oprot.trans.flush()
3956 
 
3957 
  def process_retireItemOn(self, seqid, iprot, oprot):
3958 
    args = retireItemOn_args()
3959 
    args.read(iprot)
3960 
    iprot.readMessageEnd()
3961 
    result = retireItemOn_result()
3962 
    try:
3963 
      self._handler.retireItemOn(args.item_id, args.timestamp)
3964 
    except CatalogServiceException, cex:
3965 
      result.cex = cex
3966 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
3967 
    result.write(oprot)
3968 
    oprot.writeMessageEnd()
3969 
    oprot.trans.flush()
3970 
 
3971 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3972 
    args = changeItemStatus_args()
3973 
    args.read(iprot)
3974 
    iprot.readMessageEnd()
3975 
    result = changeItemStatus_result()
3976 
    try:
3977 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
3978 
    except CatalogServiceException, cex:
3979 
      result.cex = cex
3980 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3981 
    result.write(oprot)
3982 
    oprot.writeMessageEnd()
3983 
    oprot.trans.flush()
3984 
 
3985 
  def process_getItem(self, seqid, iprot, oprot):
3986 
    args = getItem_args()
3987 
    args.read(iprot)
3988 
    iprot.readMessageEnd()
3989 
    result = getItem_result()
3990 
    try:
3991 
      result.success = self._handler.getItem(args.item_id)
3992 
    except CatalogServiceException, cex:
3993 
      result.cex = cex
3994 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
3995 
    result.write(oprot)
3996 
    oprot.writeMessageEnd()
3997 
    oprot.trans.flush()
3998 
 
3999 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4000 
    args = getItemsByCatalogId_args()
4001 
    args.read(iprot)
4002 
    iprot.readMessageEnd()
4003 
    result = getItemsByCatalogId_result()
4004 
    try:
4005 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4006 
    except CatalogServiceException, cex:
4007 
      result.cex = cex
4008 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4009 
    result.write(oprot)
4010 
    oprot.writeMessageEnd()
4011 
    oprot.trans.flush()
4012 
 
4013 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4014 
    args = getValidItemsByCatalogId_args()
4015 
    args.read(iprot)
4016 
    iprot.readMessageEnd()
4017 
    result = getValidItemsByCatalogId_result()
4018 
    try:
4019 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4020 
    except CatalogServiceException, cex:
4021 
      result.cex = cex
4022 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4023 
    result.write(oprot)
4024 
    oprot.writeMessageEnd()
4025 
    oprot.trans.flush()
4026 
 
4027 
  def process_getAllItems(self, seqid, iprot, oprot):
4028 
    args = getAllItems_args()
4029 
    args.read(iprot)
4030 
    iprot.readMessageEnd()
4031 
    result = getAllItems_result()
4032 
    try:
4033 
      result.success = self._handler.getAllItems(args.isActive)
4034 
    except CatalogServiceException, cex:
4035 
      result.cex = cex
4036 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4037 
    result.write(oprot)
4038 
    oprot.writeMessageEnd()
4039 
    oprot.trans.flush()
4040 
 
4041 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4042 
    args = getAllItemsByStatus_args()
4043 
    args.read(iprot)
4044 
    iprot.readMessageEnd()
4045 
    result = getAllItemsByStatus_result()
4046 
    try:
4047 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4048 
    except CatalogServiceException, cex:
4049 
      result.cex = cex
4050 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4051 
    result.write(oprot)
4052 
    oprot.writeMessageEnd()
4053 
    oprot.trans.flush()
4054 
 
4055 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4056 
    args = markItemAsContentComplete_args()
4057 
    args.read(iprot)
4058 
    iprot.readMessageEnd()
4059 
    result = markItemAsContentComplete_result()
4060 
    try:
4061 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4062 
    except CatalogServiceException, cex:
4063 
      result.cex = cex
4064 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
4068 
 
4069 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4070 
    args = getAllItemsInRange_args()
4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
4073 
    result = getAllItemsInRange_result()
4074 
    try:
4075 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4076 
    except CatalogServiceException, cex:
4077 
      result.cex = cex
4078 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
4083 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4084 
    args = getAllItemsByStatusInRange_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = getAllItemsByStatusInRange_result()
4088 
    try:
4089 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4090 
    except CatalogServiceException, cex:
4091 
      result.cex = cex
4092 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4093 
    result.write(oprot)
4094 
    oprot.writeMessageEnd()
4095 
    oprot.trans.flush()
4096 
 
4097 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4098 
    args = getItemCountByStatus_args()
4099 
    args.read(iprot)
4100 
    iprot.readMessageEnd()
4101 
    result = getItemCountByStatus_result()
4102 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4103 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4104 
    result.write(oprot)
4105 
    oprot.writeMessageEnd()
4106 
    oprot.trans.flush()
4107 
 
4108 
  def process_getBestSellers(self, seqid, iprot, oprot):
4109 
    args = getBestSellers_args()
4110 
    args.read(iprot)
4111 
    iprot.readMessageEnd()
4112 
    result = getBestSellers_result()
4113 
    try:
4114 
      result.success = self._handler.getBestSellers()
4115 
    except CatalogServiceException, isex:
4116 
      result.isex = isex
4117 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4118 
    result.write(oprot)
4119 
    oprot.writeMessageEnd()
4120 
    oprot.trans.flush()
4121 
 
4122 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4123 
    args = getBestSellersCatalogIds_args()
4124 
    args.read(iprot)
4125 
    iprot.readMessageEnd()
4126 
    result = getBestSellersCatalogIds_result()
4127 
    try:
4128 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4129 
    except CatalogServiceException, cex:
4130 
      result.cex = cex
4131 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4132 
    result.write(oprot)
4133 
    oprot.writeMessageEnd()
4134 
    oprot.trans.flush()
4135 
 
4136 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4137 
    args = getBestSellersCount_args()
4138 
    args.read(iprot)
4139 
    iprot.readMessageEnd()
4140 
    result = getBestSellersCount_result()
4141 
    try:
4142 
      result.success = self._handler.getBestSellersCount()
4143 
    except CatalogServiceException, cex:
4144 
      result.cex = cex
4145 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4146 
    result.write(oprot)
4147 
    oprot.writeMessageEnd()
4148 
    oprot.trans.flush()
4149 
 
4150 
  def process_getBestDeals(self, seqid, iprot, oprot):
4151 
    args = getBestDeals_args()
4152 
    args.read(iprot)
4153 
    iprot.readMessageEnd()
4154 
    result = getBestDeals_result()
4155 
    try:
4156 
      result.success = self._handler.getBestDeals()
4157 
    except CatalogServiceException, isex:
4158 
      result.isex = isex
4159 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4160 
    result.write(oprot)
4161 
    oprot.writeMessageEnd()
4162 
    oprot.trans.flush()
4163 
 
4164 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4165 
    args = getBestDealsCatalogIds_args()
4166 
    args.read(iprot)
4167 
    iprot.readMessageEnd()
4168 
    result = getBestDealsCatalogIds_result()
4169 
    try:
4170 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4171 
    except CatalogServiceException, cex:
4172 
      result.cex = cex
4173 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4174 
    result.write(oprot)
4175 
    oprot.writeMessageEnd()
4176 
    oprot.trans.flush()
4177 
 
4178 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4179 
    args = getBestDealsCount_args()
4180 
    args.read(iprot)
4181 
    iprot.readMessageEnd()
4182 
    result = getBestDealsCount_result()
4183 
    try:
4184 
      result.success = self._handler.getBestDealsCount()
4185 
    except CatalogServiceException, cex:
4186 
      result.cex = cex
4187 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4188 
    result.write(oprot)
4189 
    oprot.writeMessageEnd()
4190 
    oprot.trans.flush()
4191 
 
4192 
  def process_getComingSoon(self, seqid, iprot, oprot):
4193 
    args = getComingSoon_args()
4194 
    args.read(iprot)
4195 
    iprot.readMessageEnd()
4196 
    result = getComingSoon_result()
4197 
    try:
4198 
      result.success = self._handler.getComingSoon()
4199 
    except CatalogServiceException, isex:
4200 
      result.isex = isex
4201 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4202 
    result.write(oprot)
4203 
    oprot.writeMessageEnd()
4204 
    oprot.trans.flush()
4205 
 
4206 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4207 
    args = getComingSoonCatalogIds_args()
4208 
    args.read(iprot)
4209 
    iprot.readMessageEnd()
4210 
    result = getComingSoonCatalogIds_result()
4211 
    try:
4212 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4213 
    except CatalogServiceException, cex:
4214 
      result.cex = cex
4215 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4216 
    result.write(oprot)
4217 
    oprot.writeMessageEnd()
4218 
    oprot.trans.flush()
4219 
 
4220 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4221 
    args = getComingSoonCount_args()
4222 
    args.read(iprot)
4223 
    iprot.readMessageEnd()
4224 
    result = getComingSoonCount_result()
4225 
    try:
4226 
      result.success = self._handler.getComingSoonCount()
4227 
    except CatalogServiceException, cex:
4228 
      result.cex = cex
4229 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4230 
    result.write(oprot)
4231 
    oprot.writeMessageEnd()
4232 
    oprot.trans.flush()
4233 
 
4234 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4235 
    args = getLatestArrivals_args()
4236 
    args.read(iprot)
4237 
    iprot.readMessageEnd()
4238 
    result = getLatestArrivals_result()
4239 
    try:
4240 
      result.success = self._handler.getLatestArrivals()
4241 
    except CatalogServiceException, isex:
4242 
      result.isex = isex
4243 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4244 
    result.write(oprot)
4245 
    oprot.writeMessageEnd()
4246 
    oprot.trans.flush()
4247 
 
4248 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4249 
    args = getLatestArrivalsCatalogIds_args()
4250 
    args.read(iprot)
4251 
    iprot.readMessageEnd()
4252 
    result = getLatestArrivalsCatalogIds_result()
4253 
    try:
4254 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4255 
    except CatalogServiceException, cex:
4256 
      result.cex = cex
4257 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4258 
    result.write(oprot)
4259 
    oprot.writeMessageEnd()
4260 
    oprot.trans.flush()
4261 
 
4262 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4263 
    args = getLatestArrivalsCount_args()
4264 
    args.read(iprot)
4265 
    iprot.readMessageEnd()
4266 
    result = getLatestArrivalsCount_result()
4267 
    try:
4268 
      result.success = self._handler.getLatestArrivalsCount()
4269 
    except CatalogServiceException, cex:
4270 
      result.cex = cex
4271 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4272 
    result.write(oprot)
4273 
    oprot.writeMessageEnd()
4274 
    oprot.trans.flush()
4275 
 
4276 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4277 
    args = generateNewEntityID_args()
4278 
    args.read(iprot)
4279 
    iprot.readMessageEnd()
4280 
    result = generateNewEntityID_result()
4281 
    result.success = self._handler.generateNewEntityID()
4282 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4283 
    result.write(oprot)
4284 
    oprot.writeMessageEnd()
4285 
    oprot.trans.flush()
4286 
 
4287 
  def process_addCategory(self, seqid, iprot, oprot):
4288 
    args = addCategory_args()
4289 
    args.read(iprot)
4290 
    iprot.readMessageEnd()
4291 
    result = addCategory_result()
4292 
    result.success = self._handler.addCategory(args.category)
4293 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4294 
    result.write(oprot)
4295 
    oprot.writeMessageEnd()
4296 
    oprot.trans.flush()
4297 
 
4298 
  def process_getCategory(self, seqid, iprot, oprot):
4299 
    args = getCategory_args()
4300 
    args.read(iprot)
4301 
    iprot.readMessageEnd()
4302 
    result = getCategory_result()
4303 
    result.success = self._handler.getCategory(args.id)
4304 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4305 
    result.write(oprot)
4306 
    oprot.writeMessageEnd()
4307 
    oprot.trans.flush()
4308 
 
4309 
  def process_getAllCategories(self, seqid, iprot, oprot):
4310 
    args = getAllCategories_args()
4311 
    args.read(iprot)
4312 
    iprot.readMessageEnd()
4313 
    result = getAllCategories_result()
4314 
    result.success = self._handler.getAllCategories()
4315 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4316 
    result.write(oprot)
4317 
    oprot.writeMessageEnd()
4318 
    oprot.trans.flush()
4319 
 
4320 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4321 
    args = getAllSimilarItems_args()
4322 
    args.read(iprot)
4323 
    iprot.readMessageEnd()
4324 
    result = getAllSimilarItems_result()
4325 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4326 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4327 
    result.write(oprot)
4328 
    oprot.writeMessageEnd()
4329 
    oprot.trans.flush()
4330 
 
4331 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4332 
    args = addSimilarItem_args()
4333 
    args.read(iprot)
4334 
    iprot.readMessageEnd()
4335 
    result = addSimilarItem_result()
4336 
    try:
4337 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4338 
    except CatalogServiceException, cex:
4339 
      result.cex = cex
4340 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4341 
    result.write(oprot)
4342 
    oprot.writeMessageEnd()
4343 
    oprot.trans.flush()
4344 
 
6512 kshitij.so 4345 
  def process_addTag(self, seqid, iprot, oprot):
4346 
    args = addTag_args()
4347 
    args.read(iprot)
4348 
    iprot.readMessageEnd()
4349 
    result = addTag_result()
4350 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4351 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4352 
    result.write(oprot)
4353 
    oprot.writeMessageEnd()
4354 
    oprot.trans.flush()
4355 
 
4356 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4357 
    args = deleteEntityTag_args()
4358 
    args.read(iprot)
4359 
    iprot.readMessageEnd()
4360 
    result = deleteEntityTag_result()
4361 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4362 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4363 
    result.write(oprot)
4364 
    oprot.writeMessageEnd()
4365 
    oprot.trans.flush()
4366 
 
4367 
  def process_deleteTag(self, seqid, iprot, oprot):
4368 
    args = deleteTag_args()
4369 
    args.read(iprot)
4370 
    iprot.readMessageEnd()
4371 
    result = deleteTag_result()
4372 
    result.success = self._handler.deleteTag(args.displayName)
4373 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4374 
    result.write(oprot)
4375 
    oprot.writeMessageEnd()
4376 
    oprot.trans.flush()
4377 
 
4378 
  def process_getAllTags(self, seqid, iprot, oprot):
4379 
    args = getAllTags_args()
4380 
    args.read(iprot)
4381 
    iprot.readMessageEnd()
4382 
    result = getAllTags_result()
4383 
    result.success = self._handler.getAllTags()
4384 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4385 
    result.write(oprot)
4386 
    oprot.writeMessageEnd()
4387 
    oprot.trans.flush()
4388 
 
4389 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4390 
    args = getAllEntitiesByTagName_args()
4391 
    args.read(iprot)
4392 
    iprot.readMessageEnd()
4393 
    result = getAllEntitiesByTagName_result()
4394 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4395 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4396 
    result.write(oprot)
4397 
    oprot.writeMessageEnd()
4398 
    oprot.trans.flush()
4399 
 
6845 amit.gupta 4400 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4401 
    args = getAllEntityTags_args()
4402 
    args.read(iprot)
4403 
    iprot.readMessageEnd()
4404 
    result = getAllEntityTags_result()
4405 
    result.success = self._handler.getAllEntityTags()
4406 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4407 
    result.write(oprot)
4408 
    oprot.writeMessageEnd()
4409 
    oprot.trans.flush()
4410 
 
6850 kshitij.so 4411 
  def process_addBanner(self, seqid, iprot, oprot):
4412 
    args = addBanner_args()
4413 
    args.read(iprot)
4414 
    iprot.readMessageEnd()
4415 
    result = addBanner_result()
4416 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4417 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4418 
    result.write(oprot)
4419 
    oprot.writeMessageEnd()
4420 
    oprot.trans.flush()
4421 
 
4422 
  def process_getAllBanners(self, seqid, iprot, oprot):
4423 
    args = getAllBanners_args()
4424 
    args.read(iprot)
4425 
    iprot.readMessageEnd()
4426 
    result = getAllBanners_result()
4427 
    result.success = self._handler.getAllBanners()
4428 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4429 
    result.write(oprot)
4430 
    oprot.writeMessageEnd()
4431 
    oprot.trans.flush()
4432 
 
4433 
  def process_deleteBanner(self, seqid, iprot, oprot):
4434 
    args = deleteBanner_args()
4435 
    args.read(iprot)
4436 
    iprot.readMessageEnd()
4437 
    result = deleteBanner_result()
4438 
    result.success = self._handler.deleteBanner(args.bannerName)
4439 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4440 
    result.write(oprot)
4441 
    oprot.writeMessageEnd()
4442 
    oprot.trans.flush()
4443 
 
4444 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4445 
    args = getBannerDetails_args()
4446 
    args.read(iprot)
4447 
    iprot.readMessageEnd()
4448 
    result = getBannerDetails_result()
4449 
    result.success = self._handler.getBannerDetails(args.bannerName)
4450 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4451 
    result.write(oprot)
4452 
    oprot.writeMessageEnd()
4453 
    oprot.trans.flush()
4454 
 
4455 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4456 
    args = getActiveBanners_args()
4457 
    args.read(iprot)
4458 
    iprot.readMessageEnd()
4459 
    result = getActiveBanners_result()
4460 
    result.success = self._handler.getActiveBanners()
4461 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4462 
    result.write(oprot)
4463 
    oprot.writeMessageEnd()
4464 
    oprot.trans.flush()
4465 
 
6849 kshitij.so 4466 
  def process_addBannerMap(self, seqid, iprot, oprot):
4467 
    args = addBannerMap_args()
4468 
    args.read(iprot)
4469 
    iprot.readMessageEnd()
4470 
    result = addBannerMap_result()
4471 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4472 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4473 
    result.write(oprot)
4474 
    oprot.writeMessageEnd()
4475 
    oprot.trans.flush()
4476 
 
4477 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4478 
    args = deleteBannerMap_args()
4479 
    args.read(iprot)
4480 
    iprot.readMessageEnd()
4481 
    result = deleteBannerMap_result()
4482 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4483 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4484 
    result.write(oprot)
4485 
    oprot.writeMessageEnd()
4486 
    oprot.trans.flush()
4487 
 
4488 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4489 
    args = getBannerMapDetails_args()
4490 
    args.read(iprot)
4491 
    iprot.readMessageEnd()
4492 
    result = getBannerMapDetails_result()
4493 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4494 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4495 
    result.write(oprot)
4496 
    oprot.writeMessageEnd()
4497 
    oprot.trans.flush()
4498 
 
5944 mandeep.dh 4499 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4500 
    args = deleteSimilarItem_args()
4501 
    args.read(iprot)
4502 
    iprot.readMessageEnd()
4503 
    result = deleteSimilarItem_result()
4504 
    try:
4505 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4506 
    except CatalogServiceException, cex:
4507 
      result.cex = cex
4508 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4509 
    result.write(oprot)
4510 
    oprot.writeMessageEnd()
4511 
    oprot.trans.flush()
4512 
 
4513 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4514 
    args = checkSimilarItem_args()
4515 
    args.read(iprot)
4516 
    iprot.readMessageEnd()
4517 
    result = checkSimilarItem_result()
4518 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4519 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4520 
    result.write(oprot)
4521 
    oprot.writeMessageEnd()
4522 
    oprot.trans.flush()
4523 
 
4524 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4525 
    args = validateRiskyStatus_args()
4526 
    args.read(iprot)
4527 
    iprot.readMessageEnd()
4528 
    result = validateRiskyStatus_result()
4529 
    self._handler.validateRiskyStatus(args.itemId)
4530 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4531 
    result.write(oprot)
4532 
    oprot.writeMessageEnd()
4533 
    oprot.trans.flush()
4534 
 
4535 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4536 
    args = changeItemRiskyFlag_args()
4537 
    args.read(iprot)
4538 
    iprot.readMessageEnd()
4539 
    result = changeItemRiskyFlag_result()
4540 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4541 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4542 
    result.write(oprot)
4543 
    oprot.writeMessageEnd()
4544 
    oprot.trans.flush()
4545 
 
4546 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4547 
    args = getItemsByRiskyFlag_args()
4548 
    args.read(iprot)
4549 
    iprot.readMessageEnd()
4550 
    result = getItemsByRiskyFlag_result()
4551 
    result.success = self._handler.getItemsByRiskyFlag()
4552 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4553 
    result.write(oprot)
4554 
    oprot.writeMessageEnd()
4555 
    oprot.trans.flush()
4556 
 
4557 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4558 
    args = getItemsForMasterSheet_args()
4559 
    args.read(iprot)
4560 
    iprot.readMessageEnd()
4561 
    result = getItemsForMasterSheet_result()
4562 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4563 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4564 
    result.write(oprot)
4565 
    oprot.writeMessageEnd()
4566 
    oprot.trans.flush()
4567 
 
4568 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4569 
    args = getSimilarItemsCatalogIds_args()
4570 
    args.read(iprot)
4571 
    iprot.readMessageEnd()
4572 
    result = getSimilarItemsCatalogIds_result()
4573 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4574 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4575 
    result.write(oprot)
4576 
    oprot.writeMessageEnd()
4577 
    oprot.trans.flush()
4578 
 
4579 
  def process_addProductNotification(self, seqid, iprot, oprot):
4580 
    args = addProductNotification_args()
4581 
    args.read(iprot)
4582 
    iprot.readMessageEnd()
4583 
    result = addProductNotification_result()
4584 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4585 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4586 
    result.write(oprot)
4587 
    oprot.writeMessageEnd()
4588 
    oprot.trans.flush()
4589 
 
4590 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4591 
    args = sendProductNotifications_args()
4592 
    args.read(iprot)
4593 
    iprot.readMessageEnd()
4594 
    result = sendProductNotifications_result()
4595 
    result.success = self._handler.sendProductNotifications()
4596 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4597 
    result.write(oprot)
4598 
    oprot.writeMessageEnd()
4599 
    oprot.trans.flush()
4600 
 
4601 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4602 
    args = getAllBrandsByCategory_args()
4603 
    args.read(iprot)
4604 
    iprot.readMessageEnd()
4605 
    result = getAllBrandsByCategory_result()
4606 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4607 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4608 
    result.write(oprot)
4609 
    oprot.writeMessageEnd()
4610 
    oprot.trans.flush()
4611 
 
4612 
  def process_getAllBrands(self, seqid, iprot, oprot):
4613 
    args = getAllBrands_args()
4614 
    args.read(iprot)
4615 
    iprot.readMessageEnd()
4616 
    result = getAllBrands_result()
4617 
    result.success = self._handler.getAllBrands()
4618 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4619 
    result.write(oprot)
4620 
    oprot.writeMessageEnd()
4621 
    oprot.trans.flush()
4622 
 
4623 
  def process_getAllSources(self, seqid, iprot, oprot):
4624 
    args = getAllSources_args()
4625 
    args.read(iprot)
4626 
    iprot.readMessageEnd()
4627 
    result = getAllSources_result()
4628 
    result.success = self._handler.getAllSources()
4629 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4630 
    result.write(oprot)
4631 
    oprot.writeMessageEnd()
4632 
    oprot.trans.flush()
4633 
 
4634 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4635 
    args = getItemPricingBySource_args()
4636 
    args.read(iprot)
4637 
    iprot.readMessageEnd()
4638 
    result = getItemPricingBySource_result()
4639 
    try:
4640 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4641 
    except CatalogServiceException, cex:
4642 
      result.cex = cex
4643 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4644 
    result.write(oprot)
4645 
    oprot.writeMessageEnd()
4646 
    oprot.trans.flush()
4647 
 
4648 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4649 
    args = addSourceItemPricing_args()
4650 
    args.read(iprot)
4651 
    iprot.readMessageEnd()
4652 
    result = addSourceItemPricing_result()
4653 
    try:
4654 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4655 
    except CatalogServiceException, cex:
4656 
      result.cex = cex
4657 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4658 
    result.write(oprot)
4659 
    oprot.writeMessageEnd()
4660 
    oprot.trans.flush()
4661 
 
4662 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4663 
    args = getAllSourcePricing_args()
4664 
    args.read(iprot)
4665 
    iprot.readMessageEnd()
4666 
    result = getAllSourcePricing_result()
4667 
    try:
4668 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4669 
    except CatalogServiceException, cex:
4670 
      result.cex = cex
4671 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4672 
    result.write(oprot)
4673 
    oprot.writeMessageEnd()
4674 
    oprot.trans.flush()
4675 
 
4676 
  def process_getItemForSource(self, seqid, iprot, oprot):
4677 
    args = getItemForSource_args()
4678 
    args.read(iprot)
4679 
    iprot.readMessageEnd()
4680 
    result = getItemForSource_result()
4681 
    try:
4682 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4683 
    except CatalogServiceException, cex:
4684 
      result.cex = cex
4685 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4686 
    result.write(oprot)
4687 
    oprot.writeMessageEnd()
4688 
    oprot.trans.flush()
4689 
 
4690 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4691 
    args = searchItemsInRange_args()
4692 
    args.read(iprot)
4693 
    iprot.readMessageEnd()
4694 
    result = searchItemsInRange_result()
4695 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4696 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4697 
    result.write(oprot)
4698 
    oprot.writeMessageEnd()
4699 
    oprot.trans.flush()
4700 
 
4701 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4702 
    args = getSearchResultCount_args()
4703 
    args.read(iprot)
4704 
    iprot.readMessageEnd()
4705 
    result = getSearchResultCount_result()
4706 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4707 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4708 
    result.write(oprot)
4709 
    oprot.writeMessageEnd()
4710 
    oprot.trans.flush()
4711 
 
4712 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4713 
    args = getProductNotifications_args()
4714 
    args.read(iprot)
4715 
    iprot.readMessageEnd()
4716 
    result = getProductNotifications_result()
4717 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4718 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4719 
    result.write(oprot)
4720 
    oprot.writeMessageEnd()
4721 
    oprot.trans.flush()
4722 
 
4723 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4724 
    args = getProductNotificationRequestCount_args()
4725 
    args.read(iprot)
4726 
    iprot.readMessageEnd()
4727 
    result = getProductNotificationRequestCount_result()
4728 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4729 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4730 
    result.write(oprot)
4731 
    oprot.writeMessageEnd()
4732 
    oprot.trans.flush()
4733 
 
4734 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4735 
    args = addAuthorizationLog_args()
4736 
    args.read(iprot)
4737 
    iprot.readMessageEnd()
4738 
    result = addAuthorizationLog_result()
4739 
    try:
4740 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4741 
    except CatalogServiceException, cex:
4742 
      result.cex = cex
4743 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4744 
    result.write(oprot)
4745 
    oprot.writeMessageEnd()
4746 
    oprot.trans.flush()
4747 
 
4748 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4749 
    args = addupdateVoucherForItem_args()
4750 
    args.read(iprot)
4751 
    iprot.readMessageEnd()
4752 
    result = addupdateVoucherForItem_result()
4753 
    try:
4754 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4755 
    except CatalogServiceException, cex:
4756 
      result.cex = cex
4757 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4758 
    result.write(oprot)
4759 
    oprot.writeMessageEnd()
4760 
    oprot.trans.flush()
4761 
 
4762 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4763 
    args = deleteVoucherForItem_args()
4764 
    args.read(iprot)
4765 
    iprot.readMessageEnd()
4766 
    result = deleteVoucherForItem_result()
4767 
    try:
4768 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4769 
    except CatalogServiceException, cex:
4770 
      result.cex = cex
4771 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4772 
    result.write(oprot)
4773 
    oprot.writeMessageEnd()
4774 
    oprot.trans.flush()
4775 
 
4776 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4777 
    args = getVoucherAmount_args()
4778 
    args.read(iprot)
4779 
    iprot.readMessageEnd()
4780 
    result = getVoucherAmount_result()
4781 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4782 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4783 
    result.write(oprot)
4784 
    oprot.writeMessageEnd()
4785 
    oprot.trans.flush()
4786 
 
4787 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4788 
    args = getAllItemVouchers_args()
4789 
    args.read(iprot)
4790 
    iprot.readMessageEnd()
4791 
    result = getAllItemVouchers_result()
4792 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4793 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4794 
    result.write(oprot)
4795 
    oprot.writeMessageEnd()
4796 
    oprot.trans.flush()
4797 
 
4798 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4799 
    args = isValidCatalogItemId_args()
4800 
    args.read(iprot)
4801 
    iprot.readMessageEnd()
4802 
    result = isValidCatalogItemId_result()
4803 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4804 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4805 
    result.write(oprot)
4806 
    oprot.writeMessageEnd()
4807 
    oprot.trans.flush()
4808 
 
6039 amit.gupta 4809 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4810 
    args = getVatPercentageForItem_args()
4811 
    args.read(iprot)
4812 
    iprot.readMessageEnd()
4813 
    result = getVatPercentageForItem_result()
7340 amit.gupta 4814 
    try:
4815 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
4816 
    except CatalogServiceException, cex:
4817 
      result.cex = cex
6039 amit.gupta 4818 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4819 
    result.write(oprot)
4820 
    oprot.writeMessageEnd()
4821 
    oprot.trans.flush()
5944 mandeep.dh 4822 
 
6039 amit.gupta 4823 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4824 
    args = getVatAmountForItem_args()
4825 
    args.read(iprot)
4826 
    iprot.readMessageEnd()
4827 
    result = getVatAmountForItem_result()
4828 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4829 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4830 
    result.write(oprot)
4831 
    oprot.writeMessageEnd()
4832 
    oprot.trans.flush()
4833 
 
6531 vikram.rag 4834 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4835 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4836 
    args.read(iprot)
4837 
    iprot.readMessageEnd()
4838 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4839 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4840 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4841 
    result.write(oprot)
4842 
    oprot.writeMessageEnd()
4843 
    oprot.trans.flush()
6039 amit.gupta 4844 
 
6821 amar.kumar 4845 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4846 
    args = getAllAliveItems_args()
4847 
    args.read(iprot)
4848 
    iprot.readMessageEnd()
4849 
    result = getAllAliveItems_result()
4850 
    result.success = self._handler.getAllAliveItems()
4851 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4852 
    result.write(oprot)
4853 
    oprot.writeMessageEnd()
4854 
    oprot.trans.flush()
4855 
 
6805 anupam.sin 4856 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4857 
    args = getInsuranceAmount_args()
4858 
    args.read(iprot)
4859 
    iprot.readMessageEnd()
4860 
    result = getInsuranceAmount_result()
6921 anupam.sin 4861 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4862 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4863 
    result.write(oprot)
4864 
    oprot.writeMessageEnd()
4865 
    oprot.trans.flush()
6531 vikram.rag 4866 
 
6805 anupam.sin 4867 
  def process_getInsurer(self, seqid, iprot, oprot):
4868 
    args = getInsurer_args()
4869 
    args.read(iprot)
4870 
    iprot.readMessageEnd()
4871 
    result = getInsurer_result()
4872 
    result.success = self._handler.getInsurer(args.insurerId)
4873 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4874 
    result.write(oprot)
4875 
    oprot.writeMessageEnd()
4876 
    oprot.trans.flush()
4877 
 
6838 vikram.rag 4878 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4879 
    args = getAllInsurers_args()
4880 
    args.read(iprot)
4881 
    iprot.readMessageEnd()
4882 
    result = getAllInsurers_result()
4883 
    result.success = self._handler.getAllInsurers()
4884 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4885 
    result.write(oprot)
4886 
    oprot.writeMessageEnd()
4887 
    oprot.trans.flush()
6805 anupam.sin 4888 
 
6962 rajveer 4889 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4890 
    args = updateInsuranceDeclaredAmount_args()
4891 
    args.read(iprot)
4892 
    iprot.readMessageEnd()
4893 
    result = updateInsuranceDeclaredAmount_result()
4894 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4895 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4896 
    result.write(oprot)
4897 
    oprot.writeMessageEnd()
4898 
    oprot.trans.flush()
6838 vikram.rag 4899 
 
7190 amar.kumar 4900 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4901 
    args = getFreebieForItem_args()
4902 
    args.read(iprot)
4903 
    iprot.readMessageEnd()
4904 
    result = getFreebieForItem_result()
4905 
    result.success = self._handler.getFreebieForItem(args.itemId)
4906 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4907 
    result.write(oprot)
4908 
    oprot.writeMessageEnd()
4909 
    oprot.trans.flush()
6962 rajveer 4910 
 
7190 amar.kumar 4911 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4912 
    args = addOrUpdateFreebieForItem_args()
4913 
    args.read(iprot)
4914 
    iprot.readMessageEnd()
4915 
    result = addOrUpdateFreebieForItem_result()
4916 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4917 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4918 
    result.write(oprot)
4919 
    oprot.writeMessageEnd()
4920 
    oprot.trans.flush()
4921 
 
7272 amit.gupta 4922 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4923 
    args = addOrUpdateBrandInfo_args()
4924 
    args.read(iprot)
4925 
    iprot.readMessageEnd()
4926 
    result = addOrUpdateBrandInfo_result()
4927 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4928 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4929 
    result.write(oprot)
4930 
    oprot.writeMessageEnd()
4931 
    oprot.trans.flush()
4932 
 
4933 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4934 
    args = getBrandInfo_args()
4935 
    args.read(iprot)
4936 
    iprot.readMessageEnd()
4937 
    result = getBrandInfo_result()
4938 
    result.success = self._handler.getBrandInfo()
4939 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4940 
    result.write(oprot)
4941 
    oprot.writeMessageEnd()
4942 
    oprot.trans.flush()
4943 
 
7256 rajveer 4944 
  def process_getStorePricing(self, seqid, iprot, oprot):
4945 
    args = getStorePricing_args()
4946 
    args.read(iprot)
4947 
    iprot.readMessageEnd()
4948 
    result = getStorePricing_result()
4949 
    result.success = self._handler.getStorePricing(args.itemId)
4950 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
4951 
    result.write(oprot)
4952 
    oprot.writeMessageEnd()
4953 
    oprot.trans.flush()
7190 amar.kumar 4954 
 
7306 rajveer 4955 
  def process_getStorePricings(self, seqid, iprot, oprot):
4956 
    args = getStorePricings_args()
4957 
    args.read(iprot)
4958 
    iprot.readMessageEnd()
4959 
    result = getStorePricings_result()
4960 
    result.success = self._handler.getStorePricings(args.itemIds)
4961 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
4962 
    result.write(oprot)
4963 
    oprot.writeMessageEnd()
4964 
    oprot.trans.flush()
4965 
 
7265 rajveer 4966 
  def process_updateStorePricing(self, seqid, iprot, oprot):
4967 
    args = updateStorePricing_args()
4968 
    args.read(iprot)
4969 
    iprot.readMessageEnd()
4970 
    result = updateStorePricing_result()
7382 rajveer 4971 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 4972 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
4973 
    result.write(oprot)
4974 
    oprot.writeMessageEnd()
4975 
    oprot.trans.flush()
7256 rajveer 4976 
 
7281 kshitij.so 4977 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
4978 
    args = getAllAmazonListedItems_args()
4979 
    args.read(iprot)
4980 
    iprot.readMessageEnd()
4981 
    result = getAllAmazonListedItems_result()
4982 
    result.success = self._handler.getAllAmazonListedItems()
4983 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
4984 
    result.write(oprot)
4985 
    oprot.writeMessageEnd()
4986 
    oprot.trans.flush()
7265 rajveer 4987 
 
7281 kshitij.so 4988 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
4989 
    args = getAmazonItemDetails_args()
4990 
    args.read(iprot)
4991 
    iprot.readMessageEnd()
4992 
    result = getAmazonItemDetails_result()
4993 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
4994 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
4995 
    result.write(oprot)
4996 
    oprot.writeMessageEnd()
4997 
    oprot.trans.flush()
4998 
 
4999 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5000 
    args = updateAmazonItemDetails_args()
5001 
    args.read(iprot)
5002 
    iprot.readMessageEnd()
5003 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5004 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5005 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5006 
    result.write(oprot)
5007 
    oprot.writeMessageEnd()
5008 
    oprot.trans.flush()
5009 
 
5010 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5011 
    args = addAmazonItem_args()
5012 
    args.read(iprot)
5013 
    iprot.readMessageEnd()
5014 
    result = addAmazonItem_result()
5015 
    self._handler.addAmazonItem(args.amazonlisted)
5016 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5017 
    result.write(oprot)
5018 
    oprot.writeMessageEnd()
5019 
    oprot.trans.flush()
5020 
 
7291 vikram.rag 5021 
  def process_getAsinItems(self, seqid, iprot, oprot):
5022 
    args = getAsinItems_args()
5023 
    args.read(iprot)
5024 
    iprot.readMessageEnd()
5025 
    result = getAsinItems_result()
5026 
    result.success = self._handler.getAsinItems()
5027 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5028 
    result.write(oprot)
5029 
    oprot.writeMessageEnd()
5030 
    oprot.trans.flush()
7281 kshitij.so 5031 
 
7291 vikram.rag 5032 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5033 
    args = getAllFbaListedItems_args()
5034 
    args.read(iprot)
5035 
    iprot.readMessageEnd()
5036 
    result = getAllFbaListedItems_result()
5037 
    result.success = self._handler.getAllFbaListedItems()
5038 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5039 
    result.write(oprot)
5040 
    oprot.writeMessageEnd()
5041 
    oprot.trans.flush()
5042 
 
5043 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5044 
    args = getAllNonFbaListedItems_args()
5045 
    args.read(iprot)
5046 
    iprot.readMessageEnd()
5047 
    result = getAllNonFbaListedItems_result()
5048 
    result.success = self._handler.getAllNonFbaListedItems()
5049 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5050 
    result.write(oprot)
5051 
    oprot.writeMessageEnd()
5052 
    oprot.trans.flush()
5053 
 
5054 
 
5944 mandeep.dh 5055 
# HELPER FUNCTIONS AND STRUCTURES
5056 
 
5057 
class addItem_args:
5058 
  """
5059 
  Attributes:
5060 
   - item
5061 
  """
5062 
 
5063 
  thrift_spec = (
5064 
    None, # 0
5065 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5066 
  )
5067 
 
5068 
  def __init__(self, item=None,):
5069 
    self.item = item
5070 
 
5071 
  def read(self, iprot):
5072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5074 
      return
5075 
    iprot.readStructBegin()
5076 
    while True:
5077 
      (fname, ftype, fid) = iprot.readFieldBegin()
5078 
      if ftype == TType.STOP:
5079 
        break
5080 
      if fid == 1:
5081 
        if ftype == TType.STRUCT:
5082 
          self.item = Item()
5083 
          self.item.read(iprot)
5084 
        else:
5085 
          iprot.skip(ftype)
5086 
      else:
5087 
        iprot.skip(ftype)
5088 
      iprot.readFieldEnd()
5089 
    iprot.readStructEnd()
5090 
 
5091 
  def write(self, oprot):
5092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5094 
      return
5095 
    oprot.writeStructBegin('addItem_args')
5096 
    if self.item is not None:
5097 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5098 
      self.item.write(oprot)
5099 
      oprot.writeFieldEnd()
5100 
    oprot.writeFieldStop()
5101 
    oprot.writeStructEnd()
5102 
 
5103 
  def validate(self):
5104 
    return
5105 
 
5106 
 
5107 
  def __repr__(self):
5108 
    L = ['%s=%r' % (key, value)
5109 
      for key, value in self.__dict__.iteritems()]
5110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5111 
 
5112 
  def __eq__(self, other):
5113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5114 
 
5115 
  def __ne__(self, other):
5116 
    return not (self == other)
5117 
 
5118 
class addItem_result:
5119 
  """
5120 
  Attributes:
5121 
   - success
5122 
   - cex
5123 
  """
5124 
 
5125 
  thrift_spec = (
5126 
    (0, TType.I64, 'success', None, None, ), # 0
5127 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5128 
  )
5129 
 
5130 
  def __init__(self, success=None, cex=None,):
5131 
    self.success = success
5132 
    self.cex = cex
5133 
 
5134 
  def read(self, iprot):
5135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5137 
      return
5138 
    iprot.readStructBegin()
5139 
    while True:
5140 
      (fname, ftype, fid) = iprot.readFieldBegin()
5141 
      if ftype == TType.STOP:
5142 
        break
5143 
      if fid == 0:
5144 
        if ftype == TType.I64:
5145 
          self.success = iprot.readI64();
5146 
        else:
5147 
          iprot.skip(ftype)
5148 
      elif fid == 1:
5149 
        if ftype == TType.STRUCT:
5150 
          self.cex = CatalogServiceException()
5151 
          self.cex.read(iprot)
5152 
        else:
5153 
          iprot.skip(ftype)
5154 
      else:
5155 
        iprot.skip(ftype)
5156 
      iprot.readFieldEnd()
5157 
    iprot.readStructEnd()
5158 
 
5159 
  def write(self, oprot):
5160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5162 
      return
5163 
    oprot.writeStructBegin('addItem_result')
5164 
    if self.success is not None:
5165 
      oprot.writeFieldBegin('success', TType.I64, 0)
5166 
      oprot.writeI64(self.success)
5167 
      oprot.writeFieldEnd()
5168 
    if self.cex is not None:
5169 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5170 
      self.cex.write(oprot)
5171 
      oprot.writeFieldEnd()
5172 
    oprot.writeFieldStop()
5173 
    oprot.writeStructEnd()
5174 
 
5175 
  def validate(self):
5176 
    return
5177 
 
5178 
 
5179 
  def __repr__(self):
5180 
    L = ['%s=%r' % (key, value)
5181 
      for key, value in self.__dict__.iteritems()]
5182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5183 
 
5184 
  def __eq__(self, other):
5185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5186 
 
5187 
  def __ne__(self, other):
5188 
    return not (self == other)
5189 
 
5190 
class updateItem_args:
5191 
  """
5192 
  Attributes:
5193 
   - item
5194 
  """
5195 
 
5196 
  thrift_spec = (
5197 
    None, # 0
5198 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5199 
  )
5200 
 
5201 
  def __init__(self, item=None,):
5202 
    self.item = item
5203 
 
5204 
  def read(self, iprot):
5205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5207 
      return
5208 
    iprot.readStructBegin()
5209 
    while True:
5210 
      (fname, ftype, fid) = iprot.readFieldBegin()
5211 
      if ftype == TType.STOP:
5212 
        break
5213 
      if fid == 1:
5214 
        if ftype == TType.STRUCT:
5215 
          self.item = Item()
5216 
          self.item.read(iprot)
5217 
        else:
5218 
          iprot.skip(ftype)
5219 
      else:
5220 
        iprot.skip(ftype)
5221 
      iprot.readFieldEnd()
5222 
    iprot.readStructEnd()
5223 
 
5224 
  def write(self, oprot):
5225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5227 
      return
5228 
    oprot.writeStructBegin('updateItem_args')
5229 
    if self.item is not None:
5230 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5231 
      self.item.write(oprot)
5232 
      oprot.writeFieldEnd()
5233 
    oprot.writeFieldStop()
5234 
    oprot.writeStructEnd()
5235 
 
5236 
  def validate(self):
5237 
    return
5238 
 
5239 
 
5240 
  def __repr__(self):
5241 
    L = ['%s=%r' % (key, value)
5242 
      for key, value in self.__dict__.iteritems()]
5243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5244 
 
5245 
  def __eq__(self, other):
5246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5247 
 
5248 
  def __ne__(self, other):
5249 
    return not (self == other)
5250 
 
5251 
class updateItem_result:
5252 
  """
5253 
  Attributes:
5254 
   - success
5255 
   - cex
5256 
  """
5257 
 
5258 
  thrift_spec = (
5259 
    (0, TType.I64, 'success', None, None, ), # 0
5260 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5261 
  )
5262 
 
5263 
  def __init__(self, success=None, cex=None,):
5264 
    self.success = success
5265 
    self.cex = cex
5266 
 
5267 
  def read(self, iprot):
5268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5270 
      return
5271 
    iprot.readStructBegin()
5272 
    while True:
5273 
      (fname, ftype, fid) = iprot.readFieldBegin()
5274 
      if ftype == TType.STOP:
5275 
        break
5276 
      if fid == 0:
5277 
        if ftype == TType.I64:
5278 
          self.success = iprot.readI64();
5279 
        else:
5280 
          iprot.skip(ftype)
5281 
      elif fid == 1:
5282 
        if ftype == TType.STRUCT:
5283 
          self.cex = CatalogServiceException()
5284 
          self.cex.read(iprot)
5285 
        else:
5286 
          iprot.skip(ftype)
5287 
      else:
5288 
        iprot.skip(ftype)
5289 
      iprot.readFieldEnd()
5290 
    iprot.readStructEnd()
5291 
 
5292 
  def write(self, oprot):
5293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5295 
      return
5296 
    oprot.writeStructBegin('updateItem_result')
5297 
    if self.success is not None:
5298 
      oprot.writeFieldBegin('success', TType.I64, 0)
5299 
      oprot.writeI64(self.success)
5300 
      oprot.writeFieldEnd()
5301 
    if self.cex is not None:
5302 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5303 
      self.cex.write(oprot)
5304 
      oprot.writeFieldEnd()
5305 
    oprot.writeFieldStop()
5306 
    oprot.writeStructEnd()
5307 
 
5308 
  def validate(self):
5309 
    return
5310 
 
5311 
 
5312 
  def __repr__(self):
5313 
    L = ['%s=%r' % (key, value)
5314 
      for key, value in self.__dict__.iteritems()]
5315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5316 
 
5317 
  def __eq__(self, other):
5318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5319 
 
5320 
  def __ne__(self, other):
5321 
    return not (self == other)
5322 
 
5323 
class isActive_args:
5324 
  """
5325 
  Attributes:
5326 
   - itemId
5327 
  """
5328 
 
5329 
  thrift_spec = (
5330 
    None, # 0
5331 
    (1, TType.I64, 'itemId', None, None, ), # 1
5332 
  )
5333 
 
5334 
  def __init__(self, itemId=None,):
5335 
    self.itemId = itemId
5336 
 
5337 
  def read(self, iprot):
5338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5340 
      return
5341 
    iprot.readStructBegin()
5342 
    while True:
5343 
      (fname, ftype, fid) = iprot.readFieldBegin()
5344 
      if ftype == TType.STOP:
5345 
        break
5346 
      if fid == 1:
5347 
        if ftype == TType.I64:
5348 
          self.itemId = iprot.readI64();
5349 
        else:
5350 
          iprot.skip(ftype)
5351 
      else:
5352 
        iprot.skip(ftype)
5353 
      iprot.readFieldEnd()
5354 
    iprot.readStructEnd()
5355 
 
5356 
  def write(self, oprot):
5357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5359 
      return
5360 
    oprot.writeStructBegin('isActive_args')
5361 
    if self.itemId is not None:
5362 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5363 
      oprot.writeI64(self.itemId)
5364 
      oprot.writeFieldEnd()
5365 
    oprot.writeFieldStop()
5366 
    oprot.writeStructEnd()
5367 
 
5368 
  def validate(self):
5369 
    return
5370 
 
5371 
 
5372 
  def __repr__(self):
5373 
    L = ['%s=%r' % (key, value)
5374 
      for key, value in self.__dict__.iteritems()]
5375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5376 
 
5377 
  def __eq__(self, other):
5378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5379 
 
5380 
  def __ne__(self, other):
5381 
    return not (self == other)
5382 
 
5383 
class isActive_result:
5384 
  """
5385 
  Attributes:
5386 
   - success
5387 
   - isex
5388 
  """
5389 
 
5390 
  thrift_spec = (
5391 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5392 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5393 
  )
5394 
 
5395 
  def __init__(self, success=None, isex=None,):
5396 
    self.success = success
5397 
    self.isex = isex
5398 
 
5399 
  def read(self, iprot):
5400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5402 
      return
5403 
    iprot.readStructBegin()
5404 
    while True:
5405 
      (fname, ftype, fid) = iprot.readFieldBegin()
5406 
      if ftype == TType.STOP:
5407 
        break
5408 
      if fid == 0:
5409 
        if ftype == TType.STRUCT:
5410 
          self.success = ItemShippingInfo()
5411 
          self.success.read(iprot)
5412 
        else:
5413 
          iprot.skip(ftype)
5414 
      elif fid == 1:
5415 
        if ftype == TType.STRUCT:
5416 
          self.isex = CatalogServiceException()
5417 
          self.isex.read(iprot)
5418 
        else:
5419 
          iprot.skip(ftype)
5420 
      else:
5421 
        iprot.skip(ftype)
5422 
      iprot.readFieldEnd()
5423 
    iprot.readStructEnd()
5424 
 
5425 
  def write(self, oprot):
5426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5428 
      return
5429 
    oprot.writeStructBegin('isActive_result')
5430 
    if self.success is not None:
5431 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5432 
      self.success.write(oprot)
5433 
      oprot.writeFieldEnd()
5434 
    if self.isex is not None:
5435 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5436 
      self.isex.write(oprot)
5437 
      oprot.writeFieldEnd()
5438 
    oprot.writeFieldStop()
5439 
    oprot.writeStructEnd()
5440 
 
5441 
  def validate(self):
5442 
    return
5443 
 
5444 
 
5445 
  def __repr__(self):
5446 
    L = ['%s=%r' % (key, value)
5447 
      for key, value in self.__dict__.iteritems()]
5448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5449 
 
5450 
  def __eq__(self, other):
5451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5452 
 
5453 
  def __ne__(self, other):
5454 
    return not (self == other)
5455 
 
5456 
class getItemStatusDescription_args:
5457 
  """
5458 
  Attributes:
5459 
   - itemId
5460 
  """
5461 
 
5462 
  thrift_spec = (
5463 
    None, # 0
5464 
    (1, TType.I64, 'itemId', None, None, ), # 1
5465 
  )
5466 
 
5467 
  def __init__(self, itemId=None,):
5468 
    self.itemId = itemId
5469 
 
5470 
  def read(self, iprot):
5471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5473 
      return
5474 
    iprot.readStructBegin()
5475 
    while True:
5476 
      (fname, ftype, fid) = iprot.readFieldBegin()
5477 
      if ftype == TType.STOP:
5478 
        break
5479 
      if fid == 1:
5480 
        if ftype == TType.I64:
5481 
          self.itemId = iprot.readI64();
5482 
        else:
5483 
          iprot.skip(ftype)
5484 
      else:
5485 
        iprot.skip(ftype)
5486 
      iprot.readFieldEnd()
5487 
    iprot.readStructEnd()
5488 
 
5489 
  def write(self, oprot):
5490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5492 
      return
5493 
    oprot.writeStructBegin('getItemStatusDescription_args')
5494 
    if self.itemId is not None:
5495 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5496 
      oprot.writeI64(self.itemId)
5497 
      oprot.writeFieldEnd()
5498 
    oprot.writeFieldStop()
5499 
    oprot.writeStructEnd()
5500 
 
5501 
  def validate(self):
5502 
    return
5503 
 
5504 
 
5505 
  def __repr__(self):
5506 
    L = ['%s=%r' % (key, value)
5507 
      for key, value in self.__dict__.iteritems()]
5508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5509 
 
5510 
  def __eq__(self, other):
5511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5512 
 
5513 
  def __ne__(self, other):
5514 
    return not (self == other)
5515 
 
5516 
class getItemStatusDescription_result:
5517 
  """
5518 
  Attributes:
5519 
   - success
5520 
   - isex
5521 
  """
5522 
 
5523 
  thrift_spec = (
5524 
    (0, TType.STRING, 'success', None, None, ), # 0
5525 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5526 
  )
5527 
 
5528 
  def __init__(self, success=None, isex=None,):
5529 
    self.success = success
5530 
    self.isex = isex
5531 
 
5532 
  def read(self, iprot):
5533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5535 
      return
5536 
    iprot.readStructBegin()
5537 
    while True:
5538 
      (fname, ftype, fid) = iprot.readFieldBegin()
5539 
      if ftype == TType.STOP:
5540 
        break
5541 
      if fid == 0:
5542 
        if ftype == TType.STRING:
5543 
          self.success = iprot.readString();
5544 
        else:
5545 
          iprot.skip(ftype)
5546 
      elif fid == 1:
5547 
        if ftype == TType.STRUCT:
5548 
          self.isex = CatalogServiceException()
5549 
          self.isex.read(iprot)
5550 
        else:
5551 
          iprot.skip(ftype)
5552 
      else:
5553 
        iprot.skip(ftype)
5554 
      iprot.readFieldEnd()
5555 
    iprot.readStructEnd()
5556 
 
5557 
  def write(self, oprot):
5558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5560 
      return
5561 
    oprot.writeStructBegin('getItemStatusDescription_result')
5562 
    if self.success is not None:
5563 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5564 
      oprot.writeString(self.success)
5565 
      oprot.writeFieldEnd()
5566 
    if self.isex is not None:
5567 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5568 
      self.isex.write(oprot)
5569 
      oprot.writeFieldEnd()
5570 
    oprot.writeFieldStop()
5571 
    oprot.writeStructEnd()
5572 
 
5573 
  def validate(self):
5574 
    return
5575 
 
5576 
 
5577 
  def __repr__(self):
5578 
    L = ['%s=%r' % (key, value)
5579 
      for key, value in self.__dict__.iteritems()]
5580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5581 
 
5582 
  def __eq__(self, other):
5583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5584 
 
5585 
  def __ne__(self, other):
5586 
    return not (self == other)
5587 
 
5588 
class startItemOn_args:
5589 
  """
5590 
  Attributes:
5591 
   - item_id
5592 
   - timestamp
5593 
  """
5594 
 
5595 
  thrift_spec = (
5596 
    None, # 0
5597 
    (1, TType.I64, 'item_id', None, None, ), # 1
5598 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5599 
  )
5600 
 
5601 
  def __init__(self, item_id=None, timestamp=None,):
5602 
    self.item_id = item_id
5603 
    self.timestamp = timestamp
5604 
 
5605 
  def read(self, iprot):
5606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5608 
      return
5609 
    iprot.readStructBegin()
5610 
    while True:
5611 
      (fname, ftype, fid) = iprot.readFieldBegin()
5612 
      if ftype == TType.STOP:
5613 
        break
5614 
      if fid == 1:
5615 
        if ftype == TType.I64:
5616 
          self.item_id = iprot.readI64();
5617 
        else:
5618 
          iprot.skip(ftype)
5619 
      elif fid == 2:
5620 
        if ftype == TType.I64:
5621 
          self.timestamp = iprot.readI64();
5622 
        else:
5623 
          iprot.skip(ftype)
5624 
      else:
5625 
        iprot.skip(ftype)
5626 
      iprot.readFieldEnd()
5627 
    iprot.readStructEnd()
5628 
 
5629 
  def write(self, oprot):
5630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5632 
      return
5633 
    oprot.writeStructBegin('startItemOn_args')
5634 
    if self.item_id is not None:
5635 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5636 
      oprot.writeI64(self.item_id)
5637 
      oprot.writeFieldEnd()
5638 
    if self.timestamp is not None:
5639 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5640 
      oprot.writeI64(self.timestamp)
5641 
      oprot.writeFieldEnd()
5642 
    oprot.writeFieldStop()
5643 
    oprot.writeStructEnd()
5644 
 
5645 
  def validate(self):
5646 
    return
5647 
 
5648 
 
5649 
  def __repr__(self):
5650 
    L = ['%s=%r' % (key, value)
5651 
      for key, value in self.__dict__.iteritems()]
5652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5653 
 
5654 
  def __eq__(self, other):
5655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5656 
 
5657 
  def __ne__(self, other):
5658 
    return not (self == other)
5659 
 
5660 
class startItemOn_result:
5661 
  """
5662 
  Attributes:
5663 
   - cex
5664 
  """
5665 
 
5666 
  thrift_spec = (
5667 
    None, # 0
5668 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5669 
  )
5670 
 
5671 
  def __init__(self, cex=None,):
5672 
    self.cex = cex
5673 
 
5674 
  def read(self, iprot):
5675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5677 
      return
5678 
    iprot.readStructBegin()
5679 
    while True:
5680 
      (fname, ftype, fid) = iprot.readFieldBegin()
5681 
      if ftype == TType.STOP:
5682 
        break
5683 
      if fid == 1:
5684 
        if ftype == TType.STRUCT:
5685 
          self.cex = CatalogServiceException()
5686 
          self.cex.read(iprot)
5687 
        else:
5688 
          iprot.skip(ftype)
5689 
      else:
5690 
        iprot.skip(ftype)
5691 
      iprot.readFieldEnd()
5692 
    iprot.readStructEnd()
5693 
 
5694 
  def write(self, oprot):
5695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5697 
      return
5698 
    oprot.writeStructBegin('startItemOn_result')
5699 
    if self.cex is not None:
5700 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5701 
      self.cex.write(oprot)
5702 
      oprot.writeFieldEnd()
5703 
    oprot.writeFieldStop()
5704 
    oprot.writeStructEnd()
5705 
 
5706 
  def validate(self):
5707 
    return
5708 
 
5709 
 
5710 
  def __repr__(self):
5711 
    L = ['%s=%r' % (key, value)
5712 
      for key, value in self.__dict__.iteritems()]
5713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5714 
 
5715 
  def __eq__(self, other):
5716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5717 
 
5718 
  def __ne__(self, other):
5719 
    return not (self == other)
5720 
 
5721 
class retireItemOn_args:
5722 
  """
5723 
  Attributes:
5724 
   - item_id
5725 
   - timestamp
5726 
  """
5727 
 
5728 
  thrift_spec = (
5729 
    None, # 0
5730 
    (1, TType.I64, 'item_id', None, None, ), # 1
5731 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5732 
  )
5733 
 
5734 
  def __init__(self, item_id=None, timestamp=None,):
5735 
    self.item_id = item_id
5736 
    self.timestamp = timestamp
5737 
 
5738 
  def read(self, iprot):
5739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5741 
      return
5742 
    iprot.readStructBegin()
5743 
    while True:
5744 
      (fname, ftype, fid) = iprot.readFieldBegin()
5745 
      if ftype == TType.STOP:
5746 
        break
5747 
      if fid == 1:
5748 
        if ftype == TType.I64:
5749 
          self.item_id = iprot.readI64();
5750 
        else:
5751 
          iprot.skip(ftype)
5752 
      elif fid == 2:
5753 
        if ftype == TType.I64:
5754 
          self.timestamp = iprot.readI64();
5755 
        else:
5756 
          iprot.skip(ftype)
5757 
      else:
5758 
        iprot.skip(ftype)
5759 
      iprot.readFieldEnd()
5760 
    iprot.readStructEnd()
5761 
 
5762 
  def write(self, oprot):
5763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5765 
      return
5766 
    oprot.writeStructBegin('retireItemOn_args')
5767 
    if self.item_id is not None:
5768 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5769 
      oprot.writeI64(self.item_id)
5770 
      oprot.writeFieldEnd()
5771 
    if self.timestamp is not None:
5772 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5773 
      oprot.writeI64(self.timestamp)
5774 
      oprot.writeFieldEnd()
5775 
    oprot.writeFieldStop()
5776 
    oprot.writeStructEnd()
5777 
 
5778 
  def validate(self):
5779 
    return
5780 
 
5781 
 
5782 
  def __repr__(self):
5783 
    L = ['%s=%r' % (key, value)
5784 
      for key, value in self.__dict__.iteritems()]
5785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5786 
 
5787 
  def __eq__(self, other):
5788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5789 
 
5790 
  def __ne__(self, other):
5791 
    return not (self == other)
5792 
 
5793 
class retireItemOn_result:
5794 
  """
5795 
  Attributes:
5796 
   - cex
5797 
  """
5798 
 
5799 
  thrift_spec = (
5800 
    None, # 0
5801 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5802 
  )
5803 
 
5804 
  def __init__(self, cex=None,):
5805 
    self.cex = cex
5806 
 
5807 
  def read(self, iprot):
5808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5810 
      return
5811 
    iprot.readStructBegin()
5812 
    while True:
5813 
      (fname, ftype, fid) = iprot.readFieldBegin()
5814 
      if ftype == TType.STOP:
5815 
        break
5816 
      if fid == 1:
5817 
        if ftype == TType.STRUCT:
5818 
          self.cex = CatalogServiceException()
5819 
          self.cex.read(iprot)
5820 
        else:
5821 
          iprot.skip(ftype)
5822 
      else:
5823 
        iprot.skip(ftype)
5824 
      iprot.readFieldEnd()
5825 
    iprot.readStructEnd()
5826 
 
5827 
  def write(self, oprot):
5828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5830 
      return
5831 
    oprot.writeStructBegin('retireItemOn_result')
5832 
    if self.cex is not None:
5833 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5834 
      self.cex.write(oprot)
5835 
      oprot.writeFieldEnd()
5836 
    oprot.writeFieldStop()
5837 
    oprot.writeStructEnd()
5838 
 
5839 
  def validate(self):
5840 
    return
5841 
 
5842 
 
5843 
  def __repr__(self):
5844 
    L = ['%s=%r' % (key, value)
5845 
      for key, value in self.__dict__.iteritems()]
5846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5847 
 
5848 
  def __eq__(self, other):
5849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5850 
 
5851 
  def __ne__(self, other):
5852 
    return not (self == other)
5853 
 
5854 
class changeItemStatus_args:
5855 
  """
5856 
  Attributes:
5857 
   - item_id
5858 
   - timestamp
5859 
   - newstatus
5860 
  """
5861 
 
5862 
  thrift_spec = (
5863 
    None, # 0
5864 
    (1, TType.I64, 'item_id', None, None, ), # 1
5865 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5866 
    (3, TType.I32, 'newstatus', None, None, ), # 3
5867 
  )
5868 
 
5869 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
5870 
    self.item_id = item_id
5871 
    self.timestamp = timestamp
5872 
    self.newstatus = newstatus
5873 
 
5874 
  def read(self, iprot):
5875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5877 
      return
5878 
    iprot.readStructBegin()
5879 
    while True:
5880 
      (fname, ftype, fid) = iprot.readFieldBegin()
5881 
      if ftype == TType.STOP:
5882 
        break
5883 
      if fid == 1:
5884 
        if ftype == TType.I64:
5885 
          self.item_id = iprot.readI64();
5886 
        else:
5887 
          iprot.skip(ftype)
5888 
      elif fid == 2:
5889 
        if ftype == TType.I64:
5890 
          self.timestamp = iprot.readI64();
5891 
        else:
5892 
          iprot.skip(ftype)
5893 
      elif fid == 3:
5894 
        if ftype == TType.I32:
5895 
          self.newstatus = iprot.readI32();
5896 
        else:
5897 
          iprot.skip(ftype)
5898 
      else:
5899 
        iprot.skip(ftype)
5900 
      iprot.readFieldEnd()
5901 
    iprot.readStructEnd()
5902 
 
5903 
  def write(self, oprot):
5904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5906 
      return
5907 
    oprot.writeStructBegin('changeItemStatus_args')
5908 
    if self.item_id is not None:
5909 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5910 
      oprot.writeI64(self.item_id)
5911 
      oprot.writeFieldEnd()
5912 
    if self.timestamp is not None:
5913 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5914 
      oprot.writeI64(self.timestamp)
5915 
      oprot.writeFieldEnd()
5916 
    if self.newstatus is not None:
5917 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
5918 
      oprot.writeI32(self.newstatus)
5919 
      oprot.writeFieldEnd()
5920 
    oprot.writeFieldStop()
5921 
    oprot.writeStructEnd()
5922 
 
5923 
  def validate(self):
5924 
    return
5925 
 
5926 
 
5927 
  def __repr__(self):
5928 
    L = ['%s=%r' % (key, value)
5929 
      for key, value in self.__dict__.iteritems()]
5930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5931 
 
5932 
  def __eq__(self, other):
5933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5934 
 
5935 
  def __ne__(self, other):
5936 
    return not (self == other)
5937 
 
5938 
class changeItemStatus_result:
5939 
  """
5940 
  Attributes:
5941 
   - cex
5942 
  """
5943 
 
5944 
  thrift_spec = (
5945 
    None, # 0
5946 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5947 
  )
5948 
 
5949 
  def __init__(self, cex=None,):
5950 
    self.cex = cex
5951 
 
5952 
  def read(self, iprot):
5953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5955 
      return
5956 
    iprot.readStructBegin()
5957 
    while True:
5958 
      (fname, ftype, fid) = iprot.readFieldBegin()
5959 
      if ftype == TType.STOP:
5960 
        break
5961 
      if fid == 1:
5962 
        if ftype == TType.STRUCT:
5963 
          self.cex = CatalogServiceException()
5964 
          self.cex.read(iprot)
5965 
        else:
5966 
          iprot.skip(ftype)
5967 
      else:
5968 
        iprot.skip(ftype)
5969 
      iprot.readFieldEnd()
5970 
    iprot.readStructEnd()
5971 
 
5972 
  def write(self, oprot):
5973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5975 
      return
5976 
    oprot.writeStructBegin('changeItemStatus_result')
5977 
    if self.cex is not None:
5978 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5979 
      self.cex.write(oprot)
5980 
      oprot.writeFieldEnd()
5981 
    oprot.writeFieldStop()
5982 
    oprot.writeStructEnd()
5983 
 
5984 
  def validate(self):
5985 
    return
5986 
 
5987 
 
5988 
  def __repr__(self):
5989 
    L = ['%s=%r' % (key, value)
5990 
      for key, value in self.__dict__.iteritems()]
5991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5992 
 
5993 
  def __eq__(self, other):
5994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5995 
 
5996 
  def __ne__(self, other):
5997 
    return not (self == other)
5998 
 
5999 
class getItem_args:
6000 
  """
6001 
  Attributes:
6002 
   - item_id
6003 
  """
6004 
 
6005 
  thrift_spec = (
6006 
    None, # 0
6007 
    (1, TType.I64, 'item_id', None, None, ), # 1
6008 
  )
6009 
 
6010 
  def __init__(self, item_id=None,):
6011 
    self.item_id = item_id
6012 
 
6013 
  def read(self, iprot):
6014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6016 
      return
6017 
    iprot.readStructBegin()
6018 
    while True:
6019 
      (fname, ftype, fid) = iprot.readFieldBegin()
6020 
      if ftype == TType.STOP:
6021 
        break
6022 
      if fid == 1:
6023 
        if ftype == TType.I64:
6024 
          self.item_id = iprot.readI64();
6025 
        else:
6026 
          iprot.skip(ftype)
6027 
      else:
6028 
        iprot.skip(ftype)
6029 
      iprot.readFieldEnd()
6030 
    iprot.readStructEnd()
6031 
 
6032 
  def write(self, oprot):
6033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6035 
      return
6036 
    oprot.writeStructBegin('getItem_args')
6037 
    if self.item_id is not None:
6038 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6039 
      oprot.writeI64(self.item_id)
6040 
      oprot.writeFieldEnd()
6041 
    oprot.writeFieldStop()
6042 
    oprot.writeStructEnd()
6043 
 
6044 
  def validate(self):
6045 
    return
6046 
 
6047 
 
6048 
  def __repr__(self):
6049 
    L = ['%s=%r' % (key, value)
6050 
      for key, value in self.__dict__.iteritems()]
6051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6052 
 
6053 
  def __eq__(self, other):
6054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6055 
 
6056 
  def __ne__(self, other):
6057 
    return not (self == other)
6058 
 
6059 
class getItem_result:
6060 
  """
6061 
  Attributes:
6062 
   - success
6063 
   - cex
6064 
  """
6065 
 
6066 
  thrift_spec = (
6067 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6068 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6069 
  )
6070 
 
6071 
  def __init__(self, success=None, cex=None,):
6072 
    self.success = success
6073 
    self.cex = cex
6074 
 
6075 
  def read(self, iprot):
6076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6078 
      return
6079 
    iprot.readStructBegin()
6080 
    while True:
6081 
      (fname, ftype, fid) = iprot.readFieldBegin()
6082 
      if ftype == TType.STOP:
6083 
        break
6084 
      if fid == 0:
6085 
        if ftype == TType.STRUCT:
6086 
          self.success = Item()
6087 
          self.success.read(iprot)
6088 
        else:
6089 
          iprot.skip(ftype)
6090 
      elif fid == 1:
6091 
        if ftype == TType.STRUCT:
6092 
          self.cex = CatalogServiceException()
6093 
          self.cex.read(iprot)
6094 
        else:
6095 
          iprot.skip(ftype)
6096 
      else:
6097 
        iprot.skip(ftype)
6098 
      iprot.readFieldEnd()
6099 
    iprot.readStructEnd()
6100 
 
6101 
  def write(self, oprot):
6102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6104 
      return
6105 
    oprot.writeStructBegin('getItem_result')
6106 
    if self.success is not None:
6107 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6108 
      self.success.write(oprot)
6109 
      oprot.writeFieldEnd()
6110 
    if self.cex is not None:
6111 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6112 
      self.cex.write(oprot)
6113 
      oprot.writeFieldEnd()
6114 
    oprot.writeFieldStop()
6115 
    oprot.writeStructEnd()
6116 
 
6117 
  def validate(self):
6118 
    return
6119 
 
6120 
 
6121 
  def __repr__(self):
6122 
    L = ['%s=%r' % (key, value)
6123 
      for key, value in self.__dict__.iteritems()]
6124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6125 
 
6126 
  def __eq__(self, other):
6127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6128 
 
6129 
  def __ne__(self, other):
6130 
    return not (self == other)
6131 
 
6132 
class getItemsByCatalogId_args:
6133 
  """
6134 
  Attributes:
6135 
   - catalog_item_id
6136 
  """
6137 
 
6138 
  thrift_spec = (
6139 
    None, # 0
6140 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6141 
  )
6142 
 
6143 
  def __init__(self, catalog_item_id=None,):
6144 
    self.catalog_item_id = catalog_item_id
6145 
 
6146 
  def read(self, iprot):
6147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6149 
      return
6150 
    iprot.readStructBegin()
6151 
    while True:
6152 
      (fname, ftype, fid) = iprot.readFieldBegin()
6153 
      if ftype == TType.STOP:
6154 
        break
6155 
      if fid == 1:
6156 
        if ftype == TType.I64:
6157 
          self.catalog_item_id = iprot.readI64();
6158 
        else:
6159 
          iprot.skip(ftype)
6160 
      else:
6161 
        iprot.skip(ftype)
6162 
      iprot.readFieldEnd()
6163 
    iprot.readStructEnd()
6164 
 
6165 
  def write(self, oprot):
6166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6168 
      return
6169 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6170 
    if self.catalog_item_id is not None:
6171 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6172 
      oprot.writeI64(self.catalog_item_id)
6173 
      oprot.writeFieldEnd()
6174 
    oprot.writeFieldStop()
6175 
    oprot.writeStructEnd()
6176 
 
6177 
  def validate(self):
6178 
    return
6179 
 
6180 
 
6181 
  def __repr__(self):
6182 
    L = ['%s=%r' % (key, value)
6183 
      for key, value in self.__dict__.iteritems()]
6184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6185 
 
6186 
  def __eq__(self, other):
6187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6188 
 
6189 
  def __ne__(self, other):
6190 
    return not (self == other)
6191 
 
6192 
class getItemsByCatalogId_result:
6193 
  """
6194 
  Attributes:
6195 
   - success
6196 
   - cex
6197 
  """
6198 
 
6199 
  thrift_spec = (
6200 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6201 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6202 
  )
6203 
 
6204 
  def __init__(self, success=None, cex=None,):
6205 
    self.success = success
6206 
    self.cex = cex
6207 
 
6208 
  def read(self, iprot):
6209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6211 
      return
6212 
    iprot.readStructBegin()
6213 
    while True:
6214 
      (fname, ftype, fid) = iprot.readFieldBegin()
6215 
      if ftype == TType.STOP:
6216 
        break
6217 
      if fid == 0:
6218 
        if ftype == TType.LIST:
6219 
          self.success = []
6220 
          (_etype19, _size16) = iprot.readListBegin()
6221 
          for _i20 in xrange(_size16):
6222 
            _elem21 = Item()
6223 
            _elem21.read(iprot)
6224 
            self.success.append(_elem21)
6225 
          iprot.readListEnd()
6226 
        else:
6227 
          iprot.skip(ftype)
6228 
      elif fid == 1:
6229 
        if ftype == TType.STRUCT:
6230 
          self.cex = CatalogServiceException()
6231 
          self.cex.read(iprot)
6232 
        else:
6233 
          iprot.skip(ftype)
6234 
      else:
6235 
        iprot.skip(ftype)
6236 
      iprot.readFieldEnd()
6237 
    iprot.readStructEnd()
6238 
 
6239 
  def write(self, oprot):
6240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6242 
      return
6243 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6244 
    if self.success is not None:
6245 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6246 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6247 
      for iter22 in self.success:
6248 
        iter22.write(oprot)
6249 
      oprot.writeListEnd()
6250 
      oprot.writeFieldEnd()
6251 
    if self.cex is not None:
6252 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6253 
      self.cex.write(oprot)
6254 
      oprot.writeFieldEnd()
6255 
    oprot.writeFieldStop()
6256 
    oprot.writeStructEnd()
6257 
 
6258 
  def validate(self):
6259 
    return
6260 
 
6261 
 
6262 
  def __repr__(self):
6263 
    L = ['%s=%r' % (key, value)
6264 
      for key, value in self.__dict__.iteritems()]
6265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6266 
 
6267 
  def __eq__(self, other):
6268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6269 
 
6270 
  def __ne__(self, other):
6271 
    return not (self == other)
6272 
 
6273 
class getValidItemsByCatalogId_args:
6274 
  """
6275 
  Attributes:
6276 
   - catalog_item_id
6277 
  """
6278 
 
6279 
  thrift_spec = (
6280 
    None, # 0
6281 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6282 
  )
6283 
 
6284 
  def __init__(self, catalog_item_id=None,):
6285 
    self.catalog_item_id = catalog_item_id
6286 
 
6287 
  def read(self, iprot):
6288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6290 
      return
6291 
    iprot.readStructBegin()
6292 
    while True:
6293 
      (fname, ftype, fid) = iprot.readFieldBegin()
6294 
      if ftype == TType.STOP:
6295 
        break
6296 
      if fid == 1:
6297 
        if ftype == TType.I64:
6298 
          self.catalog_item_id = iprot.readI64();
6299 
        else:
6300 
          iprot.skip(ftype)
6301 
      else:
6302 
        iprot.skip(ftype)
6303 
      iprot.readFieldEnd()
6304 
    iprot.readStructEnd()
6305 
 
6306 
  def write(self, oprot):
6307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6309 
      return
6310 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6311 
    if self.catalog_item_id is not None:
6312 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6313 
      oprot.writeI64(self.catalog_item_id)
6314 
      oprot.writeFieldEnd()
6315 
    oprot.writeFieldStop()
6316 
    oprot.writeStructEnd()
6317 
 
6318 
  def validate(self):
6319 
    return
6320 
 
6321 
 
6322 
  def __repr__(self):
6323 
    L = ['%s=%r' % (key, value)
6324 
      for key, value in self.__dict__.iteritems()]
6325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6326 
 
6327 
  def __eq__(self, other):
6328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6329 
 
6330 
  def __ne__(self, other):
6331 
    return not (self == other)
6332 
 
6333 
class getValidItemsByCatalogId_result:
6334 
  """
6335 
  Attributes:
6336 
   - success
6337 
   - cex
6338 
  """
6339 
 
6340 
  thrift_spec = (
6341 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6342 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6343 
  )
6344 
 
6345 
  def __init__(self, success=None, cex=None,):
6346 
    self.success = success
6347 
    self.cex = cex
6348 
 
6349 
  def read(self, iprot):
6350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6352 
      return
6353 
    iprot.readStructBegin()
6354 
    while True:
6355 
      (fname, ftype, fid) = iprot.readFieldBegin()
6356 
      if ftype == TType.STOP:
6357 
        break
6358 
      if fid == 0:
6359 
        if ftype == TType.LIST:
6360 
          self.success = []
6361 
          (_etype26, _size23) = iprot.readListBegin()
6362 
          for _i27 in xrange(_size23):
6363 
            _elem28 = Item()
6364 
            _elem28.read(iprot)
6365 
            self.success.append(_elem28)
6366 
          iprot.readListEnd()
6367 
        else:
6368 
          iprot.skip(ftype)
6369 
      elif fid == 1:
6370 
        if ftype == TType.STRUCT:
6371 
          self.cex = CatalogServiceException()
6372 
          self.cex.read(iprot)
6373 
        else:
6374 
          iprot.skip(ftype)
6375 
      else:
6376 
        iprot.skip(ftype)
6377 
      iprot.readFieldEnd()
6378 
    iprot.readStructEnd()
6379 
 
6380 
  def write(self, oprot):
6381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6383 
      return
6384 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6385 
    if self.success is not None:
6386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6388 
      for iter29 in self.success:
6389 
        iter29.write(oprot)
6390 
      oprot.writeListEnd()
6391 
      oprot.writeFieldEnd()
6392 
    if self.cex is not None:
6393 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6394 
      self.cex.write(oprot)
6395 
      oprot.writeFieldEnd()
6396 
    oprot.writeFieldStop()
6397 
    oprot.writeStructEnd()
6398 
 
6399 
  def validate(self):
6400 
    return
6401 
 
6402 
 
6403 
  def __repr__(self):
6404 
    L = ['%s=%r' % (key, value)
6405 
      for key, value in self.__dict__.iteritems()]
6406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6407 
 
6408 
  def __eq__(self, other):
6409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6410 
 
6411 
  def __ne__(self, other):
6412 
    return not (self == other)
6413 
 
6414 
class getAllItems_args:
6415 
  """
6416 
  Attributes:
6417 
   - isActive
6418 
  """
6419 
 
6420 
  thrift_spec = (
6421 
    None, # 0
6422 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6423 
  )
6424 
 
6425 
  def __init__(self, isActive=None,):
6426 
    self.isActive = isActive
6427 
 
6428 
  def read(self, iprot):
6429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6431 
      return
6432 
    iprot.readStructBegin()
6433 
    while True:
6434 
      (fname, ftype, fid) = iprot.readFieldBegin()
6435 
      if ftype == TType.STOP:
6436 
        break
6437 
      if fid == 1:
6438 
        if ftype == TType.BOOL:
6439 
          self.isActive = iprot.readBool();
6440 
        else:
6441 
          iprot.skip(ftype)
6442 
      else:
6443 
        iprot.skip(ftype)
6444 
      iprot.readFieldEnd()
6445 
    iprot.readStructEnd()
6446 
 
6447 
  def write(self, oprot):
6448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6450 
      return
6451 
    oprot.writeStructBegin('getAllItems_args')
6452 
    if self.isActive is not None:
6453 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6454 
      oprot.writeBool(self.isActive)
6455 
      oprot.writeFieldEnd()
6456 
    oprot.writeFieldStop()
6457 
    oprot.writeStructEnd()
6458 
 
6459 
  def validate(self):
6460 
    return
6461 
 
6462 
 
6463 
  def __repr__(self):
6464 
    L = ['%s=%r' % (key, value)
6465 
      for key, value in self.__dict__.iteritems()]
6466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6467 
 
6468 
  def __eq__(self, other):
6469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6470 
 
6471 
  def __ne__(self, other):
6472 
    return not (self == other)
6473 
 
6474 
class getAllItems_result:
6475 
  """
6476 
  Attributes:
6477 
   - success
6478 
   - cex
6479 
  """
6480 
 
6481 
  thrift_spec = (
6482 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6483 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6484 
  )
6485 
 
6486 
  def __init__(self, success=None, cex=None,):
6487 
    self.success = success
6488 
    self.cex = cex
6489 
 
6490 
  def read(self, iprot):
6491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6493 
      return
6494 
    iprot.readStructBegin()
6495 
    while True:
6496 
      (fname, ftype, fid) = iprot.readFieldBegin()
6497 
      if ftype == TType.STOP:
6498 
        break
6499 
      if fid == 0:
6500 
        if ftype == TType.LIST:
6501 
          self.success = []
6502 
          (_etype33, _size30) = iprot.readListBegin()
6503 
          for _i34 in xrange(_size30):
6504 
            _elem35 = Item()
6505 
            _elem35.read(iprot)
6506 
            self.success.append(_elem35)
6507 
          iprot.readListEnd()
6508 
        else:
6509 
          iprot.skip(ftype)
6510 
      elif fid == 1:
6511 
        if ftype == TType.STRUCT:
6512 
          self.cex = CatalogServiceException()
6513 
          self.cex.read(iprot)
6514 
        else:
6515 
          iprot.skip(ftype)
6516 
      else:
6517 
        iprot.skip(ftype)
6518 
      iprot.readFieldEnd()
6519 
    iprot.readStructEnd()
6520 
 
6521 
  def write(self, oprot):
6522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6524 
      return
6525 
    oprot.writeStructBegin('getAllItems_result')
6526 
    if self.success is not None:
6527 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6528 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6529 
      for iter36 in self.success:
6530 
        iter36.write(oprot)
6531 
      oprot.writeListEnd()
6532 
      oprot.writeFieldEnd()
6533 
    if self.cex is not None:
6534 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6535 
      self.cex.write(oprot)
6536 
      oprot.writeFieldEnd()
6537 
    oprot.writeFieldStop()
6538 
    oprot.writeStructEnd()
6539 
 
6540 
  def validate(self):
6541 
    return
6542 
 
6543 
 
6544 
  def __repr__(self):
6545 
    L = ['%s=%r' % (key, value)
6546 
      for key, value in self.__dict__.iteritems()]
6547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6548 
 
6549 
  def __eq__(self, other):
6550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6551 
 
6552 
  def __ne__(self, other):
6553 
    return not (self == other)
6554 
 
6555 
class getAllItemsByStatus_args:
6556 
  """
6557 
  Attributes:
6558 
   - itemStatus
6559 
  """
6560 
 
6561 
  thrift_spec = (
6562 
    None, # 0
6563 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6564 
  )
6565 
 
6566 
  def __init__(self, itemStatus=None,):
6567 
    self.itemStatus = itemStatus
6568 
 
6569 
  def read(self, iprot):
6570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6572 
      return
6573 
    iprot.readStructBegin()
6574 
    while True:
6575 
      (fname, ftype, fid) = iprot.readFieldBegin()
6576 
      if ftype == TType.STOP:
6577 
        break
6578 
      if fid == 1:
6579 
        if ftype == TType.I32:
6580 
          self.itemStatus = iprot.readI32();
6581 
        else:
6582 
          iprot.skip(ftype)
6583 
      else:
6584 
        iprot.skip(ftype)
6585 
      iprot.readFieldEnd()
6586 
    iprot.readStructEnd()
6587 
 
6588 
  def write(self, oprot):
6589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6591 
      return
6592 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6593 
    if self.itemStatus is not None:
6594 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6595 
      oprot.writeI32(self.itemStatus)
6596 
      oprot.writeFieldEnd()
6597 
    oprot.writeFieldStop()
6598 
    oprot.writeStructEnd()
6599 
 
6600 
  def validate(self):
6601 
    return
6602 
 
6603 
 
6604 
  def __repr__(self):
6605 
    L = ['%s=%r' % (key, value)
6606 
      for key, value in self.__dict__.iteritems()]
6607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6608 
 
6609 
  def __eq__(self, other):
6610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6611 
 
6612 
  def __ne__(self, other):
6613 
    return not (self == other)
6614 
 
6615 
class getAllItemsByStatus_result:
6616 
  """
6617 
  Attributes:
6618 
   - success
6619 
   - cex
6620 
  """
6621 
 
6622 
  thrift_spec = (
6623 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6624 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6625 
  )
6626 
 
6627 
  def __init__(self, success=None, cex=None,):
6628 
    self.success = success
6629 
    self.cex = cex
6630 
 
6631 
  def read(self, iprot):
6632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6634 
      return
6635 
    iprot.readStructBegin()
6636 
    while True:
6637 
      (fname, ftype, fid) = iprot.readFieldBegin()
6638 
      if ftype == TType.STOP:
6639 
        break
6640 
      if fid == 0:
6641 
        if ftype == TType.LIST:
6642 
          self.success = []
6643 
          (_etype40, _size37) = iprot.readListBegin()
6644 
          for _i41 in xrange(_size37):
6645 
            _elem42 = Item()
6646 
            _elem42.read(iprot)
6647 
            self.success.append(_elem42)
6648 
          iprot.readListEnd()
6649 
        else:
6650 
          iprot.skip(ftype)
6651 
      elif fid == 1:
6652 
        if ftype == TType.STRUCT:
6653 
          self.cex = CatalogServiceException()
6654 
          self.cex.read(iprot)
6655 
        else:
6656 
          iprot.skip(ftype)
6657 
      else:
6658 
        iprot.skip(ftype)
6659 
      iprot.readFieldEnd()
6660 
    iprot.readStructEnd()
6661 
 
6662 
  def write(self, oprot):
6663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6665 
      return
6666 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6667 
    if self.success is not None:
6668 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6669 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6670 
      for iter43 in self.success:
6671 
        iter43.write(oprot)
6672 
      oprot.writeListEnd()
6673 
      oprot.writeFieldEnd()
6674 
    if self.cex is not None:
6675 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6676 
      self.cex.write(oprot)
6677 
      oprot.writeFieldEnd()
6678 
    oprot.writeFieldStop()
6679 
    oprot.writeStructEnd()
6680 
 
6681 
  def validate(self):
6682 
    return
6683 
 
6684 
 
6685 
  def __repr__(self):
6686 
    L = ['%s=%r' % (key, value)
6687 
      for key, value in self.__dict__.iteritems()]
6688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6689 
 
6690 
  def __eq__(self, other):
6691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6692 
 
6693 
  def __ne__(self, other):
6694 
    return not (self == other)
6695 
 
6696 
class markItemAsContentComplete_args:
6697 
  """
6698 
  Attributes:
6699 
   - entityId
6700 
   - category
6701 
   - brand
6702 
   - modelName
6703 
   - modelNumber
6704 
  """
6705 
 
6706 
  thrift_spec = (
6707 
    None, # 0
6708 
    (1, TType.I64, 'entityId', None, None, ), # 1
6709 
    (2, TType.I64, 'category', None, None, ), # 2
6710 
    (3, TType.STRING, 'brand', None, None, ), # 3
6711 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6712 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6713 
  )
6714 
 
6715 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6716 
    self.entityId = entityId
6717 
    self.category = category
6718 
    self.brand = brand
6719 
    self.modelName = modelName
6720 
    self.modelNumber = modelNumber
6721 
 
6722 
  def read(self, iprot):
6723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6725 
      return
6726 
    iprot.readStructBegin()
6727 
    while True:
6728 
      (fname, ftype, fid) = iprot.readFieldBegin()
6729 
      if ftype == TType.STOP:
6730 
        break
6731 
      if fid == 1:
6732 
        if ftype == TType.I64:
6733 
          self.entityId = iprot.readI64();
6734 
        else:
6735 
          iprot.skip(ftype)
6736 
      elif fid == 2:
6737 
        if ftype == TType.I64:
6738 
          self.category = iprot.readI64();
6739 
        else:
6740 
          iprot.skip(ftype)
6741 
      elif fid == 3:
6742 
        if ftype == TType.STRING:
6743 
          self.brand = iprot.readString();
6744 
        else:
6745 
          iprot.skip(ftype)
6746 
      elif fid == 4:
6747 
        if ftype == TType.STRING:
6748 
          self.modelName = iprot.readString();
6749 
        else:
6750 
          iprot.skip(ftype)
6751 
      elif fid == 5:
6752 
        if ftype == TType.STRING:
6753 
          self.modelNumber = iprot.readString();
6754 
        else:
6755 
          iprot.skip(ftype)
6756 
      else:
6757 
        iprot.skip(ftype)
6758 
      iprot.readFieldEnd()
6759 
    iprot.readStructEnd()
6760 
 
6761 
  def write(self, oprot):
6762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6764 
      return
6765 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6766 
    if self.entityId is not None:
6767 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6768 
      oprot.writeI64(self.entityId)
6769 
      oprot.writeFieldEnd()
6770 
    if self.category is not None:
6771 
      oprot.writeFieldBegin('category', TType.I64, 2)
6772 
      oprot.writeI64(self.category)
6773 
      oprot.writeFieldEnd()
6774 
    if self.brand is not None:
6775 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6776 
      oprot.writeString(self.brand)
6777 
      oprot.writeFieldEnd()
6778 
    if self.modelName is not None:
6779 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6780 
      oprot.writeString(self.modelName)
6781 
      oprot.writeFieldEnd()
6782 
    if self.modelNumber is not None:
6783 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6784 
      oprot.writeString(self.modelNumber)
6785 
      oprot.writeFieldEnd()
6786 
    oprot.writeFieldStop()
6787 
    oprot.writeStructEnd()
6788 
 
6789 
  def validate(self):
6790 
    return
6791 
 
6792 
 
6793 
  def __repr__(self):
6794 
    L = ['%s=%r' % (key, value)
6795 
      for key, value in self.__dict__.iteritems()]
6796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6797 
 
6798 
  def __eq__(self, other):
6799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6800 
 
6801 
  def __ne__(self, other):
6802 
    return not (self == other)
6803 
 
6804 
class markItemAsContentComplete_result:
6805 
  """
6806 
  Attributes:
6807 
   - success
6808 
   - cex
6809 
  """
6810 
 
6811 
  thrift_spec = (
6812 
    (0, TType.BOOL, 'success', None, None, ), # 0
6813 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6814 
  )
6815 
 
6816 
  def __init__(self, success=None, cex=None,):
6817 
    self.success = success
6818 
    self.cex = cex
6819 
 
6820 
  def read(self, iprot):
6821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6823 
      return
6824 
    iprot.readStructBegin()
6825 
    while True:
6826 
      (fname, ftype, fid) = iprot.readFieldBegin()
6827 
      if ftype == TType.STOP:
6828 
        break
6829 
      if fid == 0:
6830 
        if ftype == TType.BOOL:
6831 
          self.success = iprot.readBool();
6832 
        else:
6833 
          iprot.skip(ftype)
6834 
      elif fid == 1:
6835 
        if ftype == TType.STRUCT:
6836 
          self.cex = CatalogServiceException()
6837 
          self.cex.read(iprot)
6838 
        else:
6839 
          iprot.skip(ftype)
6840 
      else:
6841 
        iprot.skip(ftype)
6842 
      iprot.readFieldEnd()
6843 
    iprot.readStructEnd()
6844 
 
6845 
  def write(self, oprot):
6846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6848 
      return
6849 
    oprot.writeStructBegin('markItemAsContentComplete_result')
6850 
    if self.success is not None:
6851 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6852 
      oprot.writeBool(self.success)
6853 
      oprot.writeFieldEnd()
6854 
    if self.cex is not None:
6855 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6856 
      self.cex.write(oprot)
6857 
      oprot.writeFieldEnd()
6858 
    oprot.writeFieldStop()
6859 
    oprot.writeStructEnd()
6860 
 
6861 
  def validate(self):
6862 
    return
6863 
 
6864 
 
6865 
  def __repr__(self):
6866 
    L = ['%s=%r' % (key, value)
6867 
      for key, value in self.__dict__.iteritems()]
6868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6869 
 
6870 
  def __eq__(self, other):
6871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6872 
 
6873 
  def __ne__(self, other):
6874 
    return not (self == other)
6875 
 
6876 
class getAllItemsInRange_args:
6877 
  """
6878 
  Attributes:
6879 
   - offset
6880 
   - limit
6881 
  """
6882 
 
6883 
  thrift_spec = (
6884 
    None, # 0
6885 
    (1, TType.I64, 'offset', None, None, ), # 1
6886 
    (2, TType.I64, 'limit', None, None, ), # 2
6887 
  )
6888 
 
6889 
  def __init__(self, offset=None, limit=None,):
6890 
    self.offset = offset
6891 
    self.limit = limit
6892 
 
6893 
  def read(self, iprot):
6894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6896 
      return
6897 
    iprot.readStructBegin()
6898 
    while True:
6899 
      (fname, ftype, fid) = iprot.readFieldBegin()
6900 
      if ftype == TType.STOP:
6901 
        break
6902 
      if fid == 1:
6903 
        if ftype == TType.I64:
6904 
          self.offset = iprot.readI64();
6905 
        else:
6906 
          iprot.skip(ftype)
6907 
      elif fid == 2:
6908 
        if ftype == TType.I64:
6909 
          self.limit = iprot.readI64();
6910 
        else:
6911 
          iprot.skip(ftype)
6912 
      else:
6913 
        iprot.skip(ftype)
6914 
      iprot.readFieldEnd()
6915 
    iprot.readStructEnd()
6916 
 
6917 
  def write(self, oprot):
6918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6920 
      return
6921 
    oprot.writeStructBegin('getAllItemsInRange_args')
6922 
    if self.offset is not None:
6923 
      oprot.writeFieldBegin('offset', TType.I64, 1)
6924 
      oprot.writeI64(self.offset)
6925 
      oprot.writeFieldEnd()
6926 
    if self.limit is not None:
6927 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6928 
      oprot.writeI64(self.limit)
6929 
      oprot.writeFieldEnd()
6930 
    oprot.writeFieldStop()
6931 
    oprot.writeStructEnd()
6932 
 
6933 
  def validate(self):
6934 
    return
6935 
 
6936 
 
6937 
  def __repr__(self):
6938 
    L = ['%s=%r' % (key, value)
6939 
      for key, value in self.__dict__.iteritems()]
6940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6941 
 
6942 
  def __eq__(self, other):
6943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6944 
 
6945 
  def __ne__(self, other):
6946 
    return not (self == other)
6947 
 
6948 
class getAllItemsInRange_result:
6949 
  """
6950 
  Attributes:
6951 
   - success
6952 
   - cex
6953 
  """
6954 
 
6955 
  thrift_spec = (
6956 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6957 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6958 
  )
6959 
 
6960 
  def __init__(self, success=None, cex=None,):
6961 
    self.success = success
6962 
    self.cex = cex
6963 
 
6964 
  def read(self, iprot):
6965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6967 
      return
6968 
    iprot.readStructBegin()
6969 
    while True:
6970 
      (fname, ftype, fid) = iprot.readFieldBegin()
6971 
      if ftype == TType.STOP:
6972 
        break
6973 
      if fid == 0:
6974 
        if ftype == TType.LIST:
6975 
          self.success = []
6976 
          (_etype47, _size44) = iprot.readListBegin()
6977 
          for _i48 in xrange(_size44):
6978 
            _elem49 = Item()
6979 
            _elem49.read(iprot)
6980 
            self.success.append(_elem49)
6981 
          iprot.readListEnd()
6982 
        else:
6983 
          iprot.skip(ftype)
6984 
      elif fid == 1:
6985 
        if ftype == TType.STRUCT:
6986 
          self.cex = CatalogServiceException()
6987 
          self.cex.read(iprot)
6988 
        else:
6989 
          iprot.skip(ftype)
6990 
      else:
6991 
        iprot.skip(ftype)
6992 
      iprot.readFieldEnd()
6993 
    iprot.readStructEnd()
6994 
 
6995 
  def write(self, oprot):
6996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6998 
      return
6999 
    oprot.writeStructBegin('getAllItemsInRange_result')
7000 
    if self.success is not None:
7001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7003 
      for iter50 in self.success:
7004 
        iter50.write(oprot)
7005 
      oprot.writeListEnd()
7006 
      oprot.writeFieldEnd()
7007 
    if self.cex is not None:
7008 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7009 
      self.cex.write(oprot)
7010 
      oprot.writeFieldEnd()
7011 
    oprot.writeFieldStop()
7012 
    oprot.writeStructEnd()
7013 
 
7014 
  def validate(self):
7015 
    return
7016 
 
7017 
 
7018 
  def __repr__(self):
7019 
    L = ['%s=%r' % (key, value)
7020 
      for key, value in self.__dict__.iteritems()]
7021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7022 
 
7023 
  def __eq__(self, other):
7024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7025 
 
7026 
  def __ne__(self, other):
7027 
    return not (self == other)
7028 
 
7029 
class getAllItemsByStatusInRange_args:
7030 
  """
7031 
  Attributes:
7032 
   - itemStatus
7033 
   - offset
7034 
   - limit
7035 
  """
7036 
 
7037 
  thrift_spec = (
7038 
    None, # 0
7039 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7040 
    (2, TType.I64, 'offset', None, None, ), # 2
7041 
    (3, TType.I64, 'limit', None, None, ), # 3
7042 
  )
7043 
 
7044 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7045 
    self.itemStatus = itemStatus
7046 
    self.offset = offset
7047 
    self.limit = limit
7048 
 
7049 
  def read(self, iprot):
7050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7052 
      return
7053 
    iprot.readStructBegin()
7054 
    while True:
7055 
      (fname, ftype, fid) = iprot.readFieldBegin()
7056 
      if ftype == TType.STOP:
7057 
        break
7058 
      if fid == 1:
7059 
        if ftype == TType.I32:
7060 
          self.itemStatus = iprot.readI32();
7061 
        else:
7062 
          iprot.skip(ftype)
7063 
      elif fid == 2:
7064 
        if ftype == TType.I64:
7065 
          self.offset = iprot.readI64();
7066 
        else:
7067 
          iprot.skip(ftype)
7068 
      elif fid == 3:
7069 
        if ftype == TType.I64:
7070 
          self.limit = iprot.readI64();
7071 
        else:
7072 
          iprot.skip(ftype)
7073 
      else:
7074 
        iprot.skip(ftype)
7075 
      iprot.readFieldEnd()
7076 
    iprot.readStructEnd()
7077 
 
7078 
  def write(self, oprot):
7079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7081 
      return
7082 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7083 
    if self.itemStatus is not None:
7084 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7085 
      oprot.writeI32(self.itemStatus)
7086 
      oprot.writeFieldEnd()
7087 
    if self.offset is not None:
7088 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7089 
      oprot.writeI64(self.offset)
7090 
      oprot.writeFieldEnd()
7091 
    if self.limit is not None:
7092 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7093 
      oprot.writeI64(self.limit)
7094 
      oprot.writeFieldEnd()
7095 
    oprot.writeFieldStop()
7096 
    oprot.writeStructEnd()
7097 
 
7098 
  def validate(self):
7099 
    return
7100 
 
7101 
 
7102 
  def __repr__(self):
7103 
    L = ['%s=%r' % (key, value)
7104 
      for key, value in self.__dict__.iteritems()]
7105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7106 
 
7107 
  def __eq__(self, other):
7108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7109 
 
7110 
  def __ne__(self, other):
7111 
    return not (self == other)
7112 
 
7113 
class getAllItemsByStatusInRange_result:
7114 
  """
7115 
  Attributes:
7116 
   - success
7117 
   - cex
7118 
  """
7119 
 
7120 
  thrift_spec = (
7121 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7122 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7123 
  )
7124 
 
7125 
  def __init__(self, success=None, cex=None,):
7126 
    self.success = success
7127 
    self.cex = cex
7128 
 
7129 
  def read(self, iprot):
7130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7132 
      return
7133 
    iprot.readStructBegin()
7134 
    while True:
7135 
      (fname, ftype, fid) = iprot.readFieldBegin()
7136 
      if ftype == TType.STOP:
7137 
        break
7138 
      if fid == 0:
7139 
        if ftype == TType.LIST:
7140 
          self.success = []
7141 
          (_etype54, _size51) = iprot.readListBegin()
7142 
          for _i55 in xrange(_size51):
7143 
            _elem56 = Item()
7144 
            _elem56.read(iprot)
7145 
            self.success.append(_elem56)
7146 
          iprot.readListEnd()
7147 
        else:
7148 
          iprot.skip(ftype)
7149 
      elif fid == 1:
7150 
        if ftype == TType.STRUCT:
7151 
          self.cex = CatalogServiceException()
7152 
          self.cex.read(iprot)
7153 
        else:
7154 
          iprot.skip(ftype)
7155 
      else:
7156 
        iprot.skip(ftype)
7157 
      iprot.readFieldEnd()
7158 
    iprot.readStructEnd()
7159 
 
7160 
  def write(self, oprot):
7161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7163 
      return
7164 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7165 
    if self.success is not None:
7166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7168 
      for iter57 in self.success:
7169 
        iter57.write(oprot)
7170 
      oprot.writeListEnd()
7171 
      oprot.writeFieldEnd()
7172 
    if self.cex is not None:
7173 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7174 
      self.cex.write(oprot)
7175 
      oprot.writeFieldEnd()
7176 
    oprot.writeFieldStop()
7177 
    oprot.writeStructEnd()
7178 
 
7179 
  def validate(self):
7180 
    return
7181 
 
7182 
 
7183 
  def __repr__(self):
7184 
    L = ['%s=%r' % (key, value)
7185 
      for key, value in self.__dict__.iteritems()]
7186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7187 
 
7188 
  def __eq__(self, other):
7189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7190 
 
7191 
  def __ne__(self, other):
7192 
    return not (self == other)
7193 
 
7194 
class getItemCountByStatus_args:
7195 
  """
7196 
  Attributes:
7197 
   - useStatus
7198 
   - itemStatus
7199 
  """
7200 
 
7201 
  thrift_spec = (
7202 
    None, # 0
7203 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7204 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7205 
  )
7206 
 
7207 
  def __init__(self, useStatus=None, itemStatus=None,):
7208 
    self.useStatus = useStatus
7209 
    self.itemStatus = itemStatus
7210 
 
7211 
  def read(self, iprot):
7212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7214 
      return
7215 
    iprot.readStructBegin()
7216 
    while True:
7217 
      (fname, ftype, fid) = iprot.readFieldBegin()
7218 
      if ftype == TType.STOP:
7219 
        break
7220 
      if fid == 1:
7221 
        if ftype == TType.BOOL:
7222 
          self.useStatus = iprot.readBool();
7223 
        else:
7224 
          iprot.skip(ftype)
7225 
      elif fid == 2:
7226 
        if ftype == TType.I32:
7227 
          self.itemStatus = iprot.readI32();
7228 
        else:
7229 
          iprot.skip(ftype)
7230 
      else:
7231 
        iprot.skip(ftype)
7232 
      iprot.readFieldEnd()
7233 
    iprot.readStructEnd()
7234 
 
7235 
  def write(self, oprot):
7236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7238 
      return
7239 
    oprot.writeStructBegin('getItemCountByStatus_args')
7240 
    if self.useStatus is not None:
7241 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7242 
      oprot.writeBool(self.useStatus)
7243 
      oprot.writeFieldEnd()
7244 
    if self.itemStatus is not None:
7245 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7246 
      oprot.writeI32(self.itemStatus)
7247 
      oprot.writeFieldEnd()
7248 
    oprot.writeFieldStop()
7249 
    oprot.writeStructEnd()
7250 
 
7251 
  def validate(self):
7252 
    return
7253 
 
7254 
 
7255 
  def __repr__(self):
7256 
    L = ['%s=%r' % (key, value)
7257 
      for key, value in self.__dict__.iteritems()]
7258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7259 
 
7260 
  def __eq__(self, other):
7261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7262 
 
7263 
  def __ne__(self, other):
7264 
    return not (self == other)
7265 
 
7266 
class getItemCountByStatus_result:
7267 
  """
7268 
  Attributes:
7269 
   - success
7270 
  """
7271 
 
7272 
  thrift_spec = (
7273 
    (0, TType.I32, 'success', None, None, ), # 0
7274 
  )
7275 
 
7276 
  def __init__(self, success=None,):
7277 
    self.success = success
7278 
 
7279 
  def read(self, iprot):
7280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7282 
      return
7283 
    iprot.readStructBegin()
7284 
    while True:
7285 
      (fname, ftype, fid) = iprot.readFieldBegin()
7286 
      if ftype == TType.STOP:
7287 
        break
7288 
      if fid == 0:
7289 
        if ftype == TType.I32:
7290 
          self.success = iprot.readI32();
7291 
        else:
7292 
          iprot.skip(ftype)
7293 
      else:
7294 
        iprot.skip(ftype)
7295 
      iprot.readFieldEnd()
7296 
    iprot.readStructEnd()
7297 
 
7298 
  def write(self, oprot):
7299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7301 
      return
7302 
    oprot.writeStructBegin('getItemCountByStatus_result')
7303 
    if self.success is not None:
7304 
      oprot.writeFieldBegin('success', TType.I32, 0)
7305 
      oprot.writeI32(self.success)
7306 
      oprot.writeFieldEnd()
7307 
    oprot.writeFieldStop()
7308 
    oprot.writeStructEnd()
7309 
 
7310 
  def validate(self):
7311 
    return
7312 
 
7313 
 
7314 
  def __repr__(self):
7315 
    L = ['%s=%r' % (key, value)
7316 
      for key, value in self.__dict__.iteritems()]
7317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7318 
 
7319 
  def __eq__(self, other):
7320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7321 
 
7322 
  def __ne__(self, other):
7323 
    return not (self == other)
7324 
 
7325 
class getBestSellers_args:
7326 
 
7327 
  thrift_spec = (
7328 
  )
7329 
 
7330 
  def read(self, iprot):
7331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7333 
      return
7334 
    iprot.readStructBegin()
7335 
    while True:
7336 
      (fname, ftype, fid) = iprot.readFieldBegin()
7337 
      if ftype == TType.STOP:
7338 
        break
7339 
      else:
7340 
        iprot.skip(ftype)
7341 
      iprot.readFieldEnd()
7342 
    iprot.readStructEnd()
7343 
 
7344 
  def write(self, oprot):
7345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7347 
      return
7348 
    oprot.writeStructBegin('getBestSellers_args')
7349 
    oprot.writeFieldStop()
7350 
    oprot.writeStructEnd()
7351 
 
7352 
  def validate(self):
7353 
    return
7354 
 
7355 
 
7356 
  def __repr__(self):
7357 
    L = ['%s=%r' % (key, value)
7358 
      for key, value in self.__dict__.iteritems()]
7359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7360 
 
7361 
  def __eq__(self, other):
7362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7363 
 
7364 
  def __ne__(self, other):
7365 
    return not (self == other)
7366 
 
7367 
class getBestSellers_result:
7368 
  """
7369 
  Attributes:
7370 
   - success
7371 
   - isex
7372 
  """
7373 
 
7374 
  thrift_spec = (
7375 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7376 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7377 
  )
7378 
 
7379 
  def __init__(self, success=None, isex=None,):
7380 
    self.success = success
7381 
    self.isex = isex
7382 
 
7383 
  def read(self, iprot):
7384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7386 
      return
7387 
    iprot.readStructBegin()
7388 
    while True:
7389 
      (fname, ftype, fid) = iprot.readFieldBegin()
7390 
      if ftype == TType.STOP:
7391 
        break
7392 
      if fid == 0:
7393 
        if ftype == TType.LIST:
7394 
          self.success = []
7395 
          (_etype61, _size58) = iprot.readListBegin()
7396 
          for _i62 in xrange(_size58):
7397 
            _elem63 = Item()
7398 
            _elem63.read(iprot)
7399 
            self.success.append(_elem63)
7400 
          iprot.readListEnd()
7401 
        else:
7402 
          iprot.skip(ftype)
7403 
      elif fid == 1:
7404 
        if ftype == TType.STRUCT:
7405 
          self.isex = CatalogServiceException()
7406 
          self.isex.read(iprot)
7407 
        else:
7408 
          iprot.skip(ftype)
7409 
      else:
7410 
        iprot.skip(ftype)
7411 
      iprot.readFieldEnd()
7412 
    iprot.readStructEnd()
7413 
 
7414 
  def write(self, oprot):
7415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7417 
      return
7418 
    oprot.writeStructBegin('getBestSellers_result')
7419 
    if self.success is not None:
7420 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7421 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7422 
      for iter64 in self.success:
7423 
        iter64.write(oprot)
7424 
      oprot.writeListEnd()
7425 
      oprot.writeFieldEnd()
7426 
    if self.isex is not None:
7427 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7428 
      self.isex.write(oprot)
7429 
      oprot.writeFieldEnd()
7430 
    oprot.writeFieldStop()
7431 
    oprot.writeStructEnd()
7432 
 
7433 
  def validate(self):
7434 
    return
7435 
 
7436 
 
7437 
  def __repr__(self):
7438 
    L = ['%s=%r' % (key, value)
7439 
      for key, value in self.__dict__.iteritems()]
7440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7441 
 
7442 
  def __eq__(self, other):
7443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7444 
 
7445 
  def __ne__(self, other):
7446 
    return not (self == other)
7447 
 
7448 
class getBestSellersCatalogIds_args:
7449 
  """
7450 
  Attributes:
7451 
   - beginIndex
7452 
   - totalItems
7453 
   - brand
7454 
   - category
7455 
  """
7456 
 
7457 
  thrift_spec = (
7458 
    None, # 0
7459 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7460 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7461 
    (3, TType.STRING, 'brand', None, None, ), # 3
7462 
    (4, TType.I64, 'category', None, None, ), # 4
7463 
  )
7464 
 
7465 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7466 
    self.beginIndex = beginIndex
7467 
    self.totalItems = totalItems
7468 
    self.brand = brand
7469 
    self.category = category
7470 
 
7471 
  def read(self, iprot):
7472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7474 
      return
7475 
    iprot.readStructBegin()
7476 
    while True:
7477 
      (fname, ftype, fid) = iprot.readFieldBegin()
7478 
      if ftype == TType.STOP:
7479 
        break
7480 
      if fid == 1:
7481 
        if ftype == TType.I64:
7482 
          self.beginIndex = iprot.readI64();
7483 
        else:
7484 
          iprot.skip(ftype)
7485 
      elif fid == 2:
7486 
        if ftype == TType.I64:
7487 
          self.totalItems = iprot.readI64();
7488 
        else:
7489 
          iprot.skip(ftype)
7490 
      elif fid == 3:
7491 
        if ftype == TType.STRING:
7492 
          self.brand = iprot.readString();
7493 
        else:
7494 
          iprot.skip(ftype)
7495 
      elif fid == 4:
7496 
        if ftype == TType.I64:
7497 
          self.category = iprot.readI64();
7498 
        else:
7499 
          iprot.skip(ftype)
7500 
      else:
7501 
        iprot.skip(ftype)
7502 
      iprot.readFieldEnd()
7503 
    iprot.readStructEnd()
7504 
 
7505 
  def write(self, oprot):
7506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7508 
      return
7509 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7510 
    if self.beginIndex is not None:
7511 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7512 
      oprot.writeI64(self.beginIndex)
7513 
      oprot.writeFieldEnd()
7514 
    if self.totalItems is not None:
7515 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7516 
      oprot.writeI64(self.totalItems)
7517 
      oprot.writeFieldEnd()
7518 
    if self.brand is not None:
7519 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7520 
      oprot.writeString(self.brand)
7521 
      oprot.writeFieldEnd()
7522 
    if self.category is not None:
7523 
      oprot.writeFieldBegin('category', TType.I64, 4)
7524 
      oprot.writeI64(self.category)
7525 
      oprot.writeFieldEnd()
7526 
    oprot.writeFieldStop()
7527 
    oprot.writeStructEnd()
7528 
 
7529 
  def validate(self):
7530 
    return
7531 
 
7532 
 
7533 
  def __repr__(self):
7534 
    L = ['%s=%r' % (key, value)
7535 
      for key, value in self.__dict__.iteritems()]
7536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7537 
 
7538 
  def __eq__(self, other):
7539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7540 
 
7541 
  def __ne__(self, other):
7542 
    return not (self == other)
7543 
 
7544 
class getBestSellersCatalogIds_result:
7545 
  """
7546 
  Attributes:
7547 
   - success
7548 
   - cex
7549 
  """
7550 
 
7551 
  thrift_spec = (
7552 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7553 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7554 
  )
7555 
 
7556 
  def __init__(self, success=None, cex=None,):
7557 
    self.success = success
7558 
    self.cex = cex
7559 
 
7560 
  def read(self, iprot):
7561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7563 
      return
7564 
    iprot.readStructBegin()
7565 
    while True:
7566 
      (fname, ftype, fid) = iprot.readFieldBegin()
7567 
      if ftype == TType.STOP:
7568 
        break
7569 
      if fid == 0:
7570 
        if ftype == TType.LIST:
7571 
          self.success = []
7572 
          (_etype68, _size65) = iprot.readListBegin()
7573 
          for _i69 in xrange(_size65):
7574 
            _elem70 = iprot.readI64();
7575 
            self.success.append(_elem70)
7576 
          iprot.readListEnd()
7577 
        else:
7578 
          iprot.skip(ftype)
7579 
      elif fid == 1:
7580 
        if ftype == TType.STRUCT:
7581 
          self.cex = CatalogServiceException()
7582 
          self.cex.read(iprot)
7583 
        else:
7584 
          iprot.skip(ftype)
7585 
      else:
7586 
        iprot.skip(ftype)
7587 
      iprot.readFieldEnd()
7588 
    iprot.readStructEnd()
7589 
 
7590 
  def write(self, oprot):
7591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7593 
      return
7594 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7595 
    if self.success is not None:
7596 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7597 
      oprot.writeListBegin(TType.I64, len(self.success))
7598 
      for iter71 in self.success:
7599 
        oprot.writeI64(iter71)
7600 
      oprot.writeListEnd()
7601 
      oprot.writeFieldEnd()
7602 
    if self.cex is not None:
7603 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7604 
      self.cex.write(oprot)
7605 
      oprot.writeFieldEnd()
7606 
    oprot.writeFieldStop()
7607 
    oprot.writeStructEnd()
7608 
 
7609 
  def validate(self):
7610 
    return
7611 
 
7612 
 
7613 
  def __repr__(self):
7614 
    L = ['%s=%r' % (key, value)
7615 
      for key, value in self.__dict__.iteritems()]
7616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7617 
 
7618 
  def __eq__(self, other):
7619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7620 
 
7621 
  def __ne__(self, other):
7622 
    return not (self == other)
7623 
 
7624 
class getBestSellersCount_args:
7625 
 
7626 
  thrift_spec = (
7627 
  )
7628 
 
7629 
  def read(self, iprot):
7630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7632 
      return
7633 
    iprot.readStructBegin()
7634 
    while True:
7635 
      (fname, ftype, fid) = iprot.readFieldBegin()
7636 
      if ftype == TType.STOP:
7637 
        break
7638 
      else:
7639 
        iprot.skip(ftype)
7640 
      iprot.readFieldEnd()
7641 
    iprot.readStructEnd()
7642 
 
7643 
  def write(self, oprot):
7644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7646 
      return
7647 
    oprot.writeStructBegin('getBestSellersCount_args')
7648 
    oprot.writeFieldStop()
7649 
    oprot.writeStructEnd()
7650 
 
7651 
  def validate(self):
7652 
    return
7653 
 
7654 
 
7655 
  def __repr__(self):
7656 
    L = ['%s=%r' % (key, value)
7657 
      for key, value in self.__dict__.iteritems()]
7658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7659 
 
7660 
  def __eq__(self, other):
7661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7662 
 
7663 
  def __ne__(self, other):
7664 
    return not (self == other)
7665 
 
7666 
class getBestSellersCount_result:
7667 
  """
7668 
  Attributes:
7669 
   - success
7670 
   - cex
7671 
  """
7672 
 
7673 
  thrift_spec = (
7674 
    (0, TType.I64, 'success', None, None, ), # 0
7675 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7676 
  )
7677 
 
7678 
  def __init__(self, success=None, cex=None,):
7679 
    self.success = success
7680 
    self.cex = cex
7681 
 
7682 
  def read(self, iprot):
7683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7685 
      return
7686 
    iprot.readStructBegin()
7687 
    while True:
7688 
      (fname, ftype, fid) = iprot.readFieldBegin()
7689 
      if ftype == TType.STOP:
7690 
        break
7691 
      if fid == 0:
7692 
        if ftype == TType.I64:
7693 
          self.success = iprot.readI64();
7694 
        else:
7695 
          iprot.skip(ftype)
7696 
      elif fid == 1:
7697 
        if ftype == TType.STRUCT:
7698 
          self.cex = CatalogServiceException()
7699 
          self.cex.read(iprot)
7700 
        else:
7701 
          iprot.skip(ftype)
7702 
      else:
7703 
        iprot.skip(ftype)
7704 
      iprot.readFieldEnd()
7705 
    iprot.readStructEnd()
7706 
 
7707 
  def write(self, oprot):
7708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7710 
      return
7711 
    oprot.writeStructBegin('getBestSellersCount_result')
7712 
    if self.success is not None:
7713 
      oprot.writeFieldBegin('success', TType.I64, 0)
7714 
      oprot.writeI64(self.success)
7715 
      oprot.writeFieldEnd()
7716 
    if self.cex is not None:
7717 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7718 
      self.cex.write(oprot)
7719 
      oprot.writeFieldEnd()
7720 
    oprot.writeFieldStop()
7721 
    oprot.writeStructEnd()
7722 
 
7723 
  def validate(self):
7724 
    return
7725 
 
7726 
 
7727 
  def __repr__(self):
7728 
    L = ['%s=%r' % (key, value)
7729 
      for key, value in self.__dict__.iteritems()]
7730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7731 
 
7732 
  def __eq__(self, other):
7733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7734 
 
7735 
  def __ne__(self, other):
7736 
    return not (self == other)
7737 
 
7738 
class getBestDeals_args:
7739 
 
7740 
  thrift_spec = (
7741 
  )
7742 
 
7743 
  def read(self, iprot):
7744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7746 
      return
7747 
    iprot.readStructBegin()
7748 
    while True:
7749 
      (fname, ftype, fid) = iprot.readFieldBegin()
7750 
      if ftype == TType.STOP:
7751 
        break
7752 
      else:
7753 
        iprot.skip(ftype)
7754 
      iprot.readFieldEnd()
7755 
    iprot.readStructEnd()
7756 
 
7757 
  def write(self, oprot):
7758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7760 
      return
7761 
    oprot.writeStructBegin('getBestDeals_args')
7762 
    oprot.writeFieldStop()
7763 
    oprot.writeStructEnd()
7764 
 
7765 
  def validate(self):
7766 
    return
7767 
 
7768 
 
7769 
  def __repr__(self):
7770 
    L = ['%s=%r' % (key, value)
7771 
      for key, value in self.__dict__.iteritems()]
7772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7773 
 
7774 
  def __eq__(self, other):
7775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7776 
 
7777 
  def __ne__(self, other):
7778 
    return not (self == other)
7779 
 
7780 
class getBestDeals_result:
7781 
  """
7782 
  Attributes:
7783 
   - success
7784 
   - isex
7785 
  """
7786 
 
7787 
  thrift_spec = (
7788 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7789 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7790 
  )
7791 
 
7792 
  def __init__(self, success=None, isex=None,):
7793 
    self.success = success
7794 
    self.isex = isex
7795 
 
7796 
  def read(self, iprot):
7797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7799 
      return
7800 
    iprot.readStructBegin()
7801 
    while True:
7802 
      (fname, ftype, fid) = iprot.readFieldBegin()
7803 
      if ftype == TType.STOP:
7804 
        break
7805 
      if fid == 0:
7806 
        if ftype == TType.LIST:
7807 
          self.success = []
7808 
          (_etype75, _size72) = iprot.readListBegin()
7809 
          for _i76 in xrange(_size72):
7810 
            _elem77 = Item()
7811 
            _elem77.read(iprot)
7812 
            self.success.append(_elem77)
7813 
          iprot.readListEnd()
7814 
        else:
7815 
          iprot.skip(ftype)
7816 
      elif fid == 1:
7817 
        if ftype == TType.STRUCT:
7818 
          self.isex = CatalogServiceException()
7819 
          self.isex.read(iprot)
7820 
        else:
7821 
          iprot.skip(ftype)
7822 
      else:
7823 
        iprot.skip(ftype)
7824 
      iprot.readFieldEnd()
7825 
    iprot.readStructEnd()
7826 
 
7827 
  def write(self, oprot):
7828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7830 
      return
7831 
    oprot.writeStructBegin('getBestDeals_result')
7832 
    if self.success is not None:
7833 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7834 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7835 
      for iter78 in self.success:
7836 
        iter78.write(oprot)
7837 
      oprot.writeListEnd()
7838 
      oprot.writeFieldEnd()
7839 
    if self.isex is not None:
7840 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7841 
      self.isex.write(oprot)
7842 
      oprot.writeFieldEnd()
7843 
    oprot.writeFieldStop()
7844 
    oprot.writeStructEnd()
7845 
 
7846 
  def validate(self):
7847 
    return
7848 
 
7849 
 
7850 
  def __repr__(self):
7851 
    L = ['%s=%r' % (key, value)
7852 
      for key, value in self.__dict__.iteritems()]
7853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7854 
 
7855 
  def __eq__(self, other):
7856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7857 
 
7858 
  def __ne__(self, other):
7859 
    return not (self == other)
7860 
 
7861 
class getBestDealsCatalogIds_args:
7862 
  """
7863 
  Attributes:
7864 
   - beginIndex
7865 
   - totalItems
7866 
   - brand
7867 
   - category
7868 
  """
7869 
 
7870 
  thrift_spec = (
7871 
    None, # 0
7872 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7873 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7874 
    (3, TType.STRING, 'brand', None, None, ), # 3
7875 
    (4, TType.I64, 'category', None, None, ), # 4
7876 
  )
7877 
 
7878 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7879 
    self.beginIndex = beginIndex
7880 
    self.totalItems = totalItems
7881 
    self.brand = brand
7882 
    self.category = category
7883 
 
7884 
  def read(self, iprot):
7885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7887 
      return
7888 
    iprot.readStructBegin()
7889 
    while True:
7890 
      (fname, ftype, fid) = iprot.readFieldBegin()
7891 
      if ftype == TType.STOP:
7892 
        break
7893 
      if fid == 1:
7894 
        if ftype == TType.I64:
7895 
          self.beginIndex = iprot.readI64();
7896 
        else:
7897 
          iprot.skip(ftype)
7898 
      elif fid == 2:
7899 
        if ftype == TType.I64:
7900 
          self.totalItems = iprot.readI64();
7901 
        else:
7902 
          iprot.skip(ftype)
7903 
      elif fid == 3:
7904 
        if ftype == TType.STRING:
7905 
          self.brand = iprot.readString();
7906 
        else:
7907 
          iprot.skip(ftype)
7908 
      elif fid == 4:
7909 
        if ftype == TType.I64:
7910 
          self.category = iprot.readI64();
7911 
        else:
7912 
          iprot.skip(ftype)
7913 
      else:
7914 
        iprot.skip(ftype)
7915 
      iprot.readFieldEnd()
7916 
    iprot.readStructEnd()
7917 
 
7918 
  def write(self, oprot):
7919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7921 
      return
7922 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
7923 
    if self.beginIndex is not None:
7924 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7925 
      oprot.writeI64(self.beginIndex)
7926 
      oprot.writeFieldEnd()
7927 
    if self.totalItems is not None:
7928 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7929 
      oprot.writeI64(self.totalItems)
7930 
      oprot.writeFieldEnd()
7931 
    if self.brand is not None:
7932 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7933 
      oprot.writeString(self.brand)
7934 
      oprot.writeFieldEnd()
7935 
    if self.category is not None:
7936 
      oprot.writeFieldBegin('category', TType.I64, 4)
7937 
      oprot.writeI64(self.category)
7938 
      oprot.writeFieldEnd()
7939 
    oprot.writeFieldStop()
7940 
    oprot.writeStructEnd()
7941 
 
7942 
  def validate(self):
7943 
    return
7944 
 
7945 
 
7946 
  def __repr__(self):
7947 
    L = ['%s=%r' % (key, value)
7948 
      for key, value in self.__dict__.iteritems()]
7949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7950 
 
7951 
  def __eq__(self, other):
7952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7953 
 
7954 
  def __ne__(self, other):
7955 
    return not (self == other)
7956 
 
7957 
class getBestDealsCatalogIds_result:
7958 
  """
7959 
  Attributes:
7960 
   - success
7961 
   - cex
7962 
  """
7963 
 
7964 
  thrift_spec = (
7965 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7966 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7967 
  )
7968 
 
7969 
  def __init__(self, success=None, cex=None,):
7970 
    self.success = success
7971 
    self.cex = cex
7972 
 
7973 
  def read(self, iprot):
7974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7976 
      return
7977 
    iprot.readStructBegin()
7978 
    while True:
7979 
      (fname, ftype, fid) = iprot.readFieldBegin()
7980 
      if ftype == TType.STOP:
7981 
        break
7982 
      if fid == 0:
7983 
        if ftype == TType.LIST:
7984 
          self.success = []
7985 
          (_etype82, _size79) = iprot.readListBegin()
7986 
          for _i83 in xrange(_size79):
7987 
            _elem84 = iprot.readI64();
7988 
            self.success.append(_elem84)
7989 
          iprot.readListEnd()
7990 
        else:
7991 
          iprot.skip(ftype)
7992 
      elif fid == 1:
7993 
        if ftype == TType.STRUCT:
7994 
          self.cex = CatalogServiceException()
7995 
          self.cex.read(iprot)
7996 
        else:
7997 
          iprot.skip(ftype)
7998 
      else:
7999 
        iprot.skip(ftype)
8000 
      iprot.readFieldEnd()
8001 
    iprot.readStructEnd()
8002 
 
8003 
  def write(self, oprot):
8004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8006 
      return
8007 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8008 
    if self.success is not None:
8009 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8010 
      oprot.writeListBegin(TType.I64, len(self.success))
8011 
      for iter85 in self.success:
8012 
        oprot.writeI64(iter85)
8013 
      oprot.writeListEnd()
8014 
      oprot.writeFieldEnd()
8015 
    if self.cex is not None:
8016 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8017 
      self.cex.write(oprot)
8018 
      oprot.writeFieldEnd()
8019 
    oprot.writeFieldStop()
8020 
    oprot.writeStructEnd()
8021 
 
8022 
  def validate(self):
8023 
    return
8024 
 
8025 
 
8026 
  def __repr__(self):
8027 
    L = ['%s=%r' % (key, value)
8028 
      for key, value in self.__dict__.iteritems()]
8029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8030 
 
8031 
  def __eq__(self, other):
8032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8033 
 
8034 
  def __ne__(self, other):
8035 
    return not (self == other)
8036 
 
8037 
class getBestDealsCount_args:
8038 
 
8039 
  thrift_spec = (
8040 
  )
8041 
 
8042 
  def read(self, iprot):
8043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8045 
      return
8046 
    iprot.readStructBegin()
8047 
    while True:
8048 
      (fname, ftype, fid) = iprot.readFieldBegin()
8049 
      if ftype == TType.STOP:
8050 
        break
8051 
      else:
8052 
        iprot.skip(ftype)
8053 
      iprot.readFieldEnd()
8054 
    iprot.readStructEnd()
8055 
 
8056 
  def write(self, oprot):
8057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8059 
      return
8060 
    oprot.writeStructBegin('getBestDealsCount_args')
8061 
    oprot.writeFieldStop()
8062 
    oprot.writeStructEnd()
8063 
 
8064 
  def validate(self):
8065 
    return
8066 
 
8067 
 
8068 
  def __repr__(self):
8069 
    L = ['%s=%r' % (key, value)
8070 
      for key, value in self.__dict__.iteritems()]
8071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8072 
 
8073 
  def __eq__(self, other):
8074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8075 
 
8076 
  def __ne__(self, other):
8077 
    return not (self == other)
8078 
 
8079 
class getBestDealsCount_result:
8080 
  """
8081 
  Attributes:
8082 
   - success
8083 
   - cex
8084 
  """
8085 
 
8086 
  thrift_spec = (
8087 
    (0, TType.I64, 'success', None, None, ), # 0
8088 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8089 
  )
8090 
 
8091 
  def __init__(self, success=None, cex=None,):
8092 
    self.success = success
8093 
    self.cex = cex
8094 
 
8095 
  def read(self, iprot):
8096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8098 
      return
8099 
    iprot.readStructBegin()
8100 
    while True:
8101 
      (fname, ftype, fid) = iprot.readFieldBegin()
8102 
      if ftype == TType.STOP:
8103 
        break
8104 
      if fid == 0:
8105 
        if ftype == TType.I64:
8106 
          self.success = iprot.readI64();
8107 
        else:
8108 
          iprot.skip(ftype)
8109 
      elif fid == 1:
8110 
        if ftype == TType.STRUCT:
8111 
          self.cex = CatalogServiceException()
8112 
          self.cex.read(iprot)
8113 
        else:
8114 
          iprot.skip(ftype)
8115 
      else:
8116 
        iprot.skip(ftype)
8117 
      iprot.readFieldEnd()
8118 
    iprot.readStructEnd()
8119 
 
8120 
  def write(self, oprot):
8121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8123 
      return
8124 
    oprot.writeStructBegin('getBestDealsCount_result')
8125 
    if self.success is not None:
8126 
      oprot.writeFieldBegin('success', TType.I64, 0)
8127 
      oprot.writeI64(self.success)
8128 
      oprot.writeFieldEnd()
8129 
    if self.cex is not None:
8130 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8131 
      self.cex.write(oprot)
8132 
      oprot.writeFieldEnd()
8133 
    oprot.writeFieldStop()
8134 
    oprot.writeStructEnd()
8135 
 
8136 
  def validate(self):
8137 
    return
8138 
 
8139 
 
8140 
  def __repr__(self):
8141 
    L = ['%s=%r' % (key, value)
8142 
      for key, value in self.__dict__.iteritems()]
8143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8144 
 
8145 
  def __eq__(self, other):
8146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8147 
 
8148 
  def __ne__(self, other):
8149 
    return not (self == other)
8150 
 
8151 
class getComingSoon_args:
8152 
 
8153 
  thrift_spec = (
8154 
  )
8155 
 
8156 
  def read(self, iprot):
8157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8159 
      return
8160 
    iprot.readStructBegin()
8161 
    while True:
8162 
      (fname, ftype, fid) = iprot.readFieldBegin()
8163 
      if ftype == TType.STOP:
8164 
        break
8165 
      else:
8166 
        iprot.skip(ftype)
8167 
      iprot.readFieldEnd()
8168 
    iprot.readStructEnd()
8169 
 
8170 
  def write(self, oprot):
8171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8173 
      return
8174 
    oprot.writeStructBegin('getComingSoon_args')
8175 
    oprot.writeFieldStop()
8176 
    oprot.writeStructEnd()
8177 
 
8178 
  def validate(self):
8179 
    return
8180 
 
8181 
 
8182 
  def __repr__(self):
8183 
    L = ['%s=%r' % (key, value)
8184 
      for key, value in self.__dict__.iteritems()]
8185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8186 
 
8187 
  def __eq__(self, other):
8188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8189 
 
8190 
  def __ne__(self, other):
8191 
    return not (self == other)
8192 
 
8193 
class getComingSoon_result:
8194 
  """
8195 
  Attributes:
8196 
   - success
8197 
   - isex
8198 
  """
8199 
 
8200 
  thrift_spec = (
8201 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8202 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8203 
  )
8204 
 
8205 
  def __init__(self, success=None, isex=None,):
8206 
    self.success = success
8207 
    self.isex = isex
8208 
 
8209 
  def read(self, iprot):
8210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8212 
      return
8213 
    iprot.readStructBegin()
8214 
    while True:
8215 
      (fname, ftype, fid) = iprot.readFieldBegin()
8216 
      if ftype == TType.STOP:
8217 
        break
8218 
      if fid == 0:
8219 
        if ftype == TType.LIST:
8220 
          self.success = []
8221 
          (_etype89, _size86) = iprot.readListBegin()
8222 
          for _i90 in xrange(_size86):
8223 
            _elem91 = Item()
8224 
            _elem91.read(iprot)
8225 
            self.success.append(_elem91)
8226 
          iprot.readListEnd()
8227 
        else:
8228 
          iprot.skip(ftype)
8229 
      elif fid == 1:
8230 
        if ftype == TType.STRUCT:
8231 
          self.isex = CatalogServiceException()
8232 
          self.isex.read(iprot)
8233 
        else:
8234 
          iprot.skip(ftype)
8235 
      else:
8236 
        iprot.skip(ftype)
8237 
      iprot.readFieldEnd()
8238 
    iprot.readStructEnd()
8239 
 
8240 
  def write(self, oprot):
8241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8243 
      return
8244 
    oprot.writeStructBegin('getComingSoon_result')
8245 
    if self.success is not None:
8246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8247 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8248 
      for iter92 in self.success:
8249 
        iter92.write(oprot)
8250 
      oprot.writeListEnd()
8251 
      oprot.writeFieldEnd()
8252 
    if self.isex is not None:
8253 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8254 
      self.isex.write(oprot)
8255 
      oprot.writeFieldEnd()
8256 
    oprot.writeFieldStop()
8257 
    oprot.writeStructEnd()
8258 
 
8259 
  def validate(self):
8260 
    return
8261 
 
8262 
 
8263 
  def __repr__(self):
8264 
    L = ['%s=%r' % (key, value)
8265 
      for key, value in self.__dict__.iteritems()]
8266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8267 
 
8268 
  def __eq__(self, other):
8269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8270 
 
8271 
  def __ne__(self, other):
8272 
    return not (self == other)
8273 
 
8274 
class getComingSoonCatalogIds_args:
8275 
  """
8276 
  Attributes:
8277 
   - beginIndex
8278 
   - totalItems
8279 
   - brand
8280 
   - category
8281 
  """
8282 
 
8283 
  thrift_spec = (
8284 
    None, # 0
8285 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8286 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8287 
    (3, TType.STRING, 'brand', None, None, ), # 3
8288 
    (4, TType.I64, 'category', None, None, ), # 4
8289 
  )
8290 
 
8291 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8292 
    self.beginIndex = beginIndex
8293 
    self.totalItems = totalItems
8294 
    self.brand = brand
8295 
    self.category = category
8296 
 
8297 
  def read(self, iprot):
8298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8300 
      return
8301 
    iprot.readStructBegin()
8302 
    while True:
8303 
      (fname, ftype, fid) = iprot.readFieldBegin()
8304 
      if ftype == TType.STOP:
8305 
        break
8306 
      if fid == 1:
8307 
        if ftype == TType.I64:
8308 
          self.beginIndex = iprot.readI64();
8309 
        else:
8310 
          iprot.skip(ftype)
8311 
      elif fid == 2:
8312 
        if ftype == TType.I64:
8313 
          self.totalItems = iprot.readI64();
8314 
        else:
8315 
          iprot.skip(ftype)
8316 
      elif fid == 3:
8317 
        if ftype == TType.STRING:
8318 
          self.brand = iprot.readString();
8319 
        else:
8320 
          iprot.skip(ftype)
8321 
      elif fid == 4:
8322 
        if ftype == TType.I64:
8323 
          self.category = iprot.readI64();
8324 
        else:
8325 
          iprot.skip(ftype)
8326 
      else:
8327 
        iprot.skip(ftype)
8328 
      iprot.readFieldEnd()
8329 
    iprot.readStructEnd()
8330 
 
8331 
  def write(self, oprot):
8332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8334 
      return
8335 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8336 
    if self.beginIndex is not None:
8337 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8338 
      oprot.writeI64(self.beginIndex)
8339 
      oprot.writeFieldEnd()
8340 
    if self.totalItems is not None:
8341 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8342 
      oprot.writeI64(self.totalItems)
8343 
      oprot.writeFieldEnd()
8344 
    if self.brand is not None:
8345 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8346 
      oprot.writeString(self.brand)
8347 
      oprot.writeFieldEnd()
8348 
    if self.category is not None:
8349 
      oprot.writeFieldBegin('category', TType.I64, 4)
8350 
      oprot.writeI64(self.category)
8351 
      oprot.writeFieldEnd()
8352 
    oprot.writeFieldStop()
8353 
    oprot.writeStructEnd()
8354 
 
8355 
  def validate(self):
8356 
    return
8357 
 
8358 
 
8359 
  def __repr__(self):
8360 
    L = ['%s=%r' % (key, value)
8361 
      for key, value in self.__dict__.iteritems()]
8362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8363 
 
8364 
  def __eq__(self, other):
8365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8366 
 
8367 
  def __ne__(self, other):
8368 
    return not (self == other)
8369 
 
8370 
class getComingSoonCatalogIds_result:
8371 
  """
8372 
  Attributes:
8373 
   - success
8374 
   - cex
8375 
  """
8376 
 
8377 
  thrift_spec = (
8378 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8379 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8380 
  )
8381 
 
8382 
  def __init__(self, success=None, cex=None,):
8383 
    self.success = success
8384 
    self.cex = cex
8385 
 
8386 
  def read(self, iprot):
8387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8389 
      return
8390 
    iprot.readStructBegin()
8391 
    while True:
8392 
      (fname, ftype, fid) = iprot.readFieldBegin()
8393 
      if ftype == TType.STOP:
8394 
        break
8395 
      if fid == 0:
8396 
        if ftype == TType.LIST:
8397 
          self.success = []
8398 
          (_etype96, _size93) = iprot.readListBegin()
8399 
          for _i97 in xrange(_size93):
8400 
            _elem98 = iprot.readI64();
8401 
            self.success.append(_elem98)
8402 
          iprot.readListEnd()
8403 
        else:
8404 
          iprot.skip(ftype)
8405 
      elif fid == 1:
8406 
        if ftype == TType.STRUCT:
8407 
          self.cex = CatalogServiceException()
8408 
          self.cex.read(iprot)
8409 
        else:
8410 
          iprot.skip(ftype)
8411 
      else:
8412 
        iprot.skip(ftype)
8413 
      iprot.readFieldEnd()
8414 
    iprot.readStructEnd()
8415 
 
8416 
  def write(self, oprot):
8417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8419 
      return
8420 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8421 
    if self.success is not None:
8422 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8423 
      oprot.writeListBegin(TType.I64, len(self.success))
8424 
      for iter99 in self.success:
8425 
        oprot.writeI64(iter99)
8426 
      oprot.writeListEnd()
8427 
      oprot.writeFieldEnd()
8428 
    if self.cex is not None:
8429 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8430 
      self.cex.write(oprot)
8431 
      oprot.writeFieldEnd()
8432 
    oprot.writeFieldStop()
8433 
    oprot.writeStructEnd()
8434 
 
8435 
  def validate(self):
8436 
    return
8437 
 
8438 
 
8439 
  def __repr__(self):
8440 
    L = ['%s=%r' % (key, value)
8441 
      for key, value in self.__dict__.iteritems()]
8442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8443 
 
8444 
  def __eq__(self, other):
8445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8446 
 
8447 
  def __ne__(self, other):
8448 
    return not (self == other)
8449 
 
8450 
class getComingSoonCount_args:
8451 
 
8452 
  thrift_spec = (
8453 
  )
8454 
 
8455 
  def read(self, iprot):
8456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8458 
      return
8459 
    iprot.readStructBegin()
8460 
    while True:
8461 
      (fname, ftype, fid) = iprot.readFieldBegin()
8462 
      if ftype == TType.STOP:
8463 
        break
8464 
      else:
8465 
        iprot.skip(ftype)
8466 
      iprot.readFieldEnd()
8467 
    iprot.readStructEnd()
8468 
 
8469 
  def write(self, oprot):
8470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8472 
      return
8473 
    oprot.writeStructBegin('getComingSoonCount_args')
8474 
    oprot.writeFieldStop()
8475 
    oprot.writeStructEnd()
8476 
 
8477 
  def validate(self):
8478 
    return
8479 
 
8480 
 
8481 
  def __repr__(self):
8482 
    L = ['%s=%r' % (key, value)
8483 
      for key, value in self.__dict__.iteritems()]
8484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8485 
 
8486 
  def __eq__(self, other):
8487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8488 
 
8489 
  def __ne__(self, other):
8490 
    return not (self == other)
8491 
 
8492 
class getComingSoonCount_result:
8493 
  """
8494 
  Attributes:
8495 
   - success
8496 
   - cex
8497 
  """
8498 
 
8499 
  thrift_spec = (
8500 
    (0, TType.I64, 'success', None, None, ), # 0
8501 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8502 
  )
8503 
 
8504 
  def __init__(self, success=None, cex=None,):
8505 
    self.success = success
8506 
    self.cex = cex
8507 
 
8508 
  def read(self, iprot):
8509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8511 
      return
8512 
    iprot.readStructBegin()
8513 
    while True:
8514 
      (fname, ftype, fid) = iprot.readFieldBegin()
8515 
      if ftype == TType.STOP:
8516 
        break
8517 
      if fid == 0:
8518 
        if ftype == TType.I64:
8519 
          self.success = iprot.readI64();
8520 
        else:
8521 
          iprot.skip(ftype)
8522 
      elif fid == 1:
8523 
        if ftype == TType.STRUCT:
8524 
          self.cex = CatalogServiceException()
8525 
          self.cex.read(iprot)
8526 
        else:
8527 
          iprot.skip(ftype)
8528 
      else:
8529 
        iprot.skip(ftype)
8530 
      iprot.readFieldEnd()
8531 
    iprot.readStructEnd()
8532 
 
8533 
  def write(self, oprot):
8534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8536 
      return
8537 
    oprot.writeStructBegin('getComingSoonCount_result')
8538 
    if self.success is not None:
8539 
      oprot.writeFieldBegin('success', TType.I64, 0)
8540 
      oprot.writeI64(self.success)
8541 
      oprot.writeFieldEnd()
8542 
    if self.cex is not None:
8543 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8544 
      self.cex.write(oprot)
8545 
      oprot.writeFieldEnd()
8546 
    oprot.writeFieldStop()
8547 
    oprot.writeStructEnd()
8548 
 
8549 
  def validate(self):
8550 
    return
8551 
 
8552 
 
8553 
  def __repr__(self):
8554 
    L = ['%s=%r' % (key, value)
8555 
      for key, value in self.__dict__.iteritems()]
8556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8557 
 
8558 
  def __eq__(self, other):
8559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8560 
 
8561 
  def __ne__(self, other):
8562 
    return not (self == other)
8563 
 
8564 
class getLatestArrivals_args:
8565 
 
8566 
  thrift_spec = (
8567 
  )
8568 
 
8569 
  def read(self, iprot):
8570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8572 
      return
8573 
    iprot.readStructBegin()
8574 
    while True:
8575 
      (fname, ftype, fid) = iprot.readFieldBegin()
8576 
      if ftype == TType.STOP:
8577 
        break
8578 
      else:
8579 
        iprot.skip(ftype)
8580 
      iprot.readFieldEnd()
8581 
    iprot.readStructEnd()
8582 
 
8583 
  def write(self, oprot):
8584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8586 
      return
8587 
    oprot.writeStructBegin('getLatestArrivals_args')
8588 
    oprot.writeFieldStop()
8589 
    oprot.writeStructEnd()
8590 
 
8591 
  def validate(self):
8592 
    return
8593 
 
8594 
 
8595 
  def __repr__(self):
8596 
    L = ['%s=%r' % (key, value)
8597 
      for key, value in self.__dict__.iteritems()]
8598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8599 
 
8600 
  def __eq__(self, other):
8601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8602 
 
8603 
  def __ne__(self, other):
8604 
    return not (self == other)
8605 
 
8606 
class getLatestArrivals_result:
8607 
  """
8608 
  Attributes:
8609 
   - success
8610 
   - isex
8611 
  """
8612 
 
8613 
  thrift_spec = (
8614 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8615 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8616 
  )
8617 
 
8618 
  def __init__(self, success=None, isex=None,):
8619 
    self.success = success
8620 
    self.isex = isex
8621 
 
8622 
  def read(self, iprot):
8623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8625 
      return
8626 
    iprot.readStructBegin()
8627 
    while True:
8628 
      (fname, ftype, fid) = iprot.readFieldBegin()
8629 
      if ftype == TType.STOP:
8630 
        break
8631 
      if fid == 0:
8632 
        if ftype == TType.LIST:
8633 
          self.success = []
8634 
          (_etype103, _size100) = iprot.readListBegin()
8635 
          for _i104 in xrange(_size100):
8636 
            _elem105 = Item()
8637 
            _elem105.read(iprot)
8638 
            self.success.append(_elem105)
8639 
          iprot.readListEnd()
8640 
        else:
8641 
          iprot.skip(ftype)
8642 
      elif fid == 1:
8643 
        if ftype == TType.STRUCT:
8644 
          self.isex = CatalogServiceException()
8645 
          self.isex.read(iprot)
8646 
        else:
8647 
          iprot.skip(ftype)
8648 
      else:
8649 
        iprot.skip(ftype)
8650 
      iprot.readFieldEnd()
8651 
    iprot.readStructEnd()
8652 
 
8653 
  def write(self, oprot):
8654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8656 
      return
8657 
    oprot.writeStructBegin('getLatestArrivals_result')
8658 
    if self.success is not None:
8659 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8660 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8661 
      for iter106 in self.success:
8662 
        iter106.write(oprot)
8663 
      oprot.writeListEnd()
8664 
      oprot.writeFieldEnd()
8665 
    if self.isex is not None:
8666 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8667 
      self.isex.write(oprot)
8668 
      oprot.writeFieldEnd()
8669 
    oprot.writeFieldStop()
8670 
    oprot.writeStructEnd()
8671 
 
8672 
  def validate(self):
8673 
    return
8674 
 
8675 
 
8676 
  def __repr__(self):
8677 
    L = ['%s=%r' % (key, value)
8678 
      for key, value in self.__dict__.iteritems()]
8679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8680 
 
8681 
  def __eq__(self, other):
8682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8683 
 
8684 
  def __ne__(self, other):
8685 
    return not (self == other)
8686 
 
8687 
class getLatestArrivalsCatalogIds_args:
8688 
  """
8689 
  Attributes:
8690 
   - beginIndex
8691 
   - totalItems
8692 
   - brand
8693 
   - categories
8694 
  """
8695 
 
8696 
  thrift_spec = (
8697 
    None, # 0
8698 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8699 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8700 
    (3, TType.STRING, 'brand', None, None, ), # 3
8701 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8702 
  )
8703 
 
8704 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8705 
    self.beginIndex = beginIndex
8706 
    self.totalItems = totalItems
8707 
    self.brand = brand
8708 
    self.categories = categories
8709 
 
8710 
  def read(self, iprot):
8711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8713 
      return
8714 
    iprot.readStructBegin()
8715 
    while True:
8716 
      (fname, ftype, fid) = iprot.readFieldBegin()
8717 
      if ftype == TType.STOP:
8718 
        break
8719 
      if fid == 1:
8720 
        if ftype == TType.I64:
8721 
          self.beginIndex = iprot.readI64();
8722 
        else:
8723 
          iprot.skip(ftype)
8724 
      elif fid == 2:
8725 
        if ftype == TType.I64:
8726 
          self.totalItems = iprot.readI64();
8727 
        else:
8728 
          iprot.skip(ftype)
8729 
      elif fid == 3:
8730 
        if ftype == TType.STRING:
8731 
          self.brand = iprot.readString();
8732 
        else:
8733 
          iprot.skip(ftype)
8734 
      elif fid == 4:
8735 
        if ftype == TType.LIST:
8736 
          self.categories = []
8737 
          (_etype110, _size107) = iprot.readListBegin()
8738 
          for _i111 in xrange(_size107):
8739 
            _elem112 = iprot.readI64();
8740 
            self.categories.append(_elem112)
8741 
          iprot.readListEnd()
8742 
        else:
8743 
          iprot.skip(ftype)
8744 
      else:
8745 
        iprot.skip(ftype)
8746 
      iprot.readFieldEnd()
8747 
    iprot.readStructEnd()
8748 
 
8749 
  def write(self, oprot):
8750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8752 
      return
8753 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8754 
    if self.beginIndex is not None:
8755 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8756 
      oprot.writeI64(self.beginIndex)
8757 
      oprot.writeFieldEnd()
8758 
    if self.totalItems is not None:
8759 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8760 
      oprot.writeI64(self.totalItems)
8761 
      oprot.writeFieldEnd()
8762 
    if self.brand is not None:
8763 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8764 
      oprot.writeString(self.brand)
8765 
      oprot.writeFieldEnd()
8766 
    if self.categories is not None:
8767 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8768 
      oprot.writeListBegin(TType.I64, len(self.categories))
8769 
      for iter113 in self.categories:
8770 
        oprot.writeI64(iter113)
8771 
      oprot.writeListEnd()
8772 
      oprot.writeFieldEnd()
8773 
    oprot.writeFieldStop()
8774 
    oprot.writeStructEnd()
8775 
 
8776 
  def validate(self):
8777 
    return
8778 
 
8779 
 
8780 
  def __repr__(self):
8781 
    L = ['%s=%r' % (key, value)
8782 
      for key, value in self.__dict__.iteritems()]
8783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8784 
 
8785 
  def __eq__(self, other):
8786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8787 
 
8788 
  def __ne__(self, other):
8789 
    return not (self == other)
8790 
 
8791 
class getLatestArrivalsCatalogIds_result:
8792 
  """
8793 
  Attributes:
8794 
   - success
8795 
   - cex
8796 
  """
8797 
 
8798 
  thrift_spec = (
8799 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8800 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8801 
  )
8802 
 
8803 
  def __init__(self, success=None, cex=None,):
8804 
    self.success = success
8805 
    self.cex = cex
8806 
 
8807 
  def read(self, iprot):
8808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8810 
      return
8811 
    iprot.readStructBegin()
8812 
    while True:
8813 
      (fname, ftype, fid) = iprot.readFieldBegin()
8814 
      if ftype == TType.STOP:
8815 
        break
8816 
      if fid == 0:
8817 
        if ftype == TType.LIST:
8818 
          self.success = []
8819 
          (_etype117, _size114) = iprot.readListBegin()
8820 
          for _i118 in xrange(_size114):
8821 
            _elem119 = iprot.readI64();
8822 
            self.success.append(_elem119)
8823 
          iprot.readListEnd()
8824 
        else:
8825 
          iprot.skip(ftype)
8826 
      elif fid == 1:
8827 
        if ftype == TType.STRUCT:
8828 
          self.cex = CatalogServiceException()
8829 
          self.cex.read(iprot)
8830 
        else:
8831 
          iprot.skip(ftype)
8832 
      else:
8833 
        iprot.skip(ftype)
8834 
      iprot.readFieldEnd()
8835 
    iprot.readStructEnd()
8836 
 
8837 
  def write(self, oprot):
8838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8840 
      return
8841 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
8842 
    if self.success is not None:
8843 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8844 
      oprot.writeListBegin(TType.I64, len(self.success))
8845 
      for iter120 in self.success:
8846 
        oprot.writeI64(iter120)
8847 
      oprot.writeListEnd()
8848 
      oprot.writeFieldEnd()
8849 
    if self.cex is not None:
8850 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8851 
      self.cex.write(oprot)
8852 
      oprot.writeFieldEnd()
8853 
    oprot.writeFieldStop()
8854 
    oprot.writeStructEnd()
8855 
 
8856 
  def validate(self):
8857 
    return
8858 
 
8859 
 
8860 
  def __repr__(self):
8861 
    L = ['%s=%r' % (key, value)
8862 
      for key, value in self.__dict__.iteritems()]
8863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8864 
 
8865 
  def __eq__(self, other):
8866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8867 
 
8868 
  def __ne__(self, other):
8869 
    return not (self == other)
8870 
 
8871 
class getLatestArrivalsCount_args:
8872 
 
8873 
  thrift_spec = (
8874 
  )
8875 
 
8876 
  def read(self, iprot):
8877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8879 
      return
8880 
    iprot.readStructBegin()
8881 
    while True:
8882 
      (fname, ftype, fid) = iprot.readFieldBegin()
8883 
      if ftype == TType.STOP:
8884 
        break
8885 
      else:
8886 
        iprot.skip(ftype)
8887 
      iprot.readFieldEnd()
8888 
    iprot.readStructEnd()
8889 
 
8890 
  def write(self, oprot):
8891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8893 
      return
8894 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
8895 
    oprot.writeFieldStop()
8896 
    oprot.writeStructEnd()
8897 
 
8898 
  def validate(self):
8899 
    return
8900 
 
8901 
 
8902 
  def __repr__(self):
8903 
    L = ['%s=%r' % (key, value)
8904 
      for key, value in self.__dict__.iteritems()]
8905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8906 
 
8907 
  def __eq__(self, other):
8908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8909 
 
8910 
  def __ne__(self, other):
8911 
    return not (self == other)
8912 
 
8913 
class getLatestArrivalsCount_result:
8914 
  """
8915 
  Attributes:
8916 
   - success
8917 
   - cex
8918 
  """
8919 
 
8920 
  thrift_spec = (
8921 
    (0, TType.I64, 'success', None, None, ), # 0
8922 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8923 
  )
8924 
 
8925 
  def __init__(self, success=None, cex=None,):
8926 
    self.success = success
8927 
    self.cex = cex
8928 
 
8929 
  def read(self, iprot):
8930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8932 
      return
8933 
    iprot.readStructBegin()
8934 
    while True:
8935 
      (fname, ftype, fid) = iprot.readFieldBegin()
8936 
      if ftype == TType.STOP:
8937 
        break
8938 
      if fid == 0:
8939 
        if ftype == TType.I64:
8940 
          self.success = iprot.readI64();
8941 
        else:
8942 
          iprot.skip(ftype)
8943 
      elif fid == 1:
8944 
        if ftype == TType.STRUCT:
8945 
          self.cex = CatalogServiceException()
8946 
          self.cex.read(iprot)
8947 
        else:
8948 
          iprot.skip(ftype)
8949 
      else:
8950 
        iprot.skip(ftype)
8951 
      iprot.readFieldEnd()
8952 
    iprot.readStructEnd()
8953 
 
8954 
  def write(self, oprot):
8955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8957 
      return
8958 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
8959 
    if self.success is not None:
8960 
      oprot.writeFieldBegin('success', TType.I64, 0)
8961 
      oprot.writeI64(self.success)
8962 
      oprot.writeFieldEnd()
8963 
    if self.cex is not None:
8964 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8965 
      self.cex.write(oprot)
8966 
      oprot.writeFieldEnd()
8967 
    oprot.writeFieldStop()
8968 
    oprot.writeStructEnd()
8969 
 
8970 
  def validate(self):
8971 
    return
8972 
 
8973 
 
8974 
  def __repr__(self):
8975 
    L = ['%s=%r' % (key, value)
8976 
      for key, value in self.__dict__.iteritems()]
8977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8978 
 
8979 
  def __eq__(self, other):
8980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8981 
 
8982 
  def __ne__(self, other):
8983 
    return not (self == other)
8984 
 
8985 
class generateNewEntityID_args:
8986 
 
8987 
  thrift_spec = (
8988 
  )
8989 
 
8990 
  def read(self, iprot):
8991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8993 
      return
8994 
    iprot.readStructBegin()
8995 
    while True:
8996 
      (fname, ftype, fid) = iprot.readFieldBegin()
8997 
      if ftype == TType.STOP:
8998 
        break
8999 
      else:
9000 
        iprot.skip(ftype)
9001 
      iprot.readFieldEnd()
9002 
    iprot.readStructEnd()
9003 
 
9004 
  def write(self, oprot):
9005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9007 
      return
9008 
    oprot.writeStructBegin('generateNewEntityID_args')
9009 
    oprot.writeFieldStop()
9010 
    oprot.writeStructEnd()
9011 
 
9012 
  def validate(self):
9013 
    return
9014 
 
9015 
 
9016 
  def __repr__(self):
9017 
    L = ['%s=%r' % (key, value)
9018 
      for key, value in self.__dict__.iteritems()]
9019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9020 
 
9021 
  def __eq__(self, other):
9022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9023 
 
9024 
  def __ne__(self, other):
9025 
    return not (self == other)
9026 
 
9027 
class generateNewEntityID_result:
9028 
  """
9029 
  Attributes:
9030 
   - success
9031 
  """
9032 
 
9033 
  thrift_spec = (
9034 
    (0, TType.I64, 'success', None, None, ), # 0
9035 
  )
9036 
 
9037 
  def __init__(self, success=None,):
9038 
    self.success = success
9039 
 
9040 
  def read(self, iprot):
9041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9043 
      return
9044 
    iprot.readStructBegin()
9045 
    while True:
9046 
      (fname, ftype, fid) = iprot.readFieldBegin()
9047 
      if ftype == TType.STOP:
9048 
        break
9049 
      if fid == 0:
9050 
        if ftype == TType.I64:
9051 
          self.success = iprot.readI64();
9052 
        else:
9053 
          iprot.skip(ftype)
9054 
      else:
9055 
        iprot.skip(ftype)
9056 
      iprot.readFieldEnd()
9057 
    iprot.readStructEnd()
9058 
 
9059 
  def write(self, oprot):
9060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9062 
      return
9063 
    oprot.writeStructBegin('generateNewEntityID_result')
9064 
    if self.success is not None:
9065 
      oprot.writeFieldBegin('success', TType.I64, 0)
9066 
      oprot.writeI64(self.success)
9067 
      oprot.writeFieldEnd()
9068 
    oprot.writeFieldStop()
9069 
    oprot.writeStructEnd()
9070 
 
9071 
  def validate(self):
9072 
    return
9073 
 
9074 
 
9075 
  def __repr__(self):
9076 
    L = ['%s=%r' % (key, value)
9077 
      for key, value in self.__dict__.iteritems()]
9078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9079 
 
9080 
  def __eq__(self, other):
9081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9082 
 
9083 
  def __ne__(self, other):
9084 
    return not (self == other)
9085 
 
9086 
class addCategory_args:
9087 
  """
9088 
  Attributes:
9089 
   - category
9090 
  """
9091 
 
9092 
  thrift_spec = (
9093 
    None, # 0
9094 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9095 
  )
9096 
 
9097 
  def __init__(self, category=None,):
9098 
    self.category = category
9099 
 
9100 
  def read(self, iprot):
9101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9103 
      return
9104 
    iprot.readStructBegin()
9105 
    while True:
9106 
      (fname, ftype, fid) = iprot.readFieldBegin()
9107 
      if ftype == TType.STOP:
9108 
        break
9109 
      if fid == 1:
9110 
        if ftype == TType.STRUCT:
9111 
          self.category = Category()
9112 
          self.category.read(iprot)
9113 
        else:
9114 
          iprot.skip(ftype)
9115 
      else:
9116 
        iprot.skip(ftype)
9117 
      iprot.readFieldEnd()
9118 
    iprot.readStructEnd()
9119 
 
9120 
  def write(self, oprot):
9121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9123 
      return
9124 
    oprot.writeStructBegin('addCategory_args')
9125 
    if self.category is not None:
9126 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9127 
      self.category.write(oprot)
9128 
      oprot.writeFieldEnd()
9129 
    oprot.writeFieldStop()
9130 
    oprot.writeStructEnd()
9131 
 
9132 
  def validate(self):
9133 
    return
9134 
 
9135 
 
9136 
  def __repr__(self):
9137 
    L = ['%s=%r' % (key, value)
9138 
      for key, value in self.__dict__.iteritems()]
9139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9140 
 
9141 
  def __eq__(self, other):
9142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9143 
 
9144 
  def __ne__(self, other):
9145 
    return not (self == other)
9146 
 
9147 
class addCategory_result:
9148 
  """
9149 
  Attributes:
9150 
   - success
9151 
  """
9152 
 
9153 
  thrift_spec = (
9154 
    (0, TType.BOOL, 'success', None, None, ), # 0
9155 
  )
9156 
 
9157 
  def __init__(self, success=None,):
9158 
    self.success = success
9159 
 
9160 
  def read(self, iprot):
9161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9163 
      return
9164 
    iprot.readStructBegin()
9165 
    while True:
9166 
      (fname, ftype, fid) = iprot.readFieldBegin()
9167 
      if ftype == TType.STOP:
9168 
        break
9169 
      if fid == 0:
9170 
        if ftype == TType.BOOL:
9171 
          self.success = iprot.readBool();
9172 
        else:
9173 
          iprot.skip(ftype)
9174 
      else:
9175 
        iprot.skip(ftype)
9176 
      iprot.readFieldEnd()
9177 
    iprot.readStructEnd()
9178 
 
9179 
  def write(self, oprot):
9180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9182 
      return
9183 
    oprot.writeStructBegin('addCategory_result')
9184 
    if self.success is not None:
9185 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9186 
      oprot.writeBool(self.success)
9187 
      oprot.writeFieldEnd()
9188 
    oprot.writeFieldStop()
9189 
    oprot.writeStructEnd()
9190 
 
9191 
  def validate(self):
9192 
    return
9193 
 
9194 
 
9195 
  def __repr__(self):
9196 
    L = ['%s=%r' % (key, value)
9197 
      for key, value in self.__dict__.iteritems()]
9198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9199 
 
9200 
  def __eq__(self, other):
9201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9202 
 
9203 
  def __ne__(self, other):
9204 
    return not (self == other)
9205 
 
9206 
class getCategory_args:
9207 
  """
9208 
  Attributes:
9209 
   - id
9210 
  """
9211 
 
9212 
  thrift_spec = (
9213 
    None, # 0
9214 
    (1, TType.I64, 'id', None, None, ), # 1
9215 
  )
9216 
 
9217 
  def __init__(self, id=None,):
9218 
    self.id = id
9219 
 
9220 
  def read(self, iprot):
9221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9223 
      return
9224 
    iprot.readStructBegin()
9225 
    while True:
9226 
      (fname, ftype, fid) = iprot.readFieldBegin()
9227 
      if ftype == TType.STOP:
9228 
        break
9229 
      if fid == 1:
9230 
        if ftype == TType.I64:
9231 
          self.id = iprot.readI64();
9232 
        else:
9233 
          iprot.skip(ftype)
9234 
      else:
9235 
        iprot.skip(ftype)
9236 
      iprot.readFieldEnd()
9237 
    iprot.readStructEnd()
9238 
 
9239 
  def write(self, oprot):
9240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9242 
      return
9243 
    oprot.writeStructBegin('getCategory_args')
9244 
    if self.id is not None:
9245 
      oprot.writeFieldBegin('id', TType.I64, 1)
9246 
      oprot.writeI64(self.id)
9247 
      oprot.writeFieldEnd()
9248 
    oprot.writeFieldStop()
9249 
    oprot.writeStructEnd()
9250 
 
9251 
  def validate(self):
9252 
    return
9253 
 
9254 
 
9255 
  def __repr__(self):
9256 
    L = ['%s=%r' % (key, value)
9257 
      for key, value in self.__dict__.iteritems()]
9258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9259 
 
9260 
  def __eq__(self, other):
9261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9262 
 
9263 
  def __ne__(self, other):
9264 
    return not (self == other)
9265 
 
9266 
class getCategory_result:
9267 
  """
9268 
  Attributes:
9269 
   - success
9270 
  """
9271 
 
9272 
  thrift_spec = (
9273 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9274 
  )
9275 
 
9276 
  def __init__(self, success=None,):
9277 
    self.success = success
9278 
 
9279 
  def read(self, iprot):
9280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9282 
      return
9283 
    iprot.readStructBegin()
9284 
    while True:
9285 
      (fname, ftype, fid) = iprot.readFieldBegin()
9286 
      if ftype == TType.STOP:
9287 
        break
9288 
      if fid == 0:
9289 
        if ftype == TType.STRUCT:
9290 
          self.success = Category()
9291 
          self.success.read(iprot)
9292 
        else:
9293 
          iprot.skip(ftype)
9294 
      else:
9295 
        iprot.skip(ftype)
9296 
      iprot.readFieldEnd()
9297 
    iprot.readStructEnd()
9298 
 
9299 
  def write(self, oprot):
9300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9302 
      return
9303 
    oprot.writeStructBegin('getCategory_result')
9304 
    if self.success is not None:
9305 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9306 
      self.success.write(oprot)
9307 
      oprot.writeFieldEnd()
9308 
    oprot.writeFieldStop()
9309 
    oprot.writeStructEnd()
9310 
 
9311 
  def validate(self):
9312 
    return
9313 
 
9314 
 
9315 
  def __repr__(self):
9316 
    L = ['%s=%r' % (key, value)
9317 
      for key, value in self.__dict__.iteritems()]
9318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9319 
 
9320 
  def __eq__(self, other):
9321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9322 
 
9323 
  def __ne__(self, other):
9324 
    return not (self == other)
9325 
 
9326 
class getAllCategories_args:
9327 
 
9328 
  thrift_spec = (
9329 
  )
9330 
 
9331 
  def read(self, iprot):
9332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9334 
      return
9335 
    iprot.readStructBegin()
9336 
    while True:
9337 
      (fname, ftype, fid) = iprot.readFieldBegin()
9338 
      if ftype == TType.STOP:
9339 
        break
9340 
      else:
9341 
        iprot.skip(ftype)
9342 
      iprot.readFieldEnd()
9343 
    iprot.readStructEnd()
9344 
 
9345 
  def write(self, oprot):
9346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9348 
      return
9349 
    oprot.writeStructBegin('getAllCategories_args')
9350 
    oprot.writeFieldStop()
9351 
    oprot.writeStructEnd()
9352 
 
9353 
  def validate(self):
9354 
    return
9355 
 
9356 
 
9357 
  def __repr__(self):
9358 
    L = ['%s=%r' % (key, value)
9359 
      for key, value in self.__dict__.iteritems()]
9360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9361 
 
9362 
  def __eq__(self, other):
9363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9364 
 
9365 
  def __ne__(self, other):
9366 
    return not (self == other)
9367 
 
9368 
class getAllCategories_result:
9369 
  """
9370 
  Attributes:
9371 
   - success
9372 
  """
9373 
 
9374 
  thrift_spec = (
9375 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9376 
  )
9377 
 
9378 
  def __init__(self, success=None,):
9379 
    self.success = success
9380 
 
9381 
  def read(self, iprot):
9382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9384 
      return
9385 
    iprot.readStructBegin()
9386 
    while True:
9387 
      (fname, ftype, fid) = iprot.readFieldBegin()
9388 
      if ftype == TType.STOP:
9389 
        break
9390 
      if fid == 0:
9391 
        if ftype == TType.LIST:
9392 
          self.success = []
9393 
          (_etype124, _size121) = iprot.readListBegin()
9394 
          for _i125 in xrange(_size121):
9395 
            _elem126 = Category()
9396 
            _elem126.read(iprot)
9397 
            self.success.append(_elem126)
9398 
          iprot.readListEnd()
9399 
        else:
9400 
          iprot.skip(ftype)
9401 
      else:
9402 
        iprot.skip(ftype)
9403 
      iprot.readFieldEnd()
9404 
    iprot.readStructEnd()
9405 
 
9406 
  def write(self, oprot):
9407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9409 
      return
9410 
    oprot.writeStructBegin('getAllCategories_result')
9411 
    if self.success is not None:
9412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9413 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9414 
      for iter127 in self.success:
9415 
        iter127.write(oprot)
9416 
      oprot.writeListEnd()
9417 
      oprot.writeFieldEnd()
9418 
    oprot.writeFieldStop()
9419 
    oprot.writeStructEnd()
9420 
 
9421 
  def validate(self):
9422 
    return
9423 
 
9424 
 
9425 
  def __repr__(self):
9426 
    L = ['%s=%r' % (key, value)
9427 
      for key, value in self.__dict__.iteritems()]
9428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9429 
 
9430 
  def __eq__(self, other):
9431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9432 
 
9433 
  def __ne__(self, other):
9434 
    return not (self == other)
9435 
 
9436 
class getAllSimilarItems_args:
9437 
  """
9438 
  Attributes:
9439 
   - itemId
9440 
  """
9441 
 
9442 
  thrift_spec = (
9443 
    None, # 0
9444 
    (1, TType.I64, 'itemId', None, None, ), # 1
9445 
  )
9446 
 
9447 
  def __init__(self, itemId=None,):
9448 
    self.itemId = itemId
9449 
 
9450 
  def read(self, iprot):
9451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9453 
      return
9454 
    iprot.readStructBegin()
9455 
    while True:
9456 
      (fname, ftype, fid) = iprot.readFieldBegin()
9457 
      if ftype == TType.STOP:
9458 
        break
9459 
      if fid == 1:
9460 
        if ftype == TType.I64:
9461 
          self.itemId = iprot.readI64();
9462 
        else:
9463 
          iprot.skip(ftype)
9464 
      else:
9465 
        iprot.skip(ftype)
9466 
      iprot.readFieldEnd()
9467 
    iprot.readStructEnd()
9468 
 
9469 
  def write(self, oprot):
9470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9472 
      return
9473 
    oprot.writeStructBegin('getAllSimilarItems_args')
9474 
    if self.itemId is not None:
9475 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9476 
      oprot.writeI64(self.itemId)
9477 
      oprot.writeFieldEnd()
9478 
    oprot.writeFieldStop()
9479 
    oprot.writeStructEnd()
9480 
 
9481 
  def validate(self):
9482 
    return
9483 
 
9484 
 
9485 
  def __repr__(self):
9486 
    L = ['%s=%r' % (key, value)
9487 
      for key, value in self.__dict__.iteritems()]
9488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9489 
 
9490 
  def __eq__(self, other):
9491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9492 
 
9493 
  def __ne__(self, other):
9494 
    return not (self == other)
9495 
 
9496 
class getAllSimilarItems_result:
9497 
  """
9498 
  Attributes:
9499 
   - success
9500 
  """
9501 
 
9502 
  thrift_spec = (
9503 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9504 
  )
9505 
 
9506 
  def __init__(self, success=None,):
9507 
    self.success = success
9508 
 
9509 
  def read(self, iprot):
9510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9512 
      return
9513 
    iprot.readStructBegin()
9514 
    while True:
9515 
      (fname, ftype, fid) = iprot.readFieldBegin()
9516 
      if ftype == TType.STOP:
9517 
        break
9518 
      if fid == 0:
9519 
        if ftype == TType.LIST:
9520 
          self.success = []
9521 
          (_etype131, _size128) = iprot.readListBegin()
9522 
          for _i132 in xrange(_size128):
9523 
            _elem133 = Item()
9524 
            _elem133.read(iprot)
9525 
            self.success.append(_elem133)
9526 
          iprot.readListEnd()
9527 
        else:
9528 
          iprot.skip(ftype)
9529 
      else:
9530 
        iprot.skip(ftype)
9531 
      iprot.readFieldEnd()
9532 
    iprot.readStructEnd()
9533 
 
9534 
  def write(self, oprot):
9535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9537 
      return
9538 
    oprot.writeStructBegin('getAllSimilarItems_result')
9539 
    if self.success is not None:
9540 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9541 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9542 
      for iter134 in self.success:
9543 
        iter134.write(oprot)
9544 
      oprot.writeListEnd()
9545 
      oprot.writeFieldEnd()
9546 
    oprot.writeFieldStop()
9547 
    oprot.writeStructEnd()
9548 
 
9549 
  def validate(self):
9550 
    return
9551 
 
9552 
 
9553 
  def __repr__(self):
9554 
    L = ['%s=%r' % (key, value)
9555 
      for key, value in self.__dict__.iteritems()]
9556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9557 
 
9558 
  def __eq__(self, other):
9559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9560 
 
9561 
  def __ne__(self, other):
9562 
    return not (self == other)
9563 
 
9564 
class addSimilarItem_args:
9565 
  """
9566 
  Attributes:
9567 
   - itemId
9568 
   - catalogItemId
9569 
  """
9570 
 
9571 
  thrift_spec = (
9572 
    None, # 0
9573 
    (1, TType.I64, 'itemId', None, None, ), # 1
9574 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9575 
  )
9576 
 
9577 
  def __init__(self, itemId=None, catalogItemId=None,):
9578 
    self.itemId = itemId
9579 
    self.catalogItemId = catalogItemId
9580 
 
9581 
  def read(self, iprot):
9582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9584 
      return
9585 
    iprot.readStructBegin()
9586 
    while True:
9587 
      (fname, ftype, fid) = iprot.readFieldBegin()
9588 
      if ftype == TType.STOP:
9589 
        break
9590 
      if fid == 1:
9591 
        if ftype == TType.I64:
9592 
          self.itemId = iprot.readI64();
9593 
        else:
9594 
          iprot.skip(ftype)
9595 
      elif fid == 2:
9596 
        if ftype == TType.I64:
9597 
          self.catalogItemId = iprot.readI64();
9598 
        else:
9599 
          iprot.skip(ftype)
9600 
      else:
9601 
        iprot.skip(ftype)
9602 
      iprot.readFieldEnd()
9603 
    iprot.readStructEnd()
9604 
 
9605 
  def write(self, oprot):
9606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9608 
      return
9609 
    oprot.writeStructBegin('addSimilarItem_args')
9610 
    if self.itemId is not None:
9611 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9612 
      oprot.writeI64(self.itemId)
9613 
      oprot.writeFieldEnd()
9614 
    if self.catalogItemId is not None:
9615 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9616 
      oprot.writeI64(self.catalogItemId)
9617 
      oprot.writeFieldEnd()
9618 
    oprot.writeFieldStop()
9619 
    oprot.writeStructEnd()
9620 
 
9621 
  def validate(self):
9622 
    return
9623 
 
9624 
 
9625 
  def __repr__(self):
9626 
    L = ['%s=%r' % (key, value)
9627 
      for key, value in self.__dict__.iteritems()]
9628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9629 
 
9630 
  def __eq__(self, other):
9631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9632 
 
9633 
  def __ne__(self, other):
9634 
    return not (self == other)
9635 
 
9636 
class addSimilarItem_result:
9637 
  """
9638 
  Attributes:
9639 
   - success
9640 
   - cex
9641 
  """
9642 
 
9643 
  thrift_spec = (
9644 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9645 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9646 
  )
9647 
 
9648 
  def __init__(self, success=None, cex=None,):
9649 
    self.success = success
9650 
    self.cex = cex
9651 
 
9652 
  def read(self, iprot):
9653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9655 
      return
9656 
    iprot.readStructBegin()
9657 
    while True:
9658 
      (fname, ftype, fid) = iprot.readFieldBegin()
9659 
      if ftype == TType.STOP:
9660 
        break
9661 
      if fid == 0:
9662 
        if ftype == TType.STRUCT:
9663 
          self.success = Item()
9664 
          self.success.read(iprot)
9665 
        else:
9666 
          iprot.skip(ftype)
9667 
      elif fid == 1:
9668 
        if ftype == TType.STRUCT:
9669 
          self.cex = CatalogServiceException()
9670 
          self.cex.read(iprot)
9671 
        else:
9672 
          iprot.skip(ftype)
9673 
      else:
9674 
        iprot.skip(ftype)
9675 
      iprot.readFieldEnd()
9676 
    iprot.readStructEnd()
9677 
 
9678 
  def write(self, oprot):
9679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9681 
      return
9682 
    oprot.writeStructBegin('addSimilarItem_result')
9683 
    if self.success is not None:
9684 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9685 
      self.success.write(oprot)
9686 
      oprot.writeFieldEnd()
9687 
    if self.cex is not None:
9688 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9689 
      self.cex.write(oprot)
9690 
      oprot.writeFieldEnd()
9691 
    oprot.writeFieldStop()
9692 
    oprot.writeStructEnd()
9693 
 
9694 
  def validate(self):
9695 
    return
9696 
 
9697 
 
9698 
  def __repr__(self):
9699 
    L = ['%s=%r' % (key, value)
9700 
      for key, value in self.__dict__.iteritems()]
9701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9702 
 
9703 
  def __eq__(self, other):
9704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9705 
 
9706 
  def __ne__(self, other):
9707 
    return not (self == other)
9708 
 
6512 kshitij.so 9709 
class addTag_args:
9710 
  """
9711 
  Attributes:
9712 
   - displayName
9713 
   - itemId
9714 
  """
9715 
 
9716 
  thrift_spec = (
9717 
    None, # 0
9718 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9719 
    (2, TType.I64, 'itemId', None, None, ), # 2
9720 
  )
9721 
 
9722 
  def __init__(self, displayName=None, itemId=None,):
9723 
    self.displayName = displayName
9724 
    self.itemId = itemId
9725 
 
9726 
  def read(self, iprot):
9727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9729 
      return
9730 
    iprot.readStructBegin()
9731 
    while True:
9732 
      (fname, ftype, fid) = iprot.readFieldBegin()
9733 
      if ftype == TType.STOP:
9734 
        break
9735 
      if fid == 1:
9736 
        if ftype == TType.STRING:
9737 
          self.displayName = iprot.readString();
9738 
        else:
9739 
          iprot.skip(ftype)
9740 
      elif fid == 2:
9741 
        if ftype == TType.I64:
9742 
          self.itemId = iprot.readI64();
9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      else:
9746 
        iprot.skip(ftype)
9747 
      iprot.readFieldEnd()
9748 
    iprot.readStructEnd()
9749 
 
9750 
  def write(self, oprot):
9751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9753 
      return
9754 
    oprot.writeStructBegin('addTag_args')
9755 
    if self.displayName is not None:
9756 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9757 
      oprot.writeString(self.displayName)
9758 
      oprot.writeFieldEnd()
9759 
    if self.itemId is not None:
9760 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9761 
      oprot.writeI64(self.itemId)
9762 
      oprot.writeFieldEnd()
9763 
    oprot.writeFieldStop()
9764 
    oprot.writeStructEnd()
9765 
 
9766 
  def validate(self):
9767 
    return
9768 
 
9769 
 
9770 
  def __repr__(self):
9771 
    L = ['%s=%r' % (key, value)
9772 
      for key, value in self.__dict__.iteritems()]
9773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9774 
 
9775 
  def __eq__(self, other):
9776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9777 
 
9778 
  def __ne__(self, other):
9779 
    return not (self == other)
9780 
 
9781 
class addTag_result:
9782 
  """
9783 
  Attributes:
9784 
   - success
9785 
  """
9786 
 
9787 
  thrift_spec = (
9788 
    (0, TType.BOOL, 'success', None, None, ), # 0
9789 
  )
9790 
 
9791 
  def __init__(self, success=None,):
9792 
    self.success = success
9793 
 
9794 
  def read(self, iprot):
9795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9797 
      return
9798 
    iprot.readStructBegin()
9799 
    while True:
9800 
      (fname, ftype, fid) = iprot.readFieldBegin()
9801 
      if ftype == TType.STOP:
9802 
        break
9803 
      if fid == 0:
9804 
        if ftype == TType.BOOL:
9805 
          self.success = iprot.readBool();
9806 
        else:
9807 
          iprot.skip(ftype)
9808 
      else:
9809 
        iprot.skip(ftype)
9810 
      iprot.readFieldEnd()
9811 
    iprot.readStructEnd()
9812 
 
9813 
  def write(self, oprot):
9814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9816 
      return
9817 
    oprot.writeStructBegin('addTag_result')
9818 
    if self.success is not None:
9819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9820 
      oprot.writeBool(self.success)
9821 
      oprot.writeFieldEnd()
9822 
    oprot.writeFieldStop()
9823 
    oprot.writeStructEnd()
9824 
 
9825 
  def validate(self):
9826 
    return
9827 
 
9828 
 
9829 
  def __repr__(self):
9830 
    L = ['%s=%r' % (key, value)
9831 
      for key, value in self.__dict__.iteritems()]
9832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9833 
 
9834 
  def __eq__(self, other):
9835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9836 
 
9837 
  def __ne__(self, other):
9838 
    return not (self == other)
9839 
 
9840 
class deleteEntityTag_args:
9841 
  """
9842 
  Attributes:
9843 
   - displayName
9844 
   - itemId
9845 
  """
9846 
 
9847 
  thrift_spec = (
9848 
    None, # 0
9849 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9850 
    (2, TType.I64, 'itemId', None, None, ), # 2
9851 
  )
9852 
 
9853 
  def __init__(self, displayName=None, itemId=None,):
9854 
    self.displayName = displayName
9855 
    self.itemId = itemId
9856 
 
9857 
  def read(self, iprot):
9858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9860 
      return
9861 
    iprot.readStructBegin()
9862 
    while True:
9863 
      (fname, ftype, fid) = iprot.readFieldBegin()
9864 
      if ftype == TType.STOP:
9865 
        break
9866 
      if fid == 1:
9867 
        if ftype == TType.STRING:
9868 
          self.displayName = iprot.readString();
9869 
        else:
9870 
          iprot.skip(ftype)
9871 
      elif fid == 2:
9872 
        if ftype == TType.I64:
9873 
          self.itemId = iprot.readI64();
9874 
        else:
9875 
          iprot.skip(ftype)
9876 
      else:
9877 
        iprot.skip(ftype)
9878 
      iprot.readFieldEnd()
9879 
    iprot.readStructEnd()
9880 
 
9881 
  def write(self, oprot):
9882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9884 
      return
9885 
    oprot.writeStructBegin('deleteEntityTag_args')
9886 
    if self.displayName is not None:
9887 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9888 
      oprot.writeString(self.displayName)
9889 
      oprot.writeFieldEnd()
9890 
    if self.itemId is not None:
9891 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9892 
      oprot.writeI64(self.itemId)
9893 
      oprot.writeFieldEnd()
9894 
    oprot.writeFieldStop()
9895 
    oprot.writeStructEnd()
9896 
 
9897 
  def validate(self):
9898 
    return
9899 
 
9900 
 
9901 
  def __repr__(self):
9902 
    L = ['%s=%r' % (key, value)
9903 
      for key, value in self.__dict__.iteritems()]
9904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9905 
 
9906 
  def __eq__(self, other):
9907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9908 
 
9909 
  def __ne__(self, other):
9910 
    return not (self == other)
9911 
 
9912 
class deleteEntityTag_result:
9913 
  """
9914 
  Attributes:
9915 
   - success
9916 
  """
9917 
 
9918 
  thrift_spec = (
9919 
    (0, TType.BOOL, 'success', None, None, ), # 0
9920 
  )
9921 
 
9922 
  def __init__(self, success=None,):
9923 
    self.success = success
9924 
 
9925 
  def read(self, iprot):
9926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9928 
      return
9929 
    iprot.readStructBegin()
9930 
    while True:
9931 
      (fname, ftype, fid) = iprot.readFieldBegin()
9932 
      if ftype == TType.STOP:
9933 
        break
9934 
      if fid == 0:
9935 
        if ftype == TType.BOOL:
9936 
          self.success = iprot.readBool();
9937 
        else:
9938 
          iprot.skip(ftype)
9939 
      else:
9940 
        iprot.skip(ftype)
9941 
      iprot.readFieldEnd()
9942 
    iprot.readStructEnd()
9943 
 
9944 
  def write(self, oprot):
9945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9947 
      return
9948 
    oprot.writeStructBegin('deleteEntityTag_result')
9949 
    if self.success is not None:
9950 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9951 
      oprot.writeBool(self.success)
9952 
      oprot.writeFieldEnd()
9953 
    oprot.writeFieldStop()
9954 
    oprot.writeStructEnd()
9955 
 
9956 
  def validate(self):
9957 
    return
9958 
 
9959 
 
9960 
  def __repr__(self):
9961 
    L = ['%s=%r' % (key, value)
9962 
      for key, value in self.__dict__.iteritems()]
9963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9964 
 
9965 
  def __eq__(self, other):
9966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9967 
 
9968 
  def __ne__(self, other):
9969 
    return not (self == other)
9970 
 
9971 
class deleteTag_args:
9972 
  """
9973 
  Attributes:
9974 
   - displayName
9975 
  """
9976 
 
9977 
  thrift_spec = (
9978 
    None, # 0
9979 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9980 
  )
9981 
 
9982 
  def __init__(self, displayName=None,):
9983 
    self.displayName = displayName
9984 
 
9985 
  def read(self, iprot):
9986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9988 
      return
9989 
    iprot.readStructBegin()
9990 
    while True:
9991 
      (fname, ftype, fid) = iprot.readFieldBegin()
9992 
      if ftype == TType.STOP:
9993 
        break
9994 
      if fid == 1:
9995 
        if ftype == TType.STRING:
9996 
          self.displayName = iprot.readString();
9997 
        else:
9998 
          iprot.skip(ftype)
9999 
      else:
10000 
        iprot.skip(ftype)
10001 
      iprot.readFieldEnd()
10002 
    iprot.readStructEnd()
10003 
 
10004 
  def write(self, oprot):
10005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10007 
      return
10008 
    oprot.writeStructBegin('deleteTag_args')
10009 
    if self.displayName is not None:
10010 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10011 
      oprot.writeString(self.displayName)
10012 
      oprot.writeFieldEnd()
10013 
    oprot.writeFieldStop()
10014 
    oprot.writeStructEnd()
10015 
 
10016 
  def validate(self):
10017 
    return
10018 
 
10019 
 
10020 
  def __repr__(self):
10021 
    L = ['%s=%r' % (key, value)
10022 
      for key, value in self.__dict__.iteritems()]
10023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10024 
 
10025 
  def __eq__(self, other):
10026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10027 
 
10028 
  def __ne__(self, other):
10029 
    return not (self == other)
10030 
 
10031 
class deleteTag_result:
10032 
  """
10033 
  Attributes:
10034 
   - success
10035 
  """
10036 
 
10037 
  thrift_spec = (
10038 
    (0, TType.BOOL, 'success', None, None, ), # 0
10039 
  )
10040 
 
10041 
  def __init__(self, success=None,):
10042 
    self.success = success
10043 
 
10044 
  def read(self, iprot):
10045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10047 
      return
10048 
    iprot.readStructBegin()
10049 
    while True:
10050 
      (fname, ftype, fid) = iprot.readFieldBegin()
10051 
      if ftype == TType.STOP:
10052 
        break
10053 
      if fid == 0:
10054 
        if ftype == TType.BOOL:
10055 
          self.success = iprot.readBool();
10056 
        else:
10057 
          iprot.skip(ftype)
10058 
      else:
10059 
        iprot.skip(ftype)
10060 
      iprot.readFieldEnd()
10061 
    iprot.readStructEnd()
10062 
 
10063 
  def write(self, oprot):
10064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10066 
      return
10067 
    oprot.writeStructBegin('deleteTag_result')
10068 
    if self.success is not None:
10069 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10070 
      oprot.writeBool(self.success)
10071 
      oprot.writeFieldEnd()
10072 
    oprot.writeFieldStop()
10073 
    oprot.writeStructEnd()
10074 
 
10075 
  def validate(self):
10076 
    return
10077 
 
10078 
 
10079 
  def __repr__(self):
10080 
    L = ['%s=%r' % (key, value)
10081 
      for key, value in self.__dict__.iteritems()]
10082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10083 
 
10084 
  def __eq__(self, other):
10085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10086 
 
10087 
  def __ne__(self, other):
10088 
    return not (self == other)
10089 
 
10090 
class getAllTags_args:
10091 
 
10092 
  thrift_spec = (
10093 
  )
10094 
 
10095 
  def read(self, iprot):
10096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10098 
      return
10099 
    iprot.readStructBegin()
10100 
    while True:
10101 
      (fname, ftype, fid) = iprot.readFieldBegin()
10102 
      if ftype == TType.STOP:
10103 
        break
10104 
      else:
10105 
        iprot.skip(ftype)
10106 
      iprot.readFieldEnd()
10107 
    iprot.readStructEnd()
10108 
 
10109 
  def write(self, oprot):
10110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10112 
      return
10113 
    oprot.writeStructBegin('getAllTags_args')
10114 
    oprot.writeFieldStop()
10115 
    oprot.writeStructEnd()
10116 
 
10117 
  def validate(self):
10118 
    return
10119 
 
10120 
 
10121 
  def __repr__(self):
10122 
    L = ['%s=%r' % (key, value)
10123 
      for key, value in self.__dict__.iteritems()]
10124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10125 
 
10126 
  def __eq__(self, other):
10127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10128 
 
10129 
  def __ne__(self, other):
10130 
    return not (self == other)
10131 
 
10132 
class getAllTags_result:
10133 
  """
10134 
  Attributes:
10135 
   - success
10136 
  """
10137 
 
10138 
  thrift_spec = (
10139 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10140 
  )
10141 
 
10142 
  def __init__(self, success=None,):
10143 
    self.success = success
10144 
 
10145 
  def read(self, iprot):
10146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10148 
      return
10149 
    iprot.readStructBegin()
10150 
    while True:
10151 
      (fname, ftype, fid) = iprot.readFieldBegin()
10152 
      if ftype == TType.STOP:
10153 
        break
10154 
      if fid == 0:
10155 
        if ftype == TType.LIST:
10156 
          self.success = []
10157 
          (_etype138, _size135) = iprot.readListBegin()
10158 
          for _i139 in xrange(_size135):
10159 
            _elem140 = iprot.readString();
10160 
            self.success.append(_elem140)
10161 
          iprot.readListEnd()
10162 
        else:
10163 
          iprot.skip(ftype)
10164 
      else:
10165 
        iprot.skip(ftype)
10166 
      iprot.readFieldEnd()
10167 
    iprot.readStructEnd()
10168 
 
10169 
  def write(self, oprot):
10170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10172 
      return
10173 
    oprot.writeStructBegin('getAllTags_result')
10174 
    if self.success is not None:
10175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10176 
      oprot.writeListBegin(TType.STRING, len(self.success))
10177 
      for iter141 in self.success:
10178 
        oprot.writeString(iter141)
10179 
      oprot.writeListEnd()
10180 
      oprot.writeFieldEnd()
10181 
    oprot.writeFieldStop()
10182 
    oprot.writeStructEnd()
10183 
 
10184 
  def validate(self):
10185 
    return
10186 
 
10187 
 
10188 
  def __repr__(self):
10189 
    L = ['%s=%r' % (key, value)
10190 
      for key, value in self.__dict__.iteritems()]
10191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10192 
 
10193 
  def __eq__(self, other):
10194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10195 
 
10196 
  def __ne__(self, other):
10197 
    return not (self == other)
10198 
 
10199 
class getAllEntitiesByTagName_args:
10200 
  """
10201 
  Attributes:
10202 
   - displayName
10203 
  """
10204 
 
10205 
  thrift_spec = (
10206 
    None, # 0
10207 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10208 
  )
10209 
 
10210 
  def __init__(self, displayName=None,):
10211 
    self.displayName = displayName
10212 
 
10213 
  def read(self, iprot):
10214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10216 
      return
10217 
    iprot.readStructBegin()
10218 
    while True:
10219 
      (fname, ftype, fid) = iprot.readFieldBegin()
10220 
      if ftype == TType.STOP:
10221 
        break
10222 
      if fid == 1:
10223 
        if ftype == TType.STRING:
10224 
          self.displayName = iprot.readString();
10225 
        else:
10226 
          iprot.skip(ftype)
10227 
      else:
10228 
        iprot.skip(ftype)
10229 
      iprot.readFieldEnd()
10230 
    iprot.readStructEnd()
10231 
 
10232 
  def write(self, oprot):
10233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10235 
      return
10236 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10237 
    if self.displayName is not None:
10238 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10239 
      oprot.writeString(self.displayName)
10240 
      oprot.writeFieldEnd()
10241 
    oprot.writeFieldStop()
10242 
    oprot.writeStructEnd()
10243 
 
10244 
  def validate(self):
10245 
    return
10246 
 
10247 
 
10248 
  def __repr__(self):
10249 
    L = ['%s=%r' % (key, value)
10250 
      for key, value in self.__dict__.iteritems()]
10251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10252 
 
10253 
  def __eq__(self, other):
10254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10255 
 
10256 
  def __ne__(self, other):
10257 
    return not (self == other)
10258 
 
10259 
class getAllEntitiesByTagName_result:
10260 
  """
10261 
  Attributes:
10262 
   - success
10263 
  """
10264 
 
10265 
  thrift_spec = (
10266 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10267 
  )
10268 
 
10269 
  def __init__(self, success=None,):
10270 
    self.success = success
10271 
 
10272 
  def read(self, iprot):
10273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10275 
      return
10276 
    iprot.readStructBegin()
10277 
    while True:
10278 
      (fname, ftype, fid) = iprot.readFieldBegin()
10279 
      if ftype == TType.STOP:
10280 
        break
10281 
      if fid == 0:
10282 
        if ftype == TType.LIST:
10283 
          self.success = []
10284 
          (_etype145, _size142) = iprot.readListBegin()
10285 
          for _i146 in xrange(_size142):
10286 
            _elem147 = iprot.readI64();
10287 
            self.success.append(_elem147)
10288 
          iprot.readListEnd()
10289 
        else:
10290 
          iprot.skip(ftype)
10291 
      else:
10292 
        iprot.skip(ftype)
10293 
      iprot.readFieldEnd()
10294 
    iprot.readStructEnd()
10295 
 
10296 
  def write(self, oprot):
10297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10299 
      return
10300 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10301 
    if self.success is not None:
10302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10303 
      oprot.writeListBegin(TType.I64, len(self.success))
10304 
      for iter148 in self.success:
10305 
        oprot.writeI64(iter148)
10306 
      oprot.writeListEnd()
10307 
      oprot.writeFieldEnd()
10308 
    oprot.writeFieldStop()
10309 
    oprot.writeStructEnd()
10310 
 
10311 
  def validate(self):
10312 
    return
10313 
 
10314 
 
10315 
  def __repr__(self):
10316 
    L = ['%s=%r' % (key, value)
10317 
      for key, value in self.__dict__.iteritems()]
10318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10319 
 
10320 
  def __eq__(self, other):
10321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10322 
 
10323 
  def __ne__(self, other):
10324 
    return not (self == other)
10325 
 
6845 amit.gupta 10326 
class getAllEntityTags_args:
10327 
 
10328 
  thrift_spec = (
10329 
  )
10330 
 
10331 
  def read(self, iprot):
10332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10334 
      return
10335 
    iprot.readStructBegin()
10336 
    while True:
10337 
      (fname, ftype, fid) = iprot.readFieldBegin()
10338 
      if ftype == TType.STOP:
10339 
        break
10340 
      else:
10341 
        iprot.skip(ftype)
10342 
      iprot.readFieldEnd()
10343 
    iprot.readStructEnd()
10344 
 
10345 
  def write(self, oprot):
10346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10348 
      return
10349 
    oprot.writeStructBegin('getAllEntityTags_args')
10350 
    oprot.writeFieldStop()
10351 
    oprot.writeStructEnd()
10352 
 
10353 
  def validate(self):
10354 
    return
10355 
 
10356 
 
10357 
  def __repr__(self):
10358 
    L = ['%s=%r' % (key, value)
10359 
      for key, value in self.__dict__.iteritems()]
10360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10361 
 
10362 
  def __eq__(self, other):
10363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10364 
 
10365 
  def __ne__(self, other):
10366 
    return not (self == other)
10367 
 
10368 
class getAllEntityTags_result:
10369 
  """
10370 
  Attributes:
10371 
   - success
10372 
  """
10373 
 
10374 
  thrift_spec = (
10375 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10376 
  )
10377 
 
10378 
  def __init__(self, success=None,):
10379 
    self.success = success
10380 
 
10381 
  def read(self, iprot):
10382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10384 
      return
10385 
    iprot.readStructBegin()
10386 
    while True:
10387 
      (fname, ftype, fid) = iprot.readFieldBegin()
10388 
      if ftype == TType.STOP:
10389 
        break
10390 
      if fid == 0:
10391 
        if ftype == TType.MAP:
10392 
          self.success = {}
10393 
          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
10394 
          for _i153 in xrange(_size149):
10395 
            _key154 = iprot.readI64();
10396 
            _val155 = []
10397 
            (_etype159, _size156) = iprot.readListBegin()
10398 
            for _i160 in xrange(_size156):
10399 
              _elem161 = iprot.readString();
10400 
              _val155.append(_elem161)
10401 
            iprot.readListEnd()
10402 
            self.success[_key154] = _val155
10403 
          iprot.readMapEnd()
10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      else:
10407 
        iprot.skip(ftype)
10408 
      iprot.readFieldEnd()
10409 
    iprot.readStructEnd()
10410 
 
10411 
  def write(self, oprot):
10412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10414 
      return
10415 
    oprot.writeStructBegin('getAllEntityTags_result')
10416 
    if self.success is not None:
10417 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10418 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
10419 
      for kiter162,viter163 in self.success.items():
10420 
        oprot.writeI64(kiter162)
10421 
        oprot.writeListBegin(TType.STRING, len(viter163))
10422 
        for iter164 in viter163:
10423 
          oprot.writeString(iter164)
10424 
        oprot.writeListEnd()
10425 
      oprot.writeMapEnd()
10426 
      oprot.writeFieldEnd()
10427 
    oprot.writeFieldStop()
10428 
    oprot.writeStructEnd()
10429 
 
10430 
  def validate(self):
10431 
    return
10432 
 
10433 
 
10434 
  def __repr__(self):
10435 
    L = ['%s=%r' % (key, value)
10436 
      for key, value in self.__dict__.iteritems()]
10437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10438 
 
10439 
  def __eq__(self, other):
10440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10441 
 
10442 
  def __ne__(self, other):
10443 
    return not (self == other)
10444 
 
6850 kshitij.so 10445 
class addBanner_args:
10446 
  """
10447 
  Attributes:
10448 
   - bannerName
10449 
   - imageName
10450 
   - link
10451 
   - priority
10452 
   - isActive
10453 
   - hasMap
10454 
  """
10455 
 
10456 
  thrift_spec = (
10457 
    None, # 0
10458 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10459 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10460 
    (3, TType.STRING, 'link', None, None, ), # 3
10461 
    (4, TType.I64, 'priority', None, None, ), # 4
10462 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10463 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10464 
  )
10465 
 
10466 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10467 
    self.bannerName = bannerName
10468 
    self.imageName = imageName
10469 
    self.link = link
10470 
    self.priority = priority
10471 
    self.isActive = isActive
10472 
    self.hasMap = hasMap
10473 
 
10474 
  def read(self, iprot):
10475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10477 
      return
10478 
    iprot.readStructBegin()
10479 
    while True:
10480 
      (fname, ftype, fid) = iprot.readFieldBegin()
10481 
      if ftype == TType.STOP:
10482 
        break
10483 
      if fid == 1:
10484 
        if ftype == TType.STRING:
10485 
          self.bannerName = iprot.readString();
10486 
        else:
10487 
          iprot.skip(ftype)
10488 
      elif fid == 2:
10489 
        if ftype == TType.STRING:
10490 
          self.imageName = iprot.readString();
10491 
        else:
10492 
          iprot.skip(ftype)
10493 
      elif fid == 3:
10494 
        if ftype == TType.STRING:
10495 
          self.link = iprot.readString();
10496 
        else:
10497 
          iprot.skip(ftype)
10498 
      elif fid == 4:
10499 
        if ftype == TType.I64:
10500 
          self.priority = iprot.readI64();
10501 
        else:
10502 
          iprot.skip(ftype)
10503 
      elif fid == 5:
10504 
        if ftype == TType.BOOL:
10505 
          self.isActive = iprot.readBool();
10506 
        else:
10507 
          iprot.skip(ftype)
10508 
      elif fid == 6:
10509 
        if ftype == TType.BOOL:
10510 
          self.hasMap = iprot.readBool();
10511 
        else:
10512 
          iprot.skip(ftype)
10513 
      else:
10514 
        iprot.skip(ftype)
10515 
      iprot.readFieldEnd()
10516 
    iprot.readStructEnd()
10517 
 
10518 
  def write(self, oprot):
10519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10521 
      return
10522 
    oprot.writeStructBegin('addBanner_args')
10523 
    if self.bannerName is not None:
10524 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10525 
      oprot.writeString(self.bannerName)
10526 
      oprot.writeFieldEnd()
10527 
    if self.imageName is not None:
10528 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10529 
      oprot.writeString(self.imageName)
10530 
      oprot.writeFieldEnd()
10531 
    if self.link is not None:
10532 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10533 
      oprot.writeString(self.link)
10534 
      oprot.writeFieldEnd()
10535 
    if self.priority is not None:
10536 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10537 
      oprot.writeI64(self.priority)
10538 
      oprot.writeFieldEnd()
10539 
    if self.isActive is not None:
10540 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10541 
      oprot.writeBool(self.isActive)
10542 
      oprot.writeFieldEnd()
10543 
    if self.hasMap is not None:
10544 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10545 
      oprot.writeBool(self.hasMap)
10546 
      oprot.writeFieldEnd()
10547 
    oprot.writeFieldStop()
10548 
    oprot.writeStructEnd()
10549 
 
10550 
  def validate(self):
10551 
    return
10552 
 
10553 
 
10554 
  def __repr__(self):
10555 
    L = ['%s=%r' % (key, value)
10556 
      for key, value in self.__dict__.iteritems()]
10557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10558 
 
10559 
  def __eq__(self, other):
10560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10561 
 
10562 
  def __ne__(self, other):
10563 
    return not (self == other)
10564 
 
10565 
class addBanner_result:
10566 
  """
10567 
  Attributes:
10568 
   - success
10569 
  """
10570 
 
10571 
  thrift_spec = (
10572 
    (0, TType.BOOL, 'success', None, None, ), # 0
10573 
  )
10574 
 
10575 
  def __init__(self, success=None,):
10576 
    self.success = success
10577 
 
10578 
  def read(self, iprot):
10579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10581 
      return
10582 
    iprot.readStructBegin()
10583 
    while True:
10584 
      (fname, ftype, fid) = iprot.readFieldBegin()
10585 
      if ftype == TType.STOP:
10586 
        break
10587 
      if fid == 0:
10588 
        if ftype == TType.BOOL:
10589 
          self.success = iprot.readBool();
10590 
        else:
10591 
          iprot.skip(ftype)
10592 
      else:
10593 
        iprot.skip(ftype)
10594 
      iprot.readFieldEnd()
10595 
    iprot.readStructEnd()
10596 
 
10597 
  def write(self, oprot):
10598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10600 
      return
10601 
    oprot.writeStructBegin('addBanner_result')
10602 
    if self.success is not None:
10603 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10604 
      oprot.writeBool(self.success)
10605 
      oprot.writeFieldEnd()
10606 
    oprot.writeFieldStop()
10607 
    oprot.writeStructEnd()
10608 
 
10609 
  def validate(self):
10610 
    return
10611 
 
10612 
 
10613 
  def __repr__(self):
10614 
    L = ['%s=%r' % (key, value)
10615 
      for key, value in self.__dict__.iteritems()]
10616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10617 
 
10618 
  def __eq__(self, other):
10619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10620 
 
10621 
  def __ne__(self, other):
10622 
    return not (self == other)
10623 
 
10624 
class getAllBanners_args:
10625 
 
10626 
  thrift_spec = (
10627 
  )
10628 
 
10629 
  def read(self, iprot):
10630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10632 
      return
10633 
    iprot.readStructBegin()
10634 
    while True:
10635 
      (fname, ftype, fid) = iprot.readFieldBegin()
10636 
      if ftype == TType.STOP:
10637 
        break
10638 
      else:
10639 
        iprot.skip(ftype)
10640 
      iprot.readFieldEnd()
10641 
    iprot.readStructEnd()
10642 
 
10643 
  def write(self, oprot):
10644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10646 
      return
10647 
    oprot.writeStructBegin('getAllBanners_args')
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
10665 
 
10666 
class getAllBanners_result:
10667 
  """
10668 
  Attributes:
10669 
   - success
10670 
  """
10671 
 
10672 
  thrift_spec = (
10673 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10674 
  )
10675 
 
10676 
  def __init__(self, success=None,):
10677 
    self.success = success
10678 
 
10679 
  def read(self, iprot):
10680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10682 
      return
10683 
    iprot.readStructBegin()
10684 
    while True:
10685 
      (fname, ftype, fid) = iprot.readFieldBegin()
10686 
      if ftype == TType.STOP:
10687 
        break
10688 
      if fid == 0:
10689 
        if ftype == TType.LIST:
10690 
          self.success = []
10691 
          (_etype168, _size165) = iprot.readListBegin()
10692 
          for _i169 in xrange(_size165):
10693 
            _elem170 = iprot.readString();
10694 
            self.success.append(_elem170)
10695 
          iprot.readListEnd()
10696 
        else:
10697 
          iprot.skip(ftype)
10698 
      else:
10699 
        iprot.skip(ftype)
10700 
      iprot.readFieldEnd()
10701 
    iprot.readStructEnd()
10702 
 
10703 
  def write(self, oprot):
10704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10706 
      return
10707 
    oprot.writeStructBegin('getAllBanners_result')
10708 
    if self.success is not None:
10709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10710 
      oprot.writeListBegin(TType.STRING, len(self.success))
10711 
      for iter171 in self.success:
10712 
        oprot.writeString(iter171)
10713 
      oprot.writeListEnd()
10714 
      oprot.writeFieldEnd()
10715 
    oprot.writeFieldStop()
10716 
    oprot.writeStructEnd()
10717 
 
10718 
  def validate(self):
10719 
    return
10720 
 
10721 
 
10722 
  def __repr__(self):
10723 
    L = ['%s=%r' % (key, value)
10724 
      for key, value in self.__dict__.iteritems()]
10725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10726 
 
10727 
  def __eq__(self, other):
10728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10729 
 
10730 
  def __ne__(self, other):
10731 
    return not (self == other)
10732 
 
10733 
class deleteBanner_args:
10734 
  """
10735 
  Attributes:
10736 
   - bannerName
10737 
  """
10738 
 
10739 
  thrift_spec = (
10740 
    None, # 0
10741 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10742 
  )
10743 
 
10744 
  def __init__(self, bannerName=None,):
10745 
    self.bannerName = bannerName
10746 
 
10747 
  def read(self, iprot):
10748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10750 
      return
10751 
    iprot.readStructBegin()
10752 
    while True:
10753 
      (fname, ftype, fid) = iprot.readFieldBegin()
10754 
      if ftype == TType.STOP:
10755 
        break
10756 
      if fid == 1:
10757 
        if ftype == TType.STRING:
10758 
          self.bannerName = iprot.readString();
10759 
        else:
10760 
          iprot.skip(ftype)
10761 
      else:
10762 
        iprot.skip(ftype)
10763 
      iprot.readFieldEnd()
10764 
    iprot.readStructEnd()
10765 
 
10766 
  def write(self, oprot):
10767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10769 
      return
10770 
    oprot.writeStructBegin('deleteBanner_args')
10771 
    if self.bannerName is not None:
10772 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10773 
      oprot.writeString(self.bannerName)
10774 
      oprot.writeFieldEnd()
10775 
    oprot.writeFieldStop()
10776 
    oprot.writeStructEnd()
10777 
 
10778 
  def validate(self):
10779 
    return
10780 
 
10781 
 
10782 
  def __repr__(self):
10783 
    L = ['%s=%r' % (key, value)
10784 
      for key, value in self.__dict__.iteritems()]
10785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10786 
 
10787 
  def __eq__(self, other):
10788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10789 
 
10790 
  def __ne__(self, other):
10791 
    return not (self == other)
10792 
 
10793 
class deleteBanner_result:
10794 
  """
10795 
  Attributes:
10796 
   - success
10797 
  """
10798 
 
10799 
  thrift_spec = (
10800 
    (0, TType.BOOL, 'success', None, None, ), # 0
10801 
  )
10802 
 
10803 
  def __init__(self, success=None,):
10804 
    self.success = success
10805 
 
10806 
  def read(self, iprot):
10807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10809 
      return
10810 
    iprot.readStructBegin()
10811 
    while True:
10812 
      (fname, ftype, fid) = iprot.readFieldBegin()
10813 
      if ftype == TType.STOP:
10814 
        break
10815 
      if fid == 0:
10816 
        if ftype == TType.BOOL:
10817 
          self.success = iprot.readBool();
10818 
        else:
10819 
          iprot.skip(ftype)
10820 
      else:
10821 
        iprot.skip(ftype)
10822 
      iprot.readFieldEnd()
10823 
    iprot.readStructEnd()
10824 
 
10825 
  def write(self, oprot):
10826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10828 
      return
10829 
    oprot.writeStructBegin('deleteBanner_result')
10830 
    if self.success is not None:
10831 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10832 
      oprot.writeBool(self.success)
10833 
      oprot.writeFieldEnd()
10834 
    oprot.writeFieldStop()
10835 
    oprot.writeStructEnd()
10836 
 
10837 
  def validate(self):
10838 
    return
10839 
 
10840 
 
10841 
  def __repr__(self):
10842 
    L = ['%s=%r' % (key, value)
10843 
      for key, value in self.__dict__.iteritems()]
10844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10845 
 
10846 
  def __eq__(self, other):
10847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10848 
 
10849 
  def __ne__(self, other):
10850 
    return not (self == other)
10851 
 
10852 
class getBannerDetails_args:
10853 
  """
10854 
  Attributes:
10855 
   - bannerName
10856 
  """
10857 
 
10858 
  thrift_spec = (
10859 
    None, # 0
10860 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10861 
  )
10862 
 
10863 
  def __init__(self, bannerName=None,):
10864 
    self.bannerName = bannerName
10865 
 
10866 
  def read(self, iprot):
10867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10869 
      return
10870 
    iprot.readStructBegin()
10871 
    while True:
10872 
      (fname, ftype, fid) = iprot.readFieldBegin()
10873 
      if ftype == TType.STOP:
10874 
        break
10875 
      if fid == 1:
10876 
        if ftype == TType.STRING:
10877 
          self.bannerName = iprot.readString();
10878 
        else:
10879 
          iprot.skip(ftype)
10880 
      else:
10881 
        iprot.skip(ftype)
10882 
      iprot.readFieldEnd()
10883 
    iprot.readStructEnd()
10884 
 
10885 
  def write(self, oprot):
10886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10888 
      return
10889 
    oprot.writeStructBegin('getBannerDetails_args')
10890 
    if self.bannerName is not None:
10891 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10892 
      oprot.writeString(self.bannerName)
10893 
      oprot.writeFieldEnd()
10894 
    oprot.writeFieldStop()
10895 
    oprot.writeStructEnd()
10896 
 
10897 
  def validate(self):
10898 
    return
10899 
 
10900 
 
10901 
  def __repr__(self):
10902 
    L = ['%s=%r' % (key, value)
10903 
      for key, value in self.__dict__.iteritems()]
10904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10905 
 
10906 
  def __eq__(self, other):
10907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10908 
 
10909 
  def __ne__(self, other):
10910 
    return not (self == other)
10911 
 
10912 
class getBannerDetails_result:
10913 
  """
10914 
  Attributes:
10915 
   - success
10916 
  """
10917 
 
10918 
  thrift_spec = (
10919 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
10920 
  )
10921 
 
10922 
  def __init__(self, success=None,):
10923 
    self.success = success
10924 
 
10925 
  def read(self, iprot):
10926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10928 
      return
10929 
    iprot.readStructBegin()
10930 
    while True:
10931 
      (fname, ftype, fid) = iprot.readFieldBegin()
10932 
      if ftype == TType.STOP:
10933 
        break
10934 
      if fid == 0:
10935 
        if ftype == TType.STRUCT:
10936 
          self.success = Banner()
10937 
          self.success.read(iprot)
10938 
        else:
10939 
          iprot.skip(ftype)
10940 
      else:
10941 
        iprot.skip(ftype)
10942 
      iprot.readFieldEnd()
10943 
    iprot.readStructEnd()
10944 
 
10945 
  def write(self, oprot):
10946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10948 
      return
10949 
    oprot.writeStructBegin('getBannerDetails_result')
10950 
    if self.success is not None:
10951 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10952 
      self.success.write(oprot)
10953 
      oprot.writeFieldEnd()
10954 
    oprot.writeFieldStop()
10955 
    oprot.writeStructEnd()
10956 
 
10957 
  def validate(self):
10958 
    return
10959 
 
10960 
 
10961 
  def __repr__(self):
10962 
    L = ['%s=%r' % (key, value)
10963 
      for key, value in self.__dict__.iteritems()]
10964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10965 
 
10966 
  def __eq__(self, other):
10967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10968 
 
10969 
  def __ne__(self, other):
10970 
    return not (self == other)
10971 
 
10972 
class getActiveBanners_args:
10973 
 
10974 
  thrift_spec = (
10975 
  )
10976 
 
10977 
  def read(self, iprot):
10978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10980 
      return
10981 
    iprot.readStructBegin()
10982 
    while True:
10983 
      (fname, ftype, fid) = iprot.readFieldBegin()
10984 
      if ftype == TType.STOP:
10985 
        break
10986 
      else:
10987 
        iprot.skip(ftype)
10988 
      iprot.readFieldEnd()
10989 
    iprot.readStructEnd()
10990 
 
10991 
  def write(self, oprot):
10992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10994 
      return
10995 
    oprot.writeStructBegin('getActiveBanners_args')
10996 
    oprot.writeFieldStop()
10997 
    oprot.writeStructEnd()
10998 
 
10999 
  def validate(self):
11000 
    return
11001 
 
11002 
 
11003 
  def __repr__(self):
11004 
    L = ['%s=%r' % (key, value)
11005 
      for key, value in self.__dict__.iteritems()]
11006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11007 
 
11008 
  def __eq__(self, other):
11009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11010 
 
11011 
  def __ne__(self, other):
11012 
    return not (self == other)
11013 
 
11014 
class getActiveBanners_result:
11015 
  """
11016 
  Attributes:
11017 
   - success
11018 
  """
11019 
 
11020 
  thrift_spec = (
11021 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11022 
  )
11023 
 
11024 
  def __init__(self, success=None,):
11025 
    self.success = success
11026 
 
11027 
  def read(self, iprot):
11028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11030 
      return
11031 
    iprot.readStructBegin()
11032 
    while True:
11033 
      (fname, ftype, fid) = iprot.readFieldBegin()
11034 
      if ftype == TType.STOP:
11035 
        break
11036 
      if fid == 0:
11037 
        if ftype == TType.LIST:
11038 
          self.success = []
11039 
          (_etype175, _size172) = iprot.readListBegin()
11040 
          for _i176 in xrange(_size172):
11041 
            _elem177 = Banner()
11042 
            _elem177.read(iprot)
11043 
            self.success.append(_elem177)
11044 
          iprot.readListEnd()
11045 
        else:
11046 
          iprot.skip(ftype)
11047 
      else:
11048 
        iprot.skip(ftype)
11049 
      iprot.readFieldEnd()
11050 
    iprot.readStructEnd()
11051 
 
11052 
  def write(self, oprot):
11053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11055 
      return
11056 
    oprot.writeStructBegin('getActiveBanners_result')
11057 
    if self.success is not None:
11058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11060 
      for iter178 in self.success:
11061 
        iter178.write(oprot)
11062 
      oprot.writeListEnd()
11063 
      oprot.writeFieldEnd()
11064 
    oprot.writeFieldStop()
11065 
    oprot.writeStructEnd()
11066 
 
11067 
  def validate(self):
11068 
    return
11069 
 
11070 
 
11071 
  def __repr__(self):
11072 
    L = ['%s=%r' % (key, value)
11073 
      for key, value in self.__dict__.iteritems()]
11074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11075 
 
11076 
  def __eq__(self, other):
11077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11078 
 
11079 
  def __ne__(self, other):
11080 
    return not (self == other)
11081 
 
6849 kshitij.so 11082 
class addBannerMap_args:
11083 
  """
11084 
  Attributes:
11085 
   - bannerName
11086 
   - mapLink
11087 
   - coordinates
11088 
  """
11089 
 
11090 
  thrift_spec = (
11091 
    None, # 0
11092 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11093 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11094 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11095 
  )
11096 
 
11097 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11098 
    self.bannerName = bannerName
11099 
    self.mapLink = mapLink
11100 
    self.coordinates = coordinates
11101 
 
11102 
  def read(self, iprot):
11103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11105 
      return
11106 
    iprot.readStructBegin()
11107 
    while True:
11108 
      (fname, ftype, fid) = iprot.readFieldBegin()
11109 
      if ftype == TType.STOP:
11110 
        break
11111 
      if fid == 1:
11112 
        if ftype == TType.STRING:
11113 
          self.bannerName = iprot.readString();
11114 
        else:
11115 
          iprot.skip(ftype)
11116 
      elif fid == 2:
11117 
        if ftype == TType.STRING:
11118 
          self.mapLink = iprot.readString();
11119 
        else:
11120 
          iprot.skip(ftype)
11121 
      elif fid == 3:
11122 
        if ftype == TType.STRING:
11123 
          self.coordinates = iprot.readString();
11124 
        else:
11125 
          iprot.skip(ftype)
11126 
      else:
11127 
        iprot.skip(ftype)
11128 
      iprot.readFieldEnd()
11129 
    iprot.readStructEnd()
11130 
 
11131 
  def write(self, oprot):
11132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11134 
      return
11135 
    oprot.writeStructBegin('addBannerMap_args')
11136 
    if self.bannerName is not None:
11137 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11138 
      oprot.writeString(self.bannerName)
11139 
      oprot.writeFieldEnd()
11140 
    if self.mapLink is not None:
11141 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11142 
      oprot.writeString(self.mapLink)
11143 
      oprot.writeFieldEnd()
11144 
    if self.coordinates is not None:
11145 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11146 
      oprot.writeString(self.coordinates)
11147 
      oprot.writeFieldEnd()
11148 
    oprot.writeFieldStop()
11149 
    oprot.writeStructEnd()
11150 
 
11151 
  def validate(self):
11152 
    return
11153 
 
11154 
 
11155 
  def __repr__(self):
11156 
    L = ['%s=%r' % (key, value)
11157 
      for key, value in self.__dict__.iteritems()]
11158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11159 
 
11160 
  def __eq__(self, other):
11161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11162 
 
11163 
  def __ne__(self, other):
11164 
    return not (self == other)
11165 
 
11166 
class addBannerMap_result:
11167 
  """
11168 
  Attributes:
11169 
   - success
11170 
  """
11171 
 
11172 
  thrift_spec = (
11173 
    (0, TType.BOOL, 'success', None, None, ), # 0
11174 
  )
11175 
 
11176 
  def __init__(self, success=None,):
11177 
    self.success = success
11178 
 
11179 
  def read(self, iprot):
11180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11182 
      return
11183 
    iprot.readStructBegin()
11184 
    while True:
11185 
      (fname, ftype, fid) = iprot.readFieldBegin()
11186 
      if ftype == TType.STOP:
11187 
        break
11188 
      if fid == 0:
11189 
        if ftype == TType.BOOL:
11190 
          self.success = iprot.readBool();
11191 
        else:
11192 
          iprot.skip(ftype)
11193 
      else:
11194 
        iprot.skip(ftype)
11195 
      iprot.readFieldEnd()
11196 
    iprot.readStructEnd()
11197 
 
11198 
  def write(self, oprot):
11199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11201 
      return
11202 
    oprot.writeStructBegin('addBannerMap_result')
11203 
    if self.success is not None:
11204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11205 
      oprot.writeBool(self.success)
11206 
      oprot.writeFieldEnd()
11207 
    oprot.writeFieldStop()
11208 
    oprot.writeStructEnd()
11209 
 
11210 
  def validate(self):
11211 
    return
11212 
 
11213 
 
11214 
  def __repr__(self):
11215 
    L = ['%s=%r' % (key, value)
11216 
      for key, value in self.__dict__.iteritems()]
11217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11218 
 
11219 
  def __eq__(self, other):
11220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11221 
 
11222 
  def __ne__(self, other):
11223 
    return not (self == other)
11224 
 
11225 
class deleteBannerMap_args:
11226 
  """
11227 
  Attributes:
11228 
   - bannerName
11229 
  """
11230 
 
11231 
  thrift_spec = (
11232 
    None, # 0
11233 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11234 
  )
11235 
 
11236 
  def __init__(self, bannerName=None,):
11237 
    self.bannerName = bannerName
11238 
 
11239 
  def read(self, iprot):
11240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11242 
      return
11243 
    iprot.readStructBegin()
11244 
    while True:
11245 
      (fname, ftype, fid) = iprot.readFieldBegin()
11246 
      if ftype == TType.STOP:
11247 
        break
11248 
      if fid == 1:
11249 
        if ftype == TType.STRING:
11250 
          self.bannerName = iprot.readString();
11251 
        else:
11252 
          iprot.skip(ftype)
11253 
      else:
11254 
        iprot.skip(ftype)
11255 
      iprot.readFieldEnd()
11256 
    iprot.readStructEnd()
11257 
 
11258 
  def write(self, oprot):
11259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11261 
      return
11262 
    oprot.writeStructBegin('deleteBannerMap_args')
11263 
    if self.bannerName is not None:
11264 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11265 
      oprot.writeString(self.bannerName)
11266 
      oprot.writeFieldEnd()
11267 
    oprot.writeFieldStop()
11268 
    oprot.writeStructEnd()
11269 
 
11270 
  def validate(self):
11271 
    return
11272 
 
11273 
 
11274 
  def __repr__(self):
11275 
    L = ['%s=%r' % (key, value)
11276 
      for key, value in self.__dict__.iteritems()]
11277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11278 
 
11279 
  def __eq__(self, other):
11280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11281 
 
11282 
  def __ne__(self, other):
11283 
    return not (self == other)
11284 
 
11285 
class deleteBannerMap_result:
11286 
  """
11287 
  Attributes:
11288 
   - success
11289 
  """
11290 
 
11291 
  thrift_spec = (
11292 
    (0, TType.BOOL, 'success', None, None, ), # 0
11293 
  )
11294 
 
11295 
  def __init__(self, success=None,):
11296 
    self.success = success
11297 
 
11298 
  def read(self, iprot):
11299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11301 
      return
11302 
    iprot.readStructBegin()
11303 
    while True:
11304 
      (fname, ftype, fid) = iprot.readFieldBegin()
11305 
      if ftype == TType.STOP:
11306 
        break
11307 
      if fid == 0:
11308 
        if ftype == TType.BOOL:
11309 
          self.success = iprot.readBool();
11310 
        else:
11311 
          iprot.skip(ftype)
11312 
      else:
11313 
        iprot.skip(ftype)
11314 
      iprot.readFieldEnd()
11315 
    iprot.readStructEnd()
11316 
 
11317 
  def write(self, oprot):
11318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11320 
      return
11321 
    oprot.writeStructBegin('deleteBannerMap_result')
11322 
    if self.success is not None:
11323 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11324 
      oprot.writeBool(self.success)
11325 
      oprot.writeFieldEnd()
11326 
    oprot.writeFieldStop()
11327 
    oprot.writeStructEnd()
11328 
 
11329 
  def validate(self):
11330 
    return
11331 
 
11332 
 
11333 
  def __repr__(self):
11334 
    L = ['%s=%r' % (key, value)
11335 
      for key, value in self.__dict__.iteritems()]
11336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11337 
 
11338 
  def __eq__(self, other):
11339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11340 
 
11341 
  def __ne__(self, other):
11342 
    return not (self == other)
11343 
 
11344 
class getBannerMapDetails_args:
11345 
  """
11346 
  Attributes:
11347 
   - bannerName
11348 
  """
11349 
 
11350 
  thrift_spec = (
11351 
    None, # 0
11352 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11353 
  )
11354 
 
11355 
  def __init__(self, bannerName=None,):
11356 
    self.bannerName = bannerName
11357 
 
11358 
  def read(self, iprot):
11359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11361 
      return
11362 
    iprot.readStructBegin()
11363 
    while True:
11364 
      (fname, ftype, fid) = iprot.readFieldBegin()
11365 
      if ftype == TType.STOP:
11366 
        break
11367 
      if fid == 1:
11368 
        if ftype == TType.STRING:
11369 
          self.bannerName = iprot.readString();
11370 
        else:
11371 
          iprot.skip(ftype)
11372 
      else:
11373 
        iprot.skip(ftype)
11374 
      iprot.readFieldEnd()
11375 
    iprot.readStructEnd()
11376 
 
11377 
  def write(self, oprot):
11378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11380 
      return
11381 
    oprot.writeStructBegin('getBannerMapDetails_args')
11382 
    if self.bannerName is not None:
11383 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11384 
      oprot.writeString(self.bannerName)
11385 
      oprot.writeFieldEnd()
11386 
    oprot.writeFieldStop()
11387 
    oprot.writeStructEnd()
11388 
 
11389 
  def validate(self):
11390 
    return
11391 
 
11392 
 
11393 
  def __repr__(self):
11394 
    L = ['%s=%r' % (key, value)
11395 
      for key, value in self.__dict__.iteritems()]
11396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11397 
 
11398 
  def __eq__(self, other):
11399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11400 
 
11401 
  def __ne__(self, other):
11402 
    return not (self == other)
11403 
 
11404 
class getBannerMapDetails_result:
11405 
  """
11406 
  Attributes:
11407 
   - success
11408 
  """
11409 
 
11410 
  thrift_spec = (
11411 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11412 
  )
11413 
 
11414 
  def __init__(self, success=None,):
11415 
    self.success = success
11416 
 
11417 
  def read(self, iprot):
11418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11420 
      return
11421 
    iprot.readStructBegin()
11422 
    while True:
11423 
      (fname, ftype, fid) = iprot.readFieldBegin()
11424 
      if ftype == TType.STOP:
11425 
        break
11426 
      if fid == 0:
11427 
        if ftype == TType.LIST:
11428 
          self.success = []
6850 kshitij.so 11429 
          (_etype182, _size179) = iprot.readListBegin()
11430 
          for _i183 in xrange(_size179):
11431 
            _elem184 = BannerMap()
11432 
            _elem184.read(iprot)
11433 
            self.success.append(_elem184)
6849 kshitij.so 11434 
          iprot.readListEnd()
11435 
        else:
11436 
          iprot.skip(ftype)
11437 
      else:
11438 
        iprot.skip(ftype)
11439 
      iprot.readFieldEnd()
11440 
    iprot.readStructEnd()
11441 
 
11442 
  def write(self, oprot):
11443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11445 
      return
11446 
    oprot.writeStructBegin('getBannerMapDetails_result')
11447 
    if self.success is not None:
11448 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11449 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11450 
      for iter185 in self.success:
11451 
        iter185.write(oprot)
6849 kshitij.so 11452 
      oprot.writeListEnd()
11453 
      oprot.writeFieldEnd()
11454 
    oprot.writeFieldStop()
11455 
    oprot.writeStructEnd()
11456 
 
11457 
  def validate(self):
11458 
    return
11459 
 
11460 
 
11461 
  def __repr__(self):
11462 
    L = ['%s=%r' % (key, value)
11463 
      for key, value in self.__dict__.iteritems()]
11464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11465 
 
11466 
  def __eq__(self, other):
11467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11468 
 
11469 
  def __ne__(self, other):
11470 
    return not (self == other)
11471 
 
5944 mandeep.dh 11472 
class deleteSimilarItem_args:
11473 
  """
11474 
  Attributes:
11475 
   - itemId
11476 
   - catalogItemId
11477 
  """
11478 
 
11479 
  thrift_spec = (
11480 
    None, # 0
11481 
    (1, TType.I64, 'itemId', None, None, ), # 1
11482 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11483 
  )
11484 
 
11485 
  def __init__(self, itemId=None, catalogItemId=None,):
11486 
    self.itemId = itemId
11487 
    self.catalogItemId = catalogItemId
11488 
 
11489 
  def read(self, iprot):
11490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11492 
      return
11493 
    iprot.readStructBegin()
11494 
    while True:
11495 
      (fname, ftype, fid) = iprot.readFieldBegin()
11496 
      if ftype == TType.STOP:
11497 
        break
11498 
      if fid == 1:
11499 
        if ftype == TType.I64:
11500 
          self.itemId = iprot.readI64();
11501 
        else:
11502 
          iprot.skip(ftype)
11503 
      elif fid == 2:
11504 
        if ftype == TType.I64:
11505 
          self.catalogItemId = iprot.readI64();
11506 
        else:
11507 
          iprot.skip(ftype)
11508 
      else:
11509 
        iprot.skip(ftype)
11510 
      iprot.readFieldEnd()
11511 
    iprot.readStructEnd()
11512 
 
11513 
  def write(self, oprot):
11514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11516 
      return
11517 
    oprot.writeStructBegin('deleteSimilarItem_args')
11518 
    if self.itemId is not None:
11519 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11520 
      oprot.writeI64(self.itemId)
11521 
      oprot.writeFieldEnd()
11522 
    if self.catalogItemId is not None:
11523 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11524 
      oprot.writeI64(self.catalogItemId)
11525 
      oprot.writeFieldEnd()
11526 
    oprot.writeFieldStop()
11527 
    oprot.writeStructEnd()
11528 
 
11529 
  def validate(self):
11530 
    return
11531 
 
11532 
 
11533 
  def __repr__(self):
11534 
    L = ['%s=%r' % (key, value)
11535 
      for key, value in self.__dict__.iteritems()]
11536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11537 
 
11538 
  def __eq__(self, other):
11539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11540 
 
11541 
  def __ne__(self, other):
11542 
    return not (self == other)
11543 
 
11544 
class deleteSimilarItem_result:
11545 
  """
11546 
  Attributes:
11547 
   - success
11548 
   - cex
11549 
  """
11550 
 
11551 
  thrift_spec = (
11552 
    (0, TType.BOOL, 'success', None, None, ), # 0
11553 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11554 
  )
11555 
 
11556 
  def __init__(self, success=None, cex=None,):
11557 
    self.success = success
11558 
    self.cex = cex
11559 
 
11560 
  def read(self, iprot):
11561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11563 
      return
11564 
    iprot.readStructBegin()
11565 
    while True:
11566 
      (fname, ftype, fid) = iprot.readFieldBegin()
11567 
      if ftype == TType.STOP:
11568 
        break
11569 
      if fid == 0:
11570 
        if ftype == TType.BOOL:
11571 
          self.success = iprot.readBool();
11572 
        else:
11573 
          iprot.skip(ftype)
11574 
      elif fid == 1:
11575 
        if ftype == TType.STRUCT:
11576 
          self.cex = CatalogServiceException()
11577 
          self.cex.read(iprot)
11578 
        else:
11579 
          iprot.skip(ftype)
11580 
      else:
11581 
        iprot.skip(ftype)
11582 
      iprot.readFieldEnd()
11583 
    iprot.readStructEnd()
11584 
 
11585 
  def write(self, oprot):
11586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11588 
      return
11589 
    oprot.writeStructBegin('deleteSimilarItem_result')
11590 
    if self.success is not None:
11591 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11592 
      oprot.writeBool(self.success)
11593 
      oprot.writeFieldEnd()
11594 
    if self.cex is not None:
11595 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11596 
      self.cex.write(oprot)
11597 
      oprot.writeFieldEnd()
11598 
    oprot.writeFieldStop()
11599 
    oprot.writeStructEnd()
11600 
 
11601 
  def validate(self):
11602 
    return
11603 
 
11604 
 
11605 
  def __repr__(self):
11606 
    L = ['%s=%r' % (key, value)
11607 
      for key, value in self.__dict__.iteritems()]
11608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11609 
 
11610 
  def __eq__(self, other):
11611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11612 
 
11613 
  def __ne__(self, other):
11614 
    return not (self == other)
11615 
 
11616 
class checkSimilarItem_args:
11617 
  """
11618 
  Attributes:
11619 
   - brand
11620 
   - modelNumber
11621 
   - modelName
11622 
   - color
11623 
  """
11624 
 
11625 
  thrift_spec = (
11626 
    None, # 0
11627 
    (1, TType.STRING, 'brand', None, None, ), # 1
11628 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11629 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11630 
    (4, TType.STRING, 'color', None, None, ), # 4
11631 
  )
11632 
 
11633 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11634 
    self.brand = brand
11635 
    self.modelNumber = modelNumber
11636 
    self.modelName = modelName
11637 
    self.color = color
11638 
 
11639 
  def read(self, iprot):
11640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11642 
      return
11643 
    iprot.readStructBegin()
11644 
    while True:
11645 
      (fname, ftype, fid) = iprot.readFieldBegin()
11646 
      if ftype == TType.STOP:
11647 
        break
11648 
      if fid == 1:
11649 
        if ftype == TType.STRING:
11650 
          self.brand = iprot.readString();
11651 
        else:
11652 
          iprot.skip(ftype)
11653 
      elif fid == 2:
11654 
        if ftype == TType.STRING:
11655 
          self.modelNumber = iprot.readString();
11656 
        else:
11657 
          iprot.skip(ftype)
11658 
      elif fid == 3:
11659 
        if ftype == TType.STRING:
11660 
          self.modelName = iprot.readString();
11661 
        else:
11662 
          iprot.skip(ftype)
11663 
      elif fid == 4:
11664 
        if ftype == TType.STRING:
11665 
          self.color = iprot.readString();
11666 
        else:
11667 
          iprot.skip(ftype)
11668 
      else:
11669 
        iprot.skip(ftype)
11670 
      iprot.readFieldEnd()
11671 
    iprot.readStructEnd()
11672 
 
11673 
  def write(self, oprot):
11674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11676 
      return
11677 
    oprot.writeStructBegin('checkSimilarItem_args')
11678 
    if self.brand is not None:
11679 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11680 
      oprot.writeString(self.brand)
11681 
      oprot.writeFieldEnd()
11682 
    if self.modelNumber is not None:
11683 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11684 
      oprot.writeString(self.modelNumber)
11685 
      oprot.writeFieldEnd()
11686 
    if self.modelName is not None:
11687 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11688 
      oprot.writeString(self.modelName)
11689 
      oprot.writeFieldEnd()
11690 
    if self.color is not None:
11691 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11692 
      oprot.writeString(self.color)
11693 
      oprot.writeFieldEnd()
11694 
    oprot.writeFieldStop()
11695 
    oprot.writeStructEnd()
11696 
 
11697 
  def validate(self):
11698 
    return
11699 
 
11700 
 
11701 
  def __repr__(self):
11702 
    L = ['%s=%r' % (key, value)
11703 
      for key, value in self.__dict__.iteritems()]
11704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11705 
 
11706 
  def __eq__(self, other):
11707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11708 
 
11709 
  def __ne__(self, other):
11710 
    return not (self == other)
11711 
 
11712 
class checkSimilarItem_result:
11713 
  """
11714 
  Attributes:
11715 
   - success
11716 
  """
11717 
 
11718 
  thrift_spec = (
11719 
    (0, TType.I64, 'success', None, None, ), # 0
11720 
  )
11721 
 
11722 
  def __init__(self, success=None,):
11723 
    self.success = success
11724 
 
11725 
  def read(self, iprot):
11726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11728 
      return
11729 
    iprot.readStructBegin()
11730 
    while True:
11731 
      (fname, ftype, fid) = iprot.readFieldBegin()
11732 
      if ftype == TType.STOP:
11733 
        break
11734 
      if fid == 0:
11735 
        if ftype == TType.I64:
11736 
          self.success = iprot.readI64();
11737 
        else:
11738 
          iprot.skip(ftype)
11739 
      else:
11740 
        iprot.skip(ftype)
11741 
      iprot.readFieldEnd()
11742 
    iprot.readStructEnd()
11743 
 
11744 
  def write(self, oprot):
11745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11747 
      return
11748 
    oprot.writeStructBegin('checkSimilarItem_result')
11749 
    if self.success is not None:
11750 
      oprot.writeFieldBegin('success', TType.I64, 0)
11751 
      oprot.writeI64(self.success)
11752 
      oprot.writeFieldEnd()
11753 
    oprot.writeFieldStop()
11754 
    oprot.writeStructEnd()
11755 
 
11756 
  def validate(self):
11757 
    return
11758 
 
11759 
 
11760 
  def __repr__(self):
11761 
    L = ['%s=%r' % (key, value)
11762 
      for key, value in self.__dict__.iteritems()]
11763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11764 
 
11765 
  def __eq__(self, other):
11766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11767 
 
11768 
  def __ne__(self, other):
11769 
    return not (self == other)
11770 
 
11771 
class validateRiskyStatus_args:
11772 
  """
11773 
  Attributes:
11774 
   - itemId
11775 
  """
11776 
 
11777 
  thrift_spec = (
11778 
    None, # 0
11779 
    (1, TType.I64, 'itemId', None, None, ), # 1
11780 
  )
11781 
 
11782 
  def __init__(self, itemId=None,):
11783 
    self.itemId = itemId
11784 
 
11785 
  def read(self, iprot):
11786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11788 
      return
11789 
    iprot.readStructBegin()
11790 
    while True:
11791 
      (fname, ftype, fid) = iprot.readFieldBegin()
11792 
      if ftype == TType.STOP:
11793 
        break
11794 
      if fid == 1:
11795 
        if ftype == TType.I64:
11796 
          self.itemId = iprot.readI64();
11797 
        else:
11798 
          iprot.skip(ftype)
11799 
      else:
11800 
        iprot.skip(ftype)
11801 
      iprot.readFieldEnd()
11802 
    iprot.readStructEnd()
11803 
 
11804 
  def write(self, oprot):
11805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11807 
      return
11808 
    oprot.writeStructBegin('validateRiskyStatus_args')
11809 
    if self.itemId is not None:
11810 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11811 
      oprot.writeI64(self.itemId)
11812 
      oprot.writeFieldEnd()
11813 
    oprot.writeFieldStop()
11814 
    oprot.writeStructEnd()
11815 
 
11816 
  def validate(self):
11817 
    return
11818 
 
11819 
 
11820 
  def __repr__(self):
11821 
    L = ['%s=%r' % (key, value)
11822 
      for key, value in self.__dict__.iteritems()]
11823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11824 
 
11825 
  def __eq__(self, other):
11826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11827 
 
11828 
  def __ne__(self, other):
11829 
    return not (self == other)
11830 
 
11831 
class validateRiskyStatus_result:
11832 
 
11833 
  thrift_spec = (
11834 
  )
11835 
 
11836 
  def read(self, iprot):
11837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11839 
      return
11840 
    iprot.readStructBegin()
11841 
    while True:
11842 
      (fname, ftype, fid) = iprot.readFieldBegin()
11843 
      if ftype == TType.STOP:
11844 
        break
11845 
      else:
11846 
        iprot.skip(ftype)
11847 
      iprot.readFieldEnd()
11848 
    iprot.readStructEnd()
11849 
 
11850 
  def write(self, oprot):
11851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11853 
      return
11854 
    oprot.writeStructBegin('validateRiskyStatus_result')
11855 
    oprot.writeFieldStop()
11856 
    oprot.writeStructEnd()
11857 
 
11858 
  def validate(self):
11859 
    return
11860 
 
11861 
 
11862 
  def __repr__(self):
11863 
    L = ['%s=%r' % (key, value)
11864 
      for key, value in self.__dict__.iteritems()]
11865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11866 
 
11867 
  def __eq__(self, other):
11868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11869 
 
11870 
  def __ne__(self, other):
11871 
    return not (self == other)
11872 
 
11873 
class changeItemRiskyFlag_args:
11874 
  """
11875 
  Attributes:
11876 
   - itemId
11877 
   - risky
11878 
  """
11879 
 
11880 
  thrift_spec = (
11881 
    None, # 0
11882 
    (1, TType.I64, 'itemId', None, None, ), # 1
11883 
    (2, TType.BOOL, 'risky', None, None, ), # 2
11884 
  )
11885 
 
11886 
  def __init__(self, itemId=None, risky=None,):
11887 
    self.itemId = itemId
11888 
    self.risky = risky
11889 
 
11890 
  def read(self, iprot):
11891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11893 
      return
11894 
    iprot.readStructBegin()
11895 
    while True:
11896 
      (fname, ftype, fid) = iprot.readFieldBegin()
11897 
      if ftype == TType.STOP:
11898 
        break
11899 
      if fid == 1:
11900 
        if ftype == TType.I64:
11901 
          self.itemId = iprot.readI64();
11902 
        else:
11903 
          iprot.skip(ftype)
11904 
      elif fid == 2:
11905 
        if ftype == TType.BOOL:
11906 
          self.risky = iprot.readBool();
11907 
        else:
11908 
          iprot.skip(ftype)
11909 
      else:
11910 
        iprot.skip(ftype)
11911 
      iprot.readFieldEnd()
11912 
    iprot.readStructEnd()
11913 
 
11914 
  def write(self, oprot):
11915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11917 
      return
11918 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
11919 
    if self.itemId is not None:
11920 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11921 
      oprot.writeI64(self.itemId)
11922 
      oprot.writeFieldEnd()
11923 
    if self.risky is not None:
11924 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
11925 
      oprot.writeBool(self.risky)
11926 
      oprot.writeFieldEnd()
11927 
    oprot.writeFieldStop()
11928 
    oprot.writeStructEnd()
11929 
 
11930 
  def validate(self):
11931 
    return
11932 
 
11933 
 
11934 
  def __repr__(self):
11935 
    L = ['%s=%r' % (key, value)
11936 
      for key, value in self.__dict__.iteritems()]
11937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11938 
 
11939 
  def __eq__(self, other):
11940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11941 
 
11942 
  def __ne__(self, other):
11943 
    return not (self == other)
11944 
 
11945 
class changeItemRiskyFlag_result:
11946 
 
11947 
  thrift_spec = (
11948 
  )
11949 
 
11950 
  def read(self, iprot):
11951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11953 
      return
11954 
    iprot.readStructBegin()
11955 
    while True:
11956 
      (fname, ftype, fid) = iprot.readFieldBegin()
11957 
      if ftype == TType.STOP:
11958 
        break
11959 
      else:
11960 
        iprot.skip(ftype)
11961 
      iprot.readFieldEnd()
11962 
    iprot.readStructEnd()
11963 
 
11964 
  def write(self, oprot):
11965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11967 
      return
11968 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
11969 
    oprot.writeFieldStop()
11970 
    oprot.writeStructEnd()
11971 
 
11972 
  def validate(self):
11973 
    return
11974 
 
11975 
 
11976 
  def __repr__(self):
11977 
    L = ['%s=%r' % (key, value)
11978 
      for key, value in self.__dict__.iteritems()]
11979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11980 
 
11981 
  def __eq__(self, other):
11982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11983 
 
11984 
  def __ne__(self, other):
11985 
    return not (self == other)
11986 
 
11987 
class getItemsByRiskyFlag_args:
11988 
 
11989 
  thrift_spec = (
11990 
  )
11991 
 
11992 
  def read(self, iprot):
11993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11995 
      return
11996 
    iprot.readStructBegin()
11997 
    while True:
11998 
      (fname, ftype, fid) = iprot.readFieldBegin()
11999 
      if ftype == TType.STOP:
12000 
        break
12001 
      else:
12002 
        iprot.skip(ftype)
12003 
      iprot.readFieldEnd()
12004 
    iprot.readStructEnd()
12005 
 
12006 
  def write(self, oprot):
12007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12009 
      return
12010 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12011 
    oprot.writeFieldStop()
12012 
    oprot.writeStructEnd()
12013 
 
12014 
  def validate(self):
12015 
    return
12016 
 
12017 
 
12018 
  def __repr__(self):
12019 
    L = ['%s=%r' % (key, value)
12020 
      for key, value in self.__dict__.iteritems()]
12021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12022 
 
12023 
  def __eq__(self, other):
12024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12025 
 
12026 
  def __ne__(self, other):
12027 
    return not (self == other)
12028 
 
12029 
class getItemsByRiskyFlag_result:
12030 
  """
12031 
  Attributes:
12032 
   - success
12033 
  """
12034 
 
12035 
  thrift_spec = (
12036 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12037 
  )
12038 
 
12039 
  def __init__(self, success=None,):
12040 
    self.success = success
12041 
 
12042 
  def read(self, iprot):
12043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12045 
      return
12046 
    iprot.readStructBegin()
12047 
    while True:
12048 
      (fname, ftype, fid) = iprot.readFieldBegin()
12049 
      if ftype == TType.STOP:
12050 
        break
12051 
      if fid == 0:
12052 
        if ftype == TType.LIST:
12053 
          self.success = []
6850 kshitij.so 12054 
          (_etype189, _size186) = iprot.readListBegin()
12055 
          for _i190 in xrange(_size186):
12056 
            _elem191 = Item()
12057 
            _elem191.read(iprot)
12058 
            self.success.append(_elem191)
5944 mandeep.dh 12059 
          iprot.readListEnd()
12060 
        else:
12061 
          iprot.skip(ftype)
12062 
      else:
12063 
        iprot.skip(ftype)
12064 
      iprot.readFieldEnd()
12065 
    iprot.readStructEnd()
12066 
 
12067 
  def write(self, oprot):
12068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12070 
      return
12071 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12072 
    if self.success is not None:
12073 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12074 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12075 
      for iter192 in self.success:
12076 
        iter192.write(oprot)
5944 mandeep.dh 12077 
      oprot.writeListEnd()
12078 
      oprot.writeFieldEnd()
12079 
    oprot.writeFieldStop()
12080 
    oprot.writeStructEnd()
12081 
 
12082 
  def validate(self):
12083 
    return
12084 
 
12085 
 
12086 
  def __repr__(self):
12087 
    L = ['%s=%r' % (key, value)
12088 
      for key, value in self.__dict__.iteritems()]
12089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12090 
 
12091 
  def __eq__(self, other):
12092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12093 
 
12094 
  def __ne__(self, other):
12095 
    return not (self == other)
12096 
 
12097 
class getItemsForMasterSheet_args:
12098 
  """
12099 
  Attributes:
12100 
   - category
12101 
   - brand
12102 
  """
12103 
 
12104 
  thrift_spec = (
12105 
    None, # 0
12106 
    (1, TType.STRING, 'category', None, None, ), # 1
12107 
    (2, TType.STRING, 'brand', None, None, ), # 2
12108 
  )
12109 
 
12110 
  def __init__(self, category=None, brand=None,):
12111 
    self.category = category
12112 
    self.brand = brand
12113 
 
12114 
  def read(self, iprot):
12115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12117 
      return
12118 
    iprot.readStructBegin()
12119 
    while True:
12120 
      (fname, ftype, fid) = iprot.readFieldBegin()
12121 
      if ftype == TType.STOP:
12122 
        break
12123 
      if fid == 1:
12124 
        if ftype == TType.STRING:
12125 
          self.category = iprot.readString();
12126 
        else:
12127 
          iprot.skip(ftype)
12128 
      elif fid == 2:
12129 
        if ftype == TType.STRING:
12130 
          self.brand = iprot.readString();
12131 
        else:
12132 
          iprot.skip(ftype)
12133 
      else:
12134 
        iprot.skip(ftype)
12135 
      iprot.readFieldEnd()
12136 
    iprot.readStructEnd()
12137 
 
12138 
  def write(self, oprot):
12139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12141 
      return
12142 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12143 
    if self.category is not None:
12144 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12145 
      oprot.writeString(self.category)
12146 
      oprot.writeFieldEnd()
12147 
    if self.brand is not None:
12148 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12149 
      oprot.writeString(self.brand)
12150 
      oprot.writeFieldEnd()
12151 
    oprot.writeFieldStop()
12152 
    oprot.writeStructEnd()
12153 
 
12154 
  def validate(self):
12155 
    return
12156 
 
12157 
 
12158 
  def __repr__(self):
12159 
    L = ['%s=%r' % (key, value)
12160 
      for key, value in self.__dict__.iteritems()]
12161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12162 
 
12163 
  def __eq__(self, other):
12164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12165 
 
12166 
  def __ne__(self, other):
12167 
    return not (self == other)
12168 
 
12169 
class getItemsForMasterSheet_result:
12170 
  """
12171 
  Attributes:
12172 
   - success
12173 
  """
12174 
 
12175 
  thrift_spec = (
12176 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12177 
  )
12178 
 
12179 
  def __init__(self, success=None,):
12180 
    self.success = success
12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 0:
12192 
        if ftype == TType.LIST:
12193 
          self.success = []
6850 kshitij.so 12194 
          (_etype196, _size193) = iprot.readListBegin()
12195 
          for _i197 in xrange(_size193):
12196 
            _elem198 = Item()
12197 
            _elem198.read(iprot)
12198 
            self.success.append(_elem198)
5944 mandeep.dh 12199 
          iprot.readListEnd()
12200 
        else:
12201 
          iprot.skip(ftype)
12202 
      else:
12203 
        iprot.skip(ftype)
12204 
      iprot.readFieldEnd()
12205 
    iprot.readStructEnd()
12206 
 
12207 
  def write(self, oprot):
12208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12210 
      return
12211 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12212 
    if self.success is not None:
12213 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12214 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12215 
      for iter199 in self.success:
12216 
        iter199.write(oprot)
5944 mandeep.dh 12217 
      oprot.writeListEnd()
12218 
      oprot.writeFieldEnd()
12219 
    oprot.writeFieldStop()
12220 
    oprot.writeStructEnd()
12221 
 
12222 
  def validate(self):
12223 
    return
12224 
 
12225 
 
12226 
  def __repr__(self):
12227 
    L = ['%s=%r' % (key, value)
12228 
      for key, value in self.__dict__.iteritems()]
12229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12230 
 
12231 
  def __eq__(self, other):
12232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12233 
 
12234 
  def __ne__(self, other):
12235 
    return not (self == other)
12236 
 
12237 
class getSimilarItemsCatalogIds_args:
12238 
  """
12239 
  Attributes:
12240 
   - beginIndex
12241 
   - totalItems
12242 
   - itemId
12243 
  """
12244 
 
12245 
  thrift_spec = (
12246 
    None, # 0
12247 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12248 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12249 
    (3, TType.I64, 'itemId', None, None, ), # 3
12250 
  )
12251 
 
12252 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12253 
    self.beginIndex = beginIndex
12254 
    self.totalItems = totalItems
12255 
    self.itemId = itemId
12256 
 
12257 
  def read(self, iprot):
12258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12260 
      return
12261 
    iprot.readStructBegin()
12262 
    while True:
12263 
      (fname, ftype, fid) = iprot.readFieldBegin()
12264 
      if ftype == TType.STOP:
12265 
        break
12266 
      if fid == 1:
12267 
        if ftype == TType.I64:
12268 
          self.beginIndex = iprot.readI64();
12269 
        else:
12270 
          iprot.skip(ftype)
12271 
      elif fid == 2:
12272 
        if ftype == TType.I64:
12273 
          self.totalItems = iprot.readI64();
12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      elif fid == 3:
12277 
        if ftype == TType.I64:
12278 
          self.itemId = iprot.readI64();
12279 
        else:
12280 
          iprot.skip(ftype)
12281 
      else:
12282 
        iprot.skip(ftype)
12283 
      iprot.readFieldEnd()
12284 
    iprot.readStructEnd()
12285 
 
12286 
  def write(self, oprot):
12287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12289 
      return
12290 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12291 
    if self.beginIndex is not None:
12292 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12293 
      oprot.writeI64(self.beginIndex)
12294 
      oprot.writeFieldEnd()
12295 
    if self.totalItems is not None:
12296 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12297 
      oprot.writeI64(self.totalItems)
12298 
      oprot.writeFieldEnd()
12299 
    if self.itemId is not None:
12300 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12301 
      oprot.writeI64(self.itemId)
12302 
      oprot.writeFieldEnd()
12303 
    oprot.writeFieldStop()
12304 
    oprot.writeStructEnd()
12305 
 
12306 
  def validate(self):
12307 
    return
12308 
 
12309 
 
12310 
  def __repr__(self):
12311 
    L = ['%s=%r' % (key, value)
12312 
      for key, value in self.__dict__.iteritems()]
12313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12314 
 
12315 
  def __eq__(self, other):
12316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12317 
 
12318 
  def __ne__(self, other):
12319 
    return not (self == other)
12320 
 
12321 
class getSimilarItemsCatalogIds_result:
12322 
  """
12323 
  Attributes:
12324 
   - success
12325 
  """
12326 
 
12327 
  thrift_spec = (
12328 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12329 
  )
12330 
 
12331 
  def __init__(self, success=None,):
12332 
    self.success = success
12333 
 
12334 
  def read(self, iprot):
12335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12337 
      return
12338 
    iprot.readStructBegin()
12339 
    while True:
12340 
      (fname, ftype, fid) = iprot.readFieldBegin()
12341 
      if ftype == TType.STOP:
12342 
        break
12343 
      if fid == 0:
12344 
        if ftype == TType.LIST:
12345 
          self.success = []
6850 kshitij.so 12346 
          (_etype203, _size200) = iprot.readListBegin()
12347 
          for _i204 in xrange(_size200):
12348 
            _elem205 = iprot.readI64();
12349 
            self.success.append(_elem205)
5944 mandeep.dh 12350 
          iprot.readListEnd()
12351 
        else:
12352 
          iprot.skip(ftype)
12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
12362 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12363 
    if self.success is not None:
12364 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12365 
      oprot.writeListBegin(TType.I64, len(self.success))
6850 kshitij.so 12366 
      for iter206 in self.success:
12367 
        oprot.writeI64(iter206)
5944 mandeep.dh 12368 
      oprot.writeListEnd()
12369 
      oprot.writeFieldEnd()
12370 
    oprot.writeFieldStop()
12371 
    oprot.writeStructEnd()
12372 
 
12373 
  def validate(self):
12374 
    return
12375 
 
12376 
 
12377 
  def __repr__(self):
12378 
    L = ['%s=%r' % (key, value)
12379 
      for key, value in self.__dict__.iteritems()]
12380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12381 
 
12382 
  def __eq__(self, other):
12383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12384 
 
12385 
  def __ne__(self, other):
12386 
    return not (self == other)
12387 
 
12388 
class addProductNotification_args:
12389 
  """
12390 
  Attributes:
12391 
   - itemId
12392 
   - email
12393 
  """
12394 
 
12395 
  thrift_spec = None
12396 
  def __init__(self, itemId=None, email=None,):
12397 
    self.itemId = itemId
12398 
    self.email = email
12399 
 
12400 
  def read(self, iprot):
12401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12403 
      return
12404 
    iprot.readStructBegin()
12405 
    while True:
12406 
      (fname, ftype, fid) = iprot.readFieldBegin()
12407 
      if ftype == TType.STOP:
12408 
        break
12409 
      if fid == -1:
12410 
        if ftype == TType.I64:
12411 
          self.itemId = iprot.readI64();
12412 
        else:
12413 
          iprot.skip(ftype)
12414 
      elif fid == -2:
12415 
        if ftype == TType.STRING:
12416 
          self.email = iprot.readString();
12417 
        else:
12418 
          iprot.skip(ftype)
12419 
      else:
12420 
        iprot.skip(ftype)
12421 
      iprot.readFieldEnd()
12422 
    iprot.readStructEnd()
12423 
 
12424 
  def write(self, oprot):
12425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12427 
      return
12428 
    oprot.writeStructBegin('addProductNotification_args')
12429 
    if self.email is not None:
12430 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12431 
      oprot.writeString(self.email)
12432 
      oprot.writeFieldEnd()
12433 
    if self.itemId is not None:
12434 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12435 
      oprot.writeI64(self.itemId)
12436 
      oprot.writeFieldEnd()
12437 
    oprot.writeFieldStop()
12438 
    oprot.writeStructEnd()
12439 
 
12440 
  def validate(self):
12441 
    return
12442 
 
12443 
 
12444 
  def __repr__(self):
12445 
    L = ['%s=%r' % (key, value)
12446 
      for key, value in self.__dict__.iteritems()]
12447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12448 
 
12449 
  def __eq__(self, other):
12450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12451 
 
12452 
  def __ne__(self, other):
12453 
    return not (self == other)
12454 
 
12455 
class addProductNotification_result:
12456 
  """
12457 
  Attributes:
12458 
   - success
12459 
  """
12460 
 
12461 
  thrift_spec = (
12462 
    (0, TType.BOOL, 'success', None, None, ), # 0
12463 
  )
12464 
 
12465 
  def __init__(self, success=None,):
12466 
    self.success = success
12467 
 
12468 
  def read(self, iprot):
12469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12471 
      return
12472 
    iprot.readStructBegin()
12473 
    while True:
12474 
      (fname, ftype, fid) = iprot.readFieldBegin()
12475 
      if ftype == TType.STOP:
12476 
        break
12477 
      if fid == 0:
12478 
        if ftype == TType.BOOL:
12479 
          self.success = iprot.readBool();
12480 
        else:
12481 
          iprot.skip(ftype)
12482 
      else:
12483 
        iprot.skip(ftype)
12484 
      iprot.readFieldEnd()
12485 
    iprot.readStructEnd()
12486 
 
12487 
  def write(self, oprot):
12488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12490 
      return
12491 
    oprot.writeStructBegin('addProductNotification_result')
12492 
    if self.success is not None:
12493 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12494 
      oprot.writeBool(self.success)
12495 
      oprot.writeFieldEnd()
12496 
    oprot.writeFieldStop()
12497 
    oprot.writeStructEnd()
12498 
 
12499 
  def validate(self):
12500 
    return
12501 
 
12502 
 
12503 
  def __repr__(self):
12504 
    L = ['%s=%r' % (key, value)
12505 
      for key, value in self.__dict__.iteritems()]
12506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12507 
 
12508 
  def __eq__(self, other):
12509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12510 
 
12511 
  def __ne__(self, other):
12512 
    return not (self == other)
12513 
 
12514 
class sendProductNotifications_args:
12515 
 
12516 
  thrift_spec = (
12517 
  )
12518 
 
12519 
  def read(self, iprot):
12520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12522 
      return
12523 
    iprot.readStructBegin()
12524 
    while True:
12525 
      (fname, ftype, fid) = iprot.readFieldBegin()
12526 
      if ftype == TType.STOP:
12527 
        break
12528 
      else:
12529 
        iprot.skip(ftype)
12530 
      iprot.readFieldEnd()
12531 
    iprot.readStructEnd()
12532 
 
12533 
  def write(self, oprot):
12534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12536 
      return
12537 
    oprot.writeStructBegin('sendProductNotifications_args')
12538 
    oprot.writeFieldStop()
12539 
    oprot.writeStructEnd()
12540 
 
12541 
  def validate(self):
12542 
    return
12543 
 
12544 
 
12545 
  def __repr__(self):
12546 
    L = ['%s=%r' % (key, value)
12547 
      for key, value in self.__dict__.iteritems()]
12548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12549 
 
12550 
  def __eq__(self, other):
12551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12552 
 
12553 
  def __ne__(self, other):
12554 
    return not (self == other)
12555 
 
12556 
class sendProductNotifications_result:
12557 
  """
12558 
  Attributes:
12559 
   - success
12560 
  """
12561 
 
12562 
  thrift_spec = (
12563 
    (0, TType.BOOL, 'success', None, None, ), # 0
12564 
  )
12565 
 
12566 
  def __init__(self, success=None,):
12567 
    self.success = success
12568 
 
12569 
  def read(self, iprot):
12570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12572 
      return
12573 
    iprot.readStructBegin()
12574 
    while True:
12575 
      (fname, ftype, fid) = iprot.readFieldBegin()
12576 
      if ftype == TType.STOP:
12577 
        break
12578 
      if fid == 0:
12579 
        if ftype == TType.BOOL:
12580 
          self.success = iprot.readBool();
12581 
        else:
12582 
          iprot.skip(ftype)
12583 
      else:
12584 
        iprot.skip(ftype)
12585 
      iprot.readFieldEnd()
12586 
    iprot.readStructEnd()
12587 
 
12588 
  def write(self, oprot):
12589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12591 
      return
12592 
    oprot.writeStructBegin('sendProductNotifications_result')
12593 
    if self.success is not None:
12594 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12595 
      oprot.writeBool(self.success)
12596 
      oprot.writeFieldEnd()
12597 
    oprot.writeFieldStop()
12598 
    oprot.writeStructEnd()
12599 
 
12600 
  def validate(self):
12601 
    return
12602 
 
12603 
 
12604 
  def __repr__(self):
12605 
    L = ['%s=%r' % (key, value)
12606 
      for key, value in self.__dict__.iteritems()]
12607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12608 
 
12609 
  def __eq__(self, other):
12610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12611 
 
12612 
  def __ne__(self, other):
12613 
    return not (self == other)
12614 
 
12615 
class getAllBrandsByCategory_args:
12616 
  """
12617 
  Attributes:
12618 
   - categoryId
12619 
  """
12620 
 
12621 
  thrift_spec = (
12622 
    None, # 0
12623 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12624 
  )
12625 
 
12626 
  def __init__(self, categoryId=None,):
12627 
    self.categoryId = categoryId
12628 
 
12629 
  def read(self, iprot):
12630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12632 
      return
12633 
    iprot.readStructBegin()
12634 
    while True:
12635 
      (fname, ftype, fid) = iprot.readFieldBegin()
12636 
      if ftype == TType.STOP:
12637 
        break
12638 
      if fid == 1:
12639 
        if ftype == TType.I64:
12640 
          self.categoryId = iprot.readI64();
12641 
        else:
12642 
          iprot.skip(ftype)
12643 
      else:
12644 
        iprot.skip(ftype)
12645 
      iprot.readFieldEnd()
12646 
    iprot.readStructEnd()
12647 
 
12648 
  def write(self, oprot):
12649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12651 
      return
12652 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12653 
    if self.categoryId is not None:
12654 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12655 
      oprot.writeI64(self.categoryId)
12656 
      oprot.writeFieldEnd()
12657 
    oprot.writeFieldStop()
12658 
    oprot.writeStructEnd()
12659 
 
12660 
  def validate(self):
12661 
    return
12662 
 
12663 
 
12664 
  def __repr__(self):
12665 
    L = ['%s=%r' % (key, value)
12666 
      for key, value in self.__dict__.iteritems()]
12667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12668 
 
12669 
  def __eq__(self, other):
12670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12671 
 
12672 
  def __ne__(self, other):
12673 
    return not (self == other)
12674 
 
12675 
class getAllBrandsByCategory_result:
12676 
  """
12677 
  Attributes:
12678 
   - success
12679 
  """
12680 
 
12681 
  thrift_spec = (
12682 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12683 
  )
12684 
 
12685 
  def __init__(self, success=None,):
12686 
    self.success = success
12687 
 
12688 
  def read(self, iprot):
12689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12691 
      return
12692 
    iprot.readStructBegin()
12693 
    while True:
12694 
      (fname, ftype, fid) = iprot.readFieldBegin()
12695 
      if ftype == TType.STOP:
12696 
        break
12697 
      if fid == 0:
12698 
        if ftype == TType.LIST:
12699 
          self.success = []
6850 kshitij.so 12700 
          (_etype210, _size207) = iprot.readListBegin()
12701 
          for _i211 in xrange(_size207):
12702 
            _elem212 = iprot.readString();
12703 
            self.success.append(_elem212)
5944 mandeep.dh 12704 
          iprot.readListEnd()
12705 
        else:
12706 
          iprot.skip(ftype)
12707 
      else:
12708 
        iprot.skip(ftype)
12709 
      iprot.readFieldEnd()
12710 
    iprot.readStructEnd()
12711 
 
12712 
  def write(self, oprot):
12713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12715 
      return
12716 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12717 
    if self.success is not None:
12718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12719 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12720 
      for iter213 in self.success:
12721 
        oprot.writeString(iter213)
5944 mandeep.dh 12722 
      oprot.writeListEnd()
12723 
      oprot.writeFieldEnd()
12724 
    oprot.writeFieldStop()
12725 
    oprot.writeStructEnd()
12726 
 
12727 
  def validate(self):
12728 
    return
12729 
 
12730 
 
12731 
  def __repr__(self):
12732 
    L = ['%s=%r' % (key, value)
12733 
      for key, value in self.__dict__.iteritems()]
12734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12735 
 
12736 
  def __eq__(self, other):
12737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12738 
 
12739 
  def __ne__(self, other):
12740 
    return not (self == other)
12741 
 
12742 
class getAllBrands_args:
12743 
 
12744 
  thrift_spec = (
12745 
  )
12746 
 
12747 
  def read(self, iprot):
12748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12750 
      return
12751 
    iprot.readStructBegin()
12752 
    while True:
12753 
      (fname, ftype, fid) = iprot.readFieldBegin()
12754 
      if ftype == TType.STOP:
12755 
        break
12756 
      else:
12757 
        iprot.skip(ftype)
12758 
      iprot.readFieldEnd()
12759 
    iprot.readStructEnd()
12760 
 
12761 
  def write(self, oprot):
12762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12764 
      return
12765 
    oprot.writeStructBegin('getAllBrands_args')
12766 
    oprot.writeFieldStop()
12767 
    oprot.writeStructEnd()
12768 
 
12769 
  def validate(self):
12770 
    return
12771 
 
12772 
 
12773 
  def __repr__(self):
12774 
    L = ['%s=%r' % (key, value)
12775 
      for key, value in self.__dict__.iteritems()]
12776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12777 
 
12778 
  def __eq__(self, other):
12779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12780 
 
12781 
  def __ne__(self, other):
12782 
    return not (self == other)
12783 
 
12784 
class getAllBrands_result:
12785 
  """
12786 
  Attributes:
12787 
   - success
12788 
  """
12789 
 
12790 
  thrift_spec = (
12791 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12792 
  )
12793 
 
12794 
  def __init__(self, success=None,):
12795 
    self.success = success
12796 
 
12797 
  def read(self, iprot):
12798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12800 
      return
12801 
    iprot.readStructBegin()
12802 
    while True:
12803 
      (fname, ftype, fid) = iprot.readFieldBegin()
12804 
      if ftype == TType.STOP:
12805 
        break
12806 
      if fid == 0:
12807 
        if ftype == TType.LIST:
12808 
          self.success = []
6850 kshitij.so 12809 
          (_etype217, _size214) = iprot.readListBegin()
12810 
          for _i218 in xrange(_size214):
12811 
            _elem219 = iprot.readString();
12812 
            self.success.append(_elem219)
5944 mandeep.dh 12813 
          iprot.readListEnd()
12814 
        else:
12815 
          iprot.skip(ftype)
12816 
      else:
12817 
        iprot.skip(ftype)
12818 
      iprot.readFieldEnd()
12819 
    iprot.readStructEnd()
12820 
 
12821 
  def write(self, oprot):
12822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12824 
      return
12825 
    oprot.writeStructBegin('getAllBrands_result')
12826 
    if self.success is not None:
12827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12828 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12829 
      for iter220 in self.success:
12830 
        oprot.writeString(iter220)
5944 mandeep.dh 12831 
      oprot.writeListEnd()
12832 
      oprot.writeFieldEnd()
12833 
    oprot.writeFieldStop()
12834 
    oprot.writeStructEnd()
12835 
 
12836 
  def validate(self):
12837 
    return
12838 
 
12839 
 
12840 
  def __repr__(self):
12841 
    L = ['%s=%r' % (key, value)
12842 
      for key, value in self.__dict__.iteritems()]
12843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12844 
 
12845 
  def __eq__(self, other):
12846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12847 
 
12848 
  def __ne__(self, other):
12849 
    return not (self == other)
12850 
 
12851 
class getAllSources_args:
12852 
 
12853 
  thrift_spec = (
12854 
  )
12855 
 
12856 
  def read(self, iprot):
12857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12859 
      return
12860 
    iprot.readStructBegin()
12861 
    while True:
12862 
      (fname, ftype, fid) = iprot.readFieldBegin()
12863 
      if ftype == TType.STOP:
12864 
        break
12865 
      else:
12866 
        iprot.skip(ftype)
12867 
      iprot.readFieldEnd()
12868 
    iprot.readStructEnd()
12869 
 
12870 
  def write(self, oprot):
12871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12873 
      return
12874 
    oprot.writeStructBegin('getAllSources_args')
12875 
    oprot.writeFieldStop()
12876 
    oprot.writeStructEnd()
12877 
 
12878 
  def validate(self):
12879 
    return
12880 
 
12881 
 
12882 
  def __repr__(self):
12883 
    L = ['%s=%r' % (key, value)
12884 
      for key, value in self.__dict__.iteritems()]
12885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12886 
 
12887 
  def __eq__(self, other):
12888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12889 
 
12890 
  def __ne__(self, other):
12891 
    return not (self == other)
12892 
 
12893 
class getAllSources_result:
12894 
  """
12895 
  Attributes:
12896 
   - success
12897 
  """
12898 
 
12899 
  thrift_spec = (
12900 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
12901 
  )
12902 
 
12903 
  def __init__(self, success=None,):
12904 
    self.success = success
12905 
 
12906 
  def read(self, iprot):
12907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12909 
      return
12910 
    iprot.readStructBegin()
12911 
    while True:
12912 
      (fname, ftype, fid) = iprot.readFieldBegin()
12913 
      if ftype == TType.STOP:
12914 
        break
12915 
      if fid == 0:
12916 
        if ftype == TType.LIST:
12917 
          self.success = []
6850 kshitij.so 12918 
          (_etype224, _size221) = iprot.readListBegin()
12919 
          for _i225 in xrange(_size221):
12920 
            _elem226 = Source()
12921 
            _elem226.read(iprot)
12922 
            self.success.append(_elem226)
5944 mandeep.dh 12923 
          iprot.readListEnd()
12924 
        else:
12925 
          iprot.skip(ftype)
12926 
      else:
12927 
        iprot.skip(ftype)
12928 
      iprot.readFieldEnd()
12929 
    iprot.readStructEnd()
12930 
 
12931 
  def write(self, oprot):
12932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12934 
      return
12935 
    oprot.writeStructBegin('getAllSources_result')
12936 
    if self.success is not None:
12937 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12938 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12939 
      for iter227 in self.success:
12940 
        iter227.write(oprot)
5944 mandeep.dh 12941 
      oprot.writeListEnd()
12942 
      oprot.writeFieldEnd()
12943 
    oprot.writeFieldStop()
12944 
    oprot.writeStructEnd()
12945 
 
12946 
  def validate(self):
12947 
    return
12948 
 
12949 
 
12950 
  def __repr__(self):
12951 
    L = ['%s=%r' % (key, value)
12952 
      for key, value in self.__dict__.iteritems()]
12953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12954 
 
12955 
  def __eq__(self, other):
12956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12957 
 
12958 
  def __ne__(self, other):
12959 
    return not (self == other)
12960 
 
12961 
class getItemPricingBySource_args:
12962 
  """
12963 
  Attributes:
12964 
   - itemId
12965 
   - sourceId
12966 
  """
12967 
 
12968 
  thrift_spec = (
12969 
    None, # 0
12970 
    (1, TType.I64, 'itemId', None, None, ), # 1
12971 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12972 
  )
12973 
 
12974 
  def __init__(self, itemId=None, sourceId=None,):
12975 
    self.itemId = itemId
12976 
    self.sourceId = sourceId
12977 
 
12978 
  def read(self, iprot):
12979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12981 
      return
12982 
    iprot.readStructBegin()
12983 
    while True:
12984 
      (fname, ftype, fid) = iprot.readFieldBegin()
12985 
      if ftype == TType.STOP:
12986 
        break
12987 
      if fid == 1:
12988 
        if ftype == TType.I64:
12989 
          self.itemId = iprot.readI64();
12990 
        else:
12991 
          iprot.skip(ftype)
12992 
      elif fid == 2:
12993 
        if ftype == TType.I64:
12994 
          self.sourceId = iprot.readI64();
12995 
        else:
12996 
          iprot.skip(ftype)
12997 
      else:
12998 
        iprot.skip(ftype)
12999 
      iprot.readFieldEnd()
13000 
    iprot.readStructEnd()
13001 
 
13002 
  def write(self, oprot):
13003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13005 
      return
13006 
    oprot.writeStructBegin('getItemPricingBySource_args')
13007 
    if self.itemId is not None:
13008 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13009 
      oprot.writeI64(self.itemId)
13010 
      oprot.writeFieldEnd()
13011 
    if self.sourceId is not None:
13012 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13013 
      oprot.writeI64(self.sourceId)
13014 
      oprot.writeFieldEnd()
13015 
    oprot.writeFieldStop()
13016 
    oprot.writeStructEnd()
13017 
 
13018 
  def validate(self):
13019 
    return
13020 
 
13021 
 
13022 
  def __repr__(self):
13023 
    L = ['%s=%r' % (key, value)
13024 
      for key, value in self.__dict__.iteritems()]
13025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13026 
 
13027 
  def __eq__(self, other):
13028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13029 
 
13030 
  def __ne__(self, other):
13031 
    return not (self == other)
13032 
 
13033 
class getItemPricingBySource_result:
13034 
  """
13035 
  Attributes:
13036 
   - success
13037 
   - cex
13038 
  """
13039 
 
13040 
  thrift_spec = (
13041 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13042 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13043 
  )
13044 
 
13045 
  def __init__(self, success=None, cex=None,):
13046 
    self.success = success
13047 
    self.cex = cex
13048 
 
13049 
  def read(self, iprot):
13050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13052 
      return
13053 
    iprot.readStructBegin()
13054 
    while True:
13055 
      (fname, ftype, fid) = iprot.readFieldBegin()
13056 
      if ftype == TType.STOP:
13057 
        break
13058 
      if fid == 0:
13059 
        if ftype == TType.STRUCT:
13060 
          self.success = SourceItemPricing()
13061 
          self.success.read(iprot)
13062 
        else:
13063 
          iprot.skip(ftype)
13064 
      elif fid == 1:
13065 
        if ftype == TType.STRUCT:
13066 
          self.cex = CatalogServiceException()
13067 
          self.cex.read(iprot)
13068 
        else:
13069 
          iprot.skip(ftype)
13070 
      else:
13071 
        iprot.skip(ftype)
13072 
      iprot.readFieldEnd()
13073 
    iprot.readStructEnd()
13074 
 
13075 
  def write(self, oprot):
13076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13078 
      return
13079 
    oprot.writeStructBegin('getItemPricingBySource_result')
13080 
    if self.success is not None:
13081 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13082 
      self.success.write(oprot)
13083 
      oprot.writeFieldEnd()
13084 
    if self.cex is not None:
13085 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13086 
      self.cex.write(oprot)
13087 
      oprot.writeFieldEnd()
13088 
    oprot.writeFieldStop()
13089 
    oprot.writeStructEnd()
13090 
 
13091 
  def validate(self):
13092 
    return
13093 
 
13094 
 
13095 
  def __repr__(self):
13096 
    L = ['%s=%r' % (key, value)
13097 
      for key, value in self.__dict__.iteritems()]
13098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13099 
 
13100 
  def __eq__(self, other):
13101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13102 
 
13103 
  def __ne__(self, other):
13104 
    return not (self == other)
13105 
 
13106 
class addSourceItemPricing_args:
13107 
  """
13108 
  Attributes:
13109 
   - sourceItemPricing
13110 
  """
13111 
 
13112 
  thrift_spec = (
13113 
    None, # 0
13114 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13115 
  )
13116 
 
13117 
  def __init__(self, sourceItemPricing=None,):
13118 
    self.sourceItemPricing = sourceItemPricing
13119 
 
13120 
  def read(self, iprot):
13121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13123 
      return
13124 
    iprot.readStructBegin()
13125 
    while True:
13126 
      (fname, ftype, fid) = iprot.readFieldBegin()
13127 
      if ftype == TType.STOP:
13128 
        break
13129 
      if fid == 1:
13130 
        if ftype == TType.STRUCT:
13131 
          self.sourceItemPricing = SourceItemPricing()
13132 
          self.sourceItemPricing.read(iprot)
13133 
        else:
13134 
          iprot.skip(ftype)
13135 
      else:
13136 
        iprot.skip(ftype)
13137 
      iprot.readFieldEnd()
13138 
    iprot.readStructEnd()
13139 
 
13140 
  def write(self, oprot):
13141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13143 
      return
13144 
    oprot.writeStructBegin('addSourceItemPricing_args')
13145 
    if self.sourceItemPricing is not None:
13146 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13147 
      self.sourceItemPricing.write(oprot)
13148 
      oprot.writeFieldEnd()
13149 
    oprot.writeFieldStop()
13150 
    oprot.writeStructEnd()
13151 
 
13152 
  def validate(self):
13153 
    return
13154 
 
13155 
 
13156 
  def __repr__(self):
13157 
    L = ['%s=%r' % (key, value)
13158 
      for key, value in self.__dict__.iteritems()]
13159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13160 
 
13161 
  def __eq__(self, other):
13162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13163 
 
13164 
  def __ne__(self, other):
13165 
    return not (self == other)
13166 
 
13167 
class addSourceItemPricing_result:
13168 
  """
13169 
  Attributes:
13170 
   - cex
13171 
  """
13172 
 
13173 
  thrift_spec = (
13174 
    None, # 0
13175 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13176 
  )
13177 
 
13178 
  def __init__(self, cex=None,):
13179 
    self.cex = cex
13180 
 
13181 
  def read(self, iprot):
13182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13184 
      return
13185 
    iprot.readStructBegin()
13186 
    while True:
13187 
      (fname, ftype, fid) = iprot.readFieldBegin()
13188 
      if ftype == TType.STOP:
13189 
        break
13190 
      if fid == 1:
13191 
        if ftype == TType.STRUCT:
13192 
          self.cex = CatalogServiceException()
13193 
          self.cex.read(iprot)
13194 
        else:
13195 
          iprot.skip(ftype)
13196 
      else:
13197 
        iprot.skip(ftype)
13198 
      iprot.readFieldEnd()
13199 
    iprot.readStructEnd()
13200 
 
13201 
  def write(self, oprot):
13202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13204 
      return
13205 
    oprot.writeStructBegin('addSourceItemPricing_result')
13206 
    if self.cex is not None:
13207 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13208 
      self.cex.write(oprot)
13209 
      oprot.writeFieldEnd()
13210 
    oprot.writeFieldStop()
13211 
    oprot.writeStructEnd()
13212 
 
13213 
  def validate(self):
13214 
    return
13215 
 
13216 
 
13217 
  def __repr__(self):
13218 
    L = ['%s=%r' % (key, value)
13219 
      for key, value in self.__dict__.iteritems()]
13220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13221 
 
13222 
  def __eq__(self, other):
13223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13224 
 
13225 
  def __ne__(self, other):
13226 
    return not (self == other)
13227 
 
13228 
class getAllSourcePricing_args:
13229 
  """
13230 
  Attributes:
13231 
   - itemId
13232 
  """
13233 
 
13234 
  thrift_spec = (
13235 
    None, # 0
13236 
    (1, TType.I64, 'itemId', None, None, ), # 1
13237 
  )
13238 
 
13239 
  def __init__(self, itemId=None,):
13240 
    self.itemId = itemId
13241 
 
13242 
  def read(self, iprot):
13243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13245 
      return
13246 
    iprot.readStructBegin()
13247 
    while True:
13248 
      (fname, ftype, fid) = iprot.readFieldBegin()
13249 
      if ftype == TType.STOP:
13250 
        break
13251 
      if fid == 1:
13252 
        if ftype == TType.I64:
13253 
          self.itemId = iprot.readI64();
13254 
        else:
13255 
          iprot.skip(ftype)
13256 
      else:
13257 
        iprot.skip(ftype)
13258 
      iprot.readFieldEnd()
13259 
    iprot.readStructEnd()
13260 
 
13261 
  def write(self, oprot):
13262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13264 
      return
13265 
    oprot.writeStructBegin('getAllSourcePricing_args')
13266 
    if self.itemId is not None:
13267 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13268 
      oprot.writeI64(self.itemId)
13269 
      oprot.writeFieldEnd()
13270 
    oprot.writeFieldStop()
13271 
    oprot.writeStructEnd()
13272 
 
13273 
  def validate(self):
13274 
    return
13275 
 
13276 
 
13277 
  def __repr__(self):
13278 
    L = ['%s=%r' % (key, value)
13279 
      for key, value in self.__dict__.iteritems()]
13280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13281 
 
13282 
  def __eq__(self, other):
13283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13284 
 
13285 
  def __ne__(self, other):
13286 
    return not (self == other)
13287 
 
13288 
class getAllSourcePricing_result:
13289 
  """
13290 
  Attributes:
13291 
   - success
13292 
   - cex
13293 
  """
13294 
 
13295 
  thrift_spec = (
13296 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13297 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13298 
  )
13299 
 
13300 
  def __init__(self, success=None, cex=None,):
13301 
    self.success = success
13302 
    self.cex = cex
13303 
 
13304 
  def read(self, iprot):
13305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13307 
      return
13308 
    iprot.readStructBegin()
13309 
    while True:
13310 
      (fname, ftype, fid) = iprot.readFieldBegin()
13311 
      if ftype == TType.STOP:
13312 
        break
13313 
      if fid == 0:
13314 
        if ftype == TType.LIST:
13315 
          self.success = []
6850 kshitij.so 13316 
          (_etype231, _size228) = iprot.readListBegin()
13317 
          for _i232 in xrange(_size228):
13318 
            _elem233 = SourceItemPricing()
13319 
            _elem233.read(iprot)
13320 
            self.success.append(_elem233)
5944 mandeep.dh 13321 
          iprot.readListEnd()
13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      elif fid == 1:
13325 
        if ftype == TType.STRUCT:
13326 
          self.cex = CatalogServiceException()
13327 
          self.cex.read(iprot)
13328 
        else:
13329 
          iprot.skip(ftype)
13330 
      else:
13331 
        iprot.skip(ftype)
13332 
      iprot.readFieldEnd()
13333 
    iprot.readStructEnd()
13334 
 
13335 
  def write(self, oprot):
13336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13338 
      return
13339 
    oprot.writeStructBegin('getAllSourcePricing_result')
13340 
    if self.success is not None:
13341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13342 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13343 
      for iter234 in self.success:
13344 
        iter234.write(oprot)
5944 mandeep.dh 13345 
      oprot.writeListEnd()
13346 
      oprot.writeFieldEnd()
13347 
    if self.cex is not None:
13348 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13349 
      self.cex.write(oprot)
13350 
      oprot.writeFieldEnd()
13351 
    oprot.writeFieldStop()
13352 
    oprot.writeStructEnd()
13353 
 
13354 
  def validate(self):
13355 
    return
13356 
 
13357 
 
13358 
  def __repr__(self):
13359 
    L = ['%s=%r' % (key, value)
13360 
      for key, value in self.__dict__.iteritems()]
13361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13362 
 
13363 
  def __eq__(self, other):
13364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13365 
 
13366 
  def __ne__(self, other):
13367 
    return not (self == other)
13368 
 
13369 
class getItemForSource_args:
13370 
  """
13371 
  Attributes:
13372 
   - item_id
13373 
   - sourceId
13374 
  """
13375 
 
13376 
  thrift_spec = (
13377 
    None, # 0
13378 
    (1, TType.I64, 'item_id', None, None, ), # 1
13379 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13380 
  )
13381 
 
13382 
  def __init__(self, item_id=None, sourceId=None,):
13383 
    self.item_id = item_id
13384 
    self.sourceId = sourceId
13385 
 
13386 
  def read(self, iprot):
13387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13389 
      return
13390 
    iprot.readStructBegin()
13391 
    while True:
13392 
      (fname, ftype, fid) = iprot.readFieldBegin()
13393 
      if ftype == TType.STOP:
13394 
        break
13395 
      if fid == 1:
13396 
        if ftype == TType.I64:
13397 
          self.item_id = iprot.readI64();
13398 
        else:
13399 
          iprot.skip(ftype)
13400 
      elif fid == 2:
13401 
        if ftype == TType.I64:
13402 
          self.sourceId = iprot.readI64();
13403 
        else:
13404 
          iprot.skip(ftype)
13405 
      else:
13406 
        iprot.skip(ftype)
13407 
      iprot.readFieldEnd()
13408 
    iprot.readStructEnd()
13409 
 
13410 
  def write(self, oprot):
13411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13413 
      return
13414 
    oprot.writeStructBegin('getItemForSource_args')
13415 
    if self.item_id is not None:
13416 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13417 
      oprot.writeI64(self.item_id)
13418 
      oprot.writeFieldEnd()
13419 
    if self.sourceId is not None:
13420 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13421 
      oprot.writeI64(self.sourceId)
13422 
      oprot.writeFieldEnd()
13423 
    oprot.writeFieldStop()
13424 
    oprot.writeStructEnd()
13425 
 
13426 
  def validate(self):
13427 
    return
13428 
 
13429 
 
13430 
  def __repr__(self):
13431 
    L = ['%s=%r' % (key, value)
13432 
      for key, value in self.__dict__.iteritems()]
13433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13434 
 
13435 
  def __eq__(self, other):
13436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13437 
 
13438 
  def __ne__(self, other):
13439 
    return not (self == other)
13440 
 
13441 
class getItemForSource_result:
13442 
  """
13443 
  Attributes:
13444 
   - success
13445 
   - cex
13446 
  """
13447 
 
13448 
  thrift_spec = (
13449 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13450 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13451 
  )
13452 
 
13453 
  def __init__(self, success=None, cex=None,):
13454 
    self.success = success
13455 
    self.cex = cex
13456 
 
13457 
  def read(self, iprot):
13458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13460 
      return
13461 
    iprot.readStructBegin()
13462 
    while True:
13463 
      (fname, ftype, fid) = iprot.readFieldBegin()
13464 
      if ftype == TType.STOP:
13465 
        break
13466 
      if fid == 0:
13467 
        if ftype == TType.STRUCT:
13468 
          self.success = Item()
13469 
          self.success.read(iprot)
13470 
        else:
13471 
          iprot.skip(ftype)
13472 
      elif fid == 1:
13473 
        if ftype == TType.STRUCT:
13474 
          self.cex = CatalogServiceException()
13475 
          self.cex.read(iprot)
13476 
        else:
13477 
          iprot.skip(ftype)
13478 
      else:
13479 
        iprot.skip(ftype)
13480 
      iprot.readFieldEnd()
13481 
    iprot.readStructEnd()
13482 
 
13483 
  def write(self, oprot):
13484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13486 
      return
13487 
    oprot.writeStructBegin('getItemForSource_result')
13488 
    if self.success is not None:
13489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13490 
      self.success.write(oprot)
13491 
      oprot.writeFieldEnd()
13492 
    if self.cex is not None:
13493 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13494 
      self.cex.write(oprot)
13495 
      oprot.writeFieldEnd()
13496 
    oprot.writeFieldStop()
13497 
    oprot.writeStructEnd()
13498 
 
13499 
  def validate(self):
13500 
    return
13501 
 
13502 
 
13503 
  def __repr__(self):
13504 
    L = ['%s=%r' % (key, value)
13505 
      for key, value in self.__dict__.iteritems()]
13506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13507 
 
13508 
  def __eq__(self, other):
13509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13510 
 
13511 
  def __ne__(self, other):
13512 
    return not (self == other)
13513 
 
13514 
class searchItemsInRange_args:
13515 
  """
13516 
  Attributes:
13517 
   - searchTerms
13518 
   - offset
13519 
   - limit
13520 
  """
13521 
 
13522 
  thrift_spec = (
13523 
    None, # 0
13524 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13525 
    (2, TType.I64, 'offset', None, None, ), # 2
13526 
    (3, TType.I64, 'limit', None, None, ), # 3
13527 
  )
13528 
 
13529 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13530 
    self.searchTerms = searchTerms
13531 
    self.offset = offset
13532 
    self.limit = limit
13533 
 
13534 
  def read(self, iprot):
13535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13537 
      return
13538 
    iprot.readStructBegin()
13539 
    while True:
13540 
      (fname, ftype, fid) = iprot.readFieldBegin()
13541 
      if ftype == TType.STOP:
13542 
        break
13543 
      if fid == 1:
13544 
        if ftype == TType.LIST:
13545 
          self.searchTerms = []
6850 kshitij.so 13546 
          (_etype238, _size235) = iprot.readListBegin()
13547 
          for _i239 in xrange(_size235):
13548 
            _elem240 = iprot.readString();
13549 
            self.searchTerms.append(_elem240)
5944 mandeep.dh 13550 
          iprot.readListEnd()
13551 
        else:
13552 
          iprot.skip(ftype)
13553 
      elif fid == 2:
13554 
        if ftype == TType.I64:
13555 
          self.offset = iprot.readI64();
13556 
        else:
13557 
          iprot.skip(ftype)
13558 
      elif fid == 3:
13559 
        if ftype == TType.I64:
13560 
          self.limit = iprot.readI64();
13561 
        else:
13562 
          iprot.skip(ftype)
13563 
      else:
13564 
        iprot.skip(ftype)
13565 
      iprot.readFieldEnd()
13566 
    iprot.readStructEnd()
13567 
 
13568 
  def write(self, oprot):
13569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13571 
      return
13572 
    oprot.writeStructBegin('searchItemsInRange_args')
13573 
    if self.searchTerms is not None:
13574 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13575 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13576 
      for iter241 in self.searchTerms:
13577 
        oprot.writeString(iter241)
5944 mandeep.dh 13578 
      oprot.writeListEnd()
13579 
      oprot.writeFieldEnd()
13580 
    if self.offset is not None:
13581 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13582 
      oprot.writeI64(self.offset)
13583 
      oprot.writeFieldEnd()
13584 
    if self.limit is not None:
13585 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13586 
      oprot.writeI64(self.limit)
13587 
      oprot.writeFieldEnd()
13588 
    oprot.writeFieldStop()
13589 
    oprot.writeStructEnd()
13590 
 
13591 
  def validate(self):
13592 
    return
13593 
 
13594 
 
13595 
  def __repr__(self):
13596 
    L = ['%s=%r' % (key, value)
13597 
      for key, value in self.__dict__.iteritems()]
13598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13599 
 
13600 
  def __eq__(self, other):
13601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13602 
 
13603 
  def __ne__(self, other):
13604 
    return not (self == other)
13605 
 
13606 
class searchItemsInRange_result:
13607 
  """
13608 
  Attributes:
13609 
   - success
13610 
  """
13611 
 
13612 
  thrift_spec = (
13613 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13614 
  )
13615 
 
13616 
  def __init__(self, success=None,):
13617 
    self.success = success
13618 
 
13619 
  def read(self, iprot):
13620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13622 
      return
13623 
    iprot.readStructBegin()
13624 
    while True:
13625 
      (fname, ftype, fid) = iprot.readFieldBegin()
13626 
      if ftype == TType.STOP:
13627 
        break
13628 
      if fid == 0:
13629 
        if ftype == TType.LIST:
13630 
          self.success = []
6850 kshitij.so 13631 
          (_etype245, _size242) = iprot.readListBegin()
13632 
          for _i246 in xrange(_size242):
13633 
            _elem247 = Item()
13634 
            _elem247.read(iprot)
13635 
            self.success.append(_elem247)
5944 mandeep.dh 13636 
          iprot.readListEnd()
13637 
        else:
13638 
          iprot.skip(ftype)
13639 
      else:
13640 
        iprot.skip(ftype)
13641 
      iprot.readFieldEnd()
13642 
    iprot.readStructEnd()
13643 
 
13644 
  def write(self, oprot):
13645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13647 
      return
13648 
    oprot.writeStructBegin('searchItemsInRange_result')
13649 
    if self.success is not None:
13650 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13651 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13652 
      for iter248 in self.success:
13653 
        iter248.write(oprot)
5944 mandeep.dh 13654 
      oprot.writeListEnd()
13655 
      oprot.writeFieldEnd()
13656 
    oprot.writeFieldStop()
13657 
    oprot.writeStructEnd()
13658 
 
13659 
  def validate(self):
13660 
    return
13661 
 
13662 
 
13663 
  def __repr__(self):
13664 
    L = ['%s=%r' % (key, value)
13665 
      for key, value in self.__dict__.iteritems()]
13666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13667 
 
13668 
  def __eq__(self, other):
13669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13670 
 
13671 
  def __ne__(self, other):
13672 
    return not (self == other)
13673 
 
13674 
class getSearchResultCount_args:
13675 
  """
13676 
  Attributes:
13677 
   - searchTerms
13678 
  """
13679 
 
13680 
  thrift_spec = (
13681 
    None, # 0
13682 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13683 
  )
13684 
 
13685 
  def __init__(self, searchTerms=None,):
13686 
    self.searchTerms = searchTerms
13687 
 
13688 
  def read(self, iprot):
13689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13691 
      return
13692 
    iprot.readStructBegin()
13693 
    while True:
13694 
      (fname, ftype, fid) = iprot.readFieldBegin()
13695 
      if ftype == TType.STOP:
13696 
        break
13697 
      if fid == 1:
13698 
        if ftype == TType.LIST:
13699 
          self.searchTerms = []
6850 kshitij.so 13700 
          (_etype252, _size249) = iprot.readListBegin()
13701 
          for _i253 in xrange(_size249):
13702 
            _elem254 = iprot.readString();
13703 
            self.searchTerms.append(_elem254)
5944 mandeep.dh 13704 
          iprot.readListEnd()
13705 
        else:
13706 
          iprot.skip(ftype)
13707 
      else:
13708 
        iprot.skip(ftype)
13709 
      iprot.readFieldEnd()
13710 
    iprot.readStructEnd()
13711 
 
13712 
  def write(self, oprot):
13713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13715 
      return
13716 
    oprot.writeStructBegin('getSearchResultCount_args')
13717 
    if self.searchTerms is not None:
13718 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13719 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13720 
      for iter255 in self.searchTerms:
13721 
        oprot.writeString(iter255)
5944 mandeep.dh 13722 
      oprot.writeListEnd()
13723 
      oprot.writeFieldEnd()
13724 
    oprot.writeFieldStop()
13725 
    oprot.writeStructEnd()
13726 
 
13727 
  def validate(self):
13728 
    return
13729 
 
13730 
 
13731 
  def __repr__(self):
13732 
    L = ['%s=%r' % (key, value)
13733 
      for key, value in self.__dict__.iteritems()]
13734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13735 
 
13736 
  def __eq__(self, other):
13737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13738 
 
13739 
  def __ne__(self, other):
13740 
    return not (self == other)
13741 
 
13742 
class getSearchResultCount_result:
13743 
  """
13744 
  Attributes:
13745 
   - success
13746 
  """
13747 
 
13748 
  thrift_spec = (
13749 
    (0, TType.I32, 'success', None, None, ), # 0
13750 
  )
13751 
 
13752 
  def __init__(self, success=None,):
13753 
    self.success = success
13754 
 
13755 
  def read(self, iprot):
13756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13758 
      return
13759 
    iprot.readStructBegin()
13760 
    while True:
13761 
      (fname, ftype, fid) = iprot.readFieldBegin()
13762 
      if ftype == TType.STOP:
13763 
        break
13764 
      if fid == 0:
13765 
        if ftype == TType.I32:
13766 
          self.success = iprot.readI32();
13767 
        else:
13768 
          iprot.skip(ftype)
13769 
      else:
13770 
        iprot.skip(ftype)
13771 
      iprot.readFieldEnd()
13772 
    iprot.readStructEnd()
13773 
 
13774 
  def write(self, oprot):
13775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13777 
      return
13778 
    oprot.writeStructBegin('getSearchResultCount_result')
13779 
    if self.success is not None:
13780 
      oprot.writeFieldBegin('success', TType.I32, 0)
13781 
      oprot.writeI32(self.success)
13782 
      oprot.writeFieldEnd()
13783 
    oprot.writeFieldStop()
13784 
    oprot.writeStructEnd()
13785 
 
13786 
  def validate(self):
13787 
    return
13788 
 
13789 
 
13790 
  def __repr__(self):
13791 
    L = ['%s=%r' % (key, value)
13792 
      for key, value in self.__dict__.iteritems()]
13793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13794 
 
13795 
  def __eq__(self, other):
13796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13797 
 
13798 
  def __ne__(self, other):
13799 
    return not (self == other)
13800 
 
13801 
class getProductNotifications_args:
13802 
  """
13803 
  Attributes:
13804 
   - startDateTime
13805 
  """
13806 
 
13807 
  thrift_spec = (
13808 
    None, # 0
13809 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13810 
  )
13811 
 
13812 
  def __init__(self, startDateTime=None,):
13813 
    self.startDateTime = startDateTime
13814 
 
13815 
  def read(self, iprot):
13816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13818 
      return
13819 
    iprot.readStructBegin()
13820 
    while True:
13821 
      (fname, ftype, fid) = iprot.readFieldBegin()
13822 
      if ftype == TType.STOP:
13823 
        break
13824 
      if fid == 1:
13825 
        if ftype == TType.I64:
13826 
          self.startDateTime = iprot.readI64();
13827 
        else:
13828 
          iprot.skip(ftype)
13829 
      else:
13830 
        iprot.skip(ftype)
13831 
      iprot.readFieldEnd()
13832 
    iprot.readStructEnd()
13833 
 
13834 
  def write(self, oprot):
13835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13837 
      return
13838 
    oprot.writeStructBegin('getProductNotifications_args')
13839 
    if self.startDateTime is not None:
13840 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13841 
      oprot.writeI64(self.startDateTime)
13842 
      oprot.writeFieldEnd()
13843 
    oprot.writeFieldStop()
13844 
    oprot.writeStructEnd()
13845 
 
13846 
  def validate(self):
13847 
    return
13848 
 
13849 
 
13850 
  def __repr__(self):
13851 
    L = ['%s=%r' % (key, value)
13852 
      for key, value in self.__dict__.iteritems()]
13853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13854 
 
13855 
  def __eq__(self, other):
13856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13857 
 
13858 
  def __ne__(self, other):
13859 
    return not (self == other)
13860 
 
13861 
class getProductNotifications_result:
13862 
  """
13863 
  Attributes:
13864 
   - success
13865 
  """
13866 
 
13867 
  thrift_spec = (
13868 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
13869 
  )
13870 
 
13871 
  def __init__(self, success=None,):
13872 
    self.success = success
13873 
 
13874 
  def read(self, iprot):
13875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13877 
      return
13878 
    iprot.readStructBegin()
13879 
    while True:
13880 
      (fname, ftype, fid) = iprot.readFieldBegin()
13881 
      if ftype == TType.STOP:
13882 
        break
13883 
      if fid == 0:
13884 
        if ftype == TType.LIST:
13885 
          self.success = []
6850 kshitij.so 13886 
          (_etype259, _size256) = iprot.readListBegin()
13887 
          for _i260 in xrange(_size256):
13888 
            _elem261 = ProductNotificationRequest()
13889 
            _elem261.read(iprot)
13890 
            self.success.append(_elem261)
5944 mandeep.dh 13891 
          iprot.readListEnd()
13892 
        else:
13893 
          iprot.skip(ftype)
13894 
      else:
13895 
        iprot.skip(ftype)
13896 
      iprot.readFieldEnd()
13897 
    iprot.readStructEnd()
13898 
 
13899 
  def write(self, oprot):
13900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13902 
      return
13903 
    oprot.writeStructBegin('getProductNotifications_result')
13904 
    if self.success is not None:
13905 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13906 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13907 
      for iter262 in self.success:
13908 
        iter262.write(oprot)
5944 mandeep.dh 13909 
      oprot.writeListEnd()
13910 
      oprot.writeFieldEnd()
13911 
    oprot.writeFieldStop()
13912 
    oprot.writeStructEnd()
13913 
 
13914 
  def validate(self):
13915 
    return
13916 
 
13917 
 
13918 
  def __repr__(self):
13919 
    L = ['%s=%r' % (key, value)
13920 
      for key, value in self.__dict__.iteritems()]
13921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13922 
 
13923 
  def __eq__(self, other):
13924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13925 
 
13926 
  def __ne__(self, other):
13927 
    return not (self == other)
13928 
 
13929 
class getProductNotificationRequestCount_args:
13930 
  """
13931 
  Attributes:
13932 
   - startDateTime
13933 
  """
13934 
 
13935 
  thrift_spec = (
13936 
    None, # 0
13937 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13938 
  )
13939 
 
13940 
  def __init__(self, startDateTime=None,):
13941 
    self.startDateTime = startDateTime
13942 
 
13943 
  def read(self, iprot):
13944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13946 
      return
13947 
    iprot.readStructBegin()
13948 
    while True:
13949 
      (fname, ftype, fid) = iprot.readFieldBegin()
13950 
      if ftype == TType.STOP:
13951 
        break
13952 
      if fid == 1:
13953 
        if ftype == TType.I64:
13954 
          self.startDateTime = iprot.readI64();
13955 
        else:
13956 
          iprot.skip(ftype)
13957 
      else:
13958 
        iprot.skip(ftype)
13959 
      iprot.readFieldEnd()
13960 
    iprot.readStructEnd()
13961 
 
13962 
  def write(self, oprot):
13963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13965 
      return
13966 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
13967 
    if self.startDateTime is not None:
13968 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13969 
      oprot.writeI64(self.startDateTime)
13970 
      oprot.writeFieldEnd()
13971 
    oprot.writeFieldStop()
13972 
    oprot.writeStructEnd()
13973 
 
13974 
  def validate(self):
13975 
    return
13976 
 
13977 
 
13978 
  def __repr__(self):
13979 
    L = ['%s=%r' % (key, value)
13980 
      for key, value in self.__dict__.iteritems()]
13981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13982 
 
13983 
  def __eq__(self, other):
13984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13985 
 
13986 
  def __ne__(self, other):
13987 
    return not (self == other)
13988 
 
13989 
class getProductNotificationRequestCount_result:
13990 
  """
13991 
  Attributes:
13992 
   - success
13993 
  """
13994 
 
13995 
  thrift_spec = (
13996 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
13997 
  )
13998 
 
13999 
  def __init__(self, success=None,):
14000 
    self.success = success
14001 
 
14002 
  def read(self, iprot):
14003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14005 
      return
14006 
    iprot.readStructBegin()
14007 
    while True:
14008 
      (fname, ftype, fid) = iprot.readFieldBegin()
14009 
      if ftype == TType.STOP:
14010 
        break
14011 
      if fid == 0:
14012 
        if ftype == TType.LIST:
14013 
          self.success = []
6850 kshitij.so 14014 
          (_etype266, _size263) = iprot.readListBegin()
14015 
          for _i267 in xrange(_size263):
14016 
            _elem268 = ProductNotificationRequestCount()
14017 
            _elem268.read(iprot)
14018 
            self.success.append(_elem268)
5944 mandeep.dh 14019 
          iprot.readListEnd()
14020 
        else:
14021 
          iprot.skip(ftype)
14022 
      else:
14023 
        iprot.skip(ftype)
14024 
      iprot.readFieldEnd()
14025 
    iprot.readStructEnd()
14026 
 
14027 
  def write(self, oprot):
14028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14030 
      return
14031 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14032 
    if self.success is not None:
14033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 14035 
      for iter269 in self.success:
14036 
        iter269.write(oprot)
5944 mandeep.dh 14037 
      oprot.writeListEnd()
14038 
      oprot.writeFieldEnd()
14039 
    oprot.writeFieldStop()
14040 
    oprot.writeStructEnd()
14041 
 
14042 
  def validate(self):
14043 
    return
14044 
 
14045 
 
14046 
  def __repr__(self):
14047 
    L = ['%s=%r' % (key, value)
14048 
      for key, value in self.__dict__.iteritems()]
14049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14050 
 
14051 
  def __eq__(self, other):
14052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14053 
 
14054 
  def __ne__(self, other):
14055 
    return not (self == other)
14056 
 
14057 
class addAuthorizationLog_args:
14058 
  """
14059 
  Attributes:
14060 
   - itemId
14061 
   - username
14062 
   - reason
14063 
  """
14064 
 
14065 
  thrift_spec = (
14066 
    None, # 0
14067 
    (1, TType.I64, 'itemId', None, None, ), # 1
14068 
    (2, TType.STRING, 'username', None, None, ), # 2
14069 
    (3, TType.STRING, 'reason', None, None, ), # 3
14070 
  )
14071 
 
14072 
  def __init__(self, itemId=None, username=None, reason=None,):
14073 
    self.itemId = itemId
14074 
    self.username = username
14075 
    self.reason = reason
14076 
 
14077 
  def read(self, iprot):
14078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14080 
      return
14081 
    iprot.readStructBegin()
14082 
    while True:
14083 
      (fname, ftype, fid) = iprot.readFieldBegin()
14084 
      if ftype == TType.STOP:
14085 
        break
14086 
      if fid == 1:
14087 
        if ftype == TType.I64:
14088 
          self.itemId = iprot.readI64();
14089 
        else:
14090 
          iprot.skip(ftype)
14091 
      elif fid == 2:
14092 
        if ftype == TType.STRING:
14093 
          self.username = iprot.readString();
14094 
        else:
14095 
          iprot.skip(ftype)
14096 
      elif fid == 3:
14097 
        if ftype == TType.STRING:
14098 
          self.reason = iprot.readString();
14099 
        else:
14100 
          iprot.skip(ftype)
14101 
      else:
14102 
        iprot.skip(ftype)
14103 
      iprot.readFieldEnd()
14104 
    iprot.readStructEnd()
14105 
 
14106 
  def write(self, oprot):
14107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14109 
      return
14110 
    oprot.writeStructBegin('addAuthorizationLog_args')
14111 
    if self.itemId is not None:
14112 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14113 
      oprot.writeI64(self.itemId)
14114 
      oprot.writeFieldEnd()
14115 
    if self.username is not None:
14116 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14117 
      oprot.writeString(self.username)
14118 
      oprot.writeFieldEnd()
14119 
    if self.reason is not None:
14120 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14121 
      oprot.writeString(self.reason)
14122 
      oprot.writeFieldEnd()
14123 
    oprot.writeFieldStop()
14124 
    oprot.writeStructEnd()
14125 
 
14126 
  def validate(self):
14127 
    return
14128 
 
14129 
 
14130 
  def __repr__(self):
14131 
    L = ['%s=%r' % (key, value)
14132 
      for key, value in self.__dict__.iteritems()]
14133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14134 
 
14135 
  def __eq__(self, other):
14136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14137 
 
14138 
  def __ne__(self, other):
14139 
    return not (self == other)
14140 
 
14141 
class addAuthorizationLog_result:
14142 
  """
14143 
  Attributes:
14144 
   - success
14145 
   - cex
14146 
  """
14147 
 
14148 
  thrift_spec = (
14149 
    (0, TType.BOOL, 'success', None, None, ), # 0
14150 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14151 
  )
14152 
 
14153 
  def __init__(self, success=None, cex=None,):
14154 
    self.success = success
14155 
    self.cex = cex
14156 
 
14157 
  def read(self, iprot):
14158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14160 
      return
14161 
    iprot.readStructBegin()
14162 
    while True:
14163 
      (fname, ftype, fid) = iprot.readFieldBegin()
14164 
      if ftype == TType.STOP:
14165 
        break
14166 
      if fid == 0:
14167 
        if ftype == TType.BOOL:
14168 
          self.success = iprot.readBool();
14169 
        else:
14170 
          iprot.skip(ftype)
14171 
      elif fid == 1:
14172 
        if ftype == TType.STRUCT:
14173 
          self.cex = CatalogServiceException()
14174 
          self.cex.read(iprot)
14175 
        else:
14176 
          iprot.skip(ftype)
14177 
      else:
14178 
        iprot.skip(ftype)
14179 
      iprot.readFieldEnd()
14180 
    iprot.readStructEnd()
14181 
 
14182 
  def write(self, oprot):
14183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14185 
      return
14186 
    oprot.writeStructBegin('addAuthorizationLog_result')
14187 
    if self.success is not None:
14188 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14189 
      oprot.writeBool(self.success)
14190 
      oprot.writeFieldEnd()
14191 
    if self.cex is not None:
14192 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14193 
      self.cex.write(oprot)
14194 
      oprot.writeFieldEnd()
14195 
    oprot.writeFieldStop()
14196 
    oprot.writeStructEnd()
14197 
 
14198 
  def validate(self):
14199 
    return
14200 
 
14201 
 
14202 
  def __repr__(self):
14203 
    L = ['%s=%r' % (key, value)
14204 
      for key, value in self.__dict__.iteritems()]
14205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14206 
 
14207 
  def __eq__(self, other):
14208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14209 
 
14210 
  def __ne__(self, other):
14211 
    return not (self == other)
14212 
 
14213 
class addupdateVoucherForItem_args:
14214 
  """
14215 
  Attributes:
14216 
   - catalog_item_id
14217 
   - voucherType
14218 
   - voucherAmount
14219 
  """
14220 
 
14221 
  thrift_spec = (
14222 
    None, # 0
14223 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14224 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14225 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14226 
  )
14227 
 
14228 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14229 
    self.catalog_item_id = catalog_item_id
14230 
    self.voucherType = voucherType
14231 
    self.voucherAmount = voucherAmount
14232 
 
14233 
  def read(self, iprot):
14234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14236 
      return
14237 
    iprot.readStructBegin()
14238 
    while True:
14239 
      (fname, ftype, fid) = iprot.readFieldBegin()
14240 
      if ftype == TType.STOP:
14241 
        break
14242 
      if fid == 1:
14243 
        if ftype == TType.I64:
14244 
          self.catalog_item_id = iprot.readI64();
14245 
        else:
14246 
          iprot.skip(ftype)
14247 
      elif fid == 2:
14248 
        if ftype == TType.I64:
14249 
          self.voucherType = iprot.readI64();
14250 
        else:
14251 
          iprot.skip(ftype)
14252 
      elif fid == 3:
14253 
        if ftype == TType.I64:
14254 
          self.voucherAmount = iprot.readI64();
14255 
        else:
14256 
          iprot.skip(ftype)
14257 
      else:
14258 
        iprot.skip(ftype)
14259 
      iprot.readFieldEnd()
14260 
    iprot.readStructEnd()
14261 
 
14262 
  def write(self, oprot):
14263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14265 
      return
14266 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14267 
    if self.catalog_item_id is not None:
14268 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14269 
      oprot.writeI64(self.catalog_item_id)
14270 
      oprot.writeFieldEnd()
14271 
    if self.voucherType is not None:
14272 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14273 
      oprot.writeI64(self.voucherType)
14274 
      oprot.writeFieldEnd()
14275 
    if self.voucherAmount is not None:
14276 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14277 
      oprot.writeI64(self.voucherAmount)
14278 
      oprot.writeFieldEnd()
14279 
    oprot.writeFieldStop()
14280 
    oprot.writeStructEnd()
14281 
 
14282 
  def validate(self):
14283 
    return
14284 
 
14285 
 
14286 
  def __repr__(self):
14287 
    L = ['%s=%r' % (key, value)
14288 
      for key, value in self.__dict__.iteritems()]
14289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14290 
 
14291 
  def __eq__(self, other):
14292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14293 
 
14294 
  def __ne__(self, other):
14295 
    return not (self == other)
14296 
 
14297 
class addupdateVoucherForItem_result:
14298 
  """
14299 
  Attributes:
14300 
   - success
14301 
   - cex
14302 
  """
14303 
 
14304 
  thrift_spec = (
14305 
    (0, TType.BOOL, 'success', None, None, ), # 0
14306 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14307 
  )
14308 
 
14309 
  def __init__(self, success=None, cex=None,):
14310 
    self.success = success
14311 
    self.cex = cex
14312 
 
14313 
  def read(self, iprot):
14314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14316 
      return
14317 
    iprot.readStructBegin()
14318 
    while True:
14319 
      (fname, ftype, fid) = iprot.readFieldBegin()
14320 
      if ftype == TType.STOP:
14321 
        break
14322 
      if fid == 0:
14323 
        if ftype == TType.BOOL:
14324 
          self.success = iprot.readBool();
14325 
        else:
14326 
          iprot.skip(ftype)
14327 
      elif fid == 1:
14328 
        if ftype == TType.STRUCT:
14329 
          self.cex = CatalogServiceException()
14330 
          self.cex.read(iprot)
14331 
        else:
14332 
          iprot.skip(ftype)
14333 
      else:
14334 
        iprot.skip(ftype)
14335 
      iprot.readFieldEnd()
14336 
    iprot.readStructEnd()
14337 
 
14338 
  def write(self, oprot):
14339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14341 
      return
14342 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14343 
    if self.success is not None:
14344 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14345 
      oprot.writeBool(self.success)
14346 
      oprot.writeFieldEnd()
14347 
    if self.cex is not None:
14348 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14349 
      self.cex.write(oprot)
14350 
      oprot.writeFieldEnd()
14351 
    oprot.writeFieldStop()
14352 
    oprot.writeStructEnd()
14353 
 
14354 
  def validate(self):
14355 
    return
14356 
 
14357 
 
14358 
  def __repr__(self):
14359 
    L = ['%s=%r' % (key, value)
14360 
      for key, value in self.__dict__.iteritems()]
14361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14362 
 
14363 
  def __eq__(self, other):
14364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14365 
 
14366 
  def __ne__(self, other):
14367 
    return not (self == other)
14368 
 
14369 
class deleteVoucherForItem_args:
14370 
  """
14371 
  Attributes:
14372 
   - catalog_item_id
14373 
   - voucherType
14374 
  """
14375 
 
14376 
  thrift_spec = (
14377 
    None, # 0
14378 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14379 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14380 
  )
14381 
 
14382 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14383 
    self.catalog_item_id = catalog_item_id
14384 
    self.voucherType = voucherType
14385 
 
14386 
  def read(self, iprot):
14387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14389 
      return
14390 
    iprot.readStructBegin()
14391 
    while True:
14392 
      (fname, ftype, fid) = iprot.readFieldBegin()
14393 
      if ftype == TType.STOP:
14394 
        break
14395 
      if fid == 1:
14396 
        if ftype == TType.I64:
14397 
          self.catalog_item_id = iprot.readI64();
14398 
        else:
14399 
          iprot.skip(ftype)
14400 
      elif fid == 2:
14401 
        if ftype == TType.I64:
14402 
          self.voucherType = iprot.readI64();
14403 
        else:
14404 
          iprot.skip(ftype)
14405 
      else:
14406 
        iprot.skip(ftype)
14407 
      iprot.readFieldEnd()
14408 
    iprot.readStructEnd()
14409 
 
14410 
  def write(self, oprot):
14411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14413 
      return
14414 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14415 
    if self.catalog_item_id is not None:
14416 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14417 
      oprot.writeI64(self.catalog_item_id)
14418 
      oprot.writeFieldEnd()
14419 
    if self.voucherType is not None:
14420 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14421 
      oprot.writeI64(self.voucherType)
14422 
      oprot.writeFieldEnd()
14423 
    oprot.writeFieldStop()
14424 
    oprot.writeStructEnd()
14425 
 
14426 
  def validate(self):
14427 
    return
14428 
 
14429 
 
14430 
  def __repr__(self):
14431 
    L = ['%s=%r' % (key, value)
14432 
      for key, value in self.__dict__.iteritems()]
14433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14434 
 
14435 
  def __eq__(self, other):
14436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14437 
 
14438 
  def __ne__(self, other):
14439 
    return not (self == other)
14440 
 
14441 
class deleteVoucherForItem_result:
14442 
  """
14443 
  Attributes:
14444 
   - success
14445 
   - cex
14446 
  """
14447 
 
14448 
  thrift_spec = (
14449 
    (0, TType.BOOL, 'success', None, None, ), # 0
14450 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14451 
  )
14452 
 
14453 
  def __init__(self, success=None, cex=None,):
14454 
    self.success = success
14455 
    self.cex = cex
14456 
 
14457 
  def read(self, iprot):
14458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14460 
      return
14461 
    iprot.readStructBegin()
14462 
    while True:
14463 
      (fname, ftype, fid) = iprot.readFieldBegin()
14464 
      if ftype == TType.STOP:
14465 
        break
14466 
      if fid == 0:
14467 
        if ftype == TType.BOOL:
14468 
          self.success = iprot.readBool();
14469 
        else:
14470 
          iprot.skip(ftype)
14471 
      elif fid == 1:
14472 
        if ftype == TType.STRUCT:
14473 
          self.cex = CatalogServiceException()
14474 
          self.cex.read(iprot)
14475 
        else:
14476 
          iprot.skip(ftype)
14477 
      else:
14478 
        iprot.skip(ftype)
14479 
      iprot.readFieldEnd()
14480 
    iprot.readStructEnd()
14481 
 
14482 
  def write(self, oprot):
14483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14485 
      return
14486 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14487 
    if self.success is not None:
14488 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14489 
      oprot.writeBool(self.success)
14490 
      oprot.writeFieldEnd()
14491 
    if self.cex is not None:
14492 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14493 
      self.cex.write(oprot)
14494 
      oprot.writeFieldEnd()
14495 
    oprot.writeFieldStop()
14496 
    oprot.writeStructEnd()
14497 
 
14498 
  def validate(self):
14499 
    return
14500 
 
14501 
 
14502 
  def __repr__(self):
14503 
    L = ['%s=%r' % (key, value)
14504 
      for key, value in self.__dict__.iteritems()]
14505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14506 
 
14507 
  def __eq__(self, other):
14508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14509 
 
14510 
  def __ne__(self, other):
14511 
    return not (self == other)
14512 
 
14513 
class getVoucherAmount_args:
14514 
  """
14515 
  Attributes:
14516 
   - itemId
14517 
   - voucherType
14518 
  """
14519 
 
14520 
  thrift_spec = (
14521 
    None, # 0
14522 
    (1, TType.I64, 'itemId', None, None, ), # 1
14523 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14524 
  )
14525 
 
14526 
  def __init__(self, itemId=None, voucherType=None,):
14527 
    self.itemId = itemId
14528 
    self.voucherType = voucherType
14529 
 
14530 
  def read(self, iprot):
14531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14533 
      return
14534 
    iprot.readStructBegin()
14535 
    while True:
14536 
      (fname, ftype, fid) = iprot.readFieldBegin()
14537 
      if ftype == TType.STOP:
14538 
        break
14539 
      if fid == 1:
14540 
        if ftype == TType.I64:
14541 
          self.itemId = iprot.readI64();
14542 
        else:
14543 
          iprot.skip(ftype)
14544 
      elif fid == 2:
14545 
        if ftype == TType.I64:
14546 
          self.voucherType = iprot.readI64();
14547 
        else:
14548 
          iprot.skip(ftype)
14549 
      else:
14550 
        iprot.skip(ftype)
14551 
      iprot.readFieldEnd()
14552 
    iprot.readStructEnd()
14553 
 
14554 
  def write(self, oprot):
14555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14557 
      return
14558 
    oprot.writeStructBegin('getVoucherAmount_args')
14559 
    if self.itemId is not None:
14560 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14561 
      oprot.writeI64(self.itemId)
14562 
      oprot.writeFieldEnd()
14563 
    if self.voucherType is not None:
14564 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14565 
      oprot.writeI64(self.voucherType)
14566 
      oprot.writeFieldEnd()
14567 
    oprot.writeFieldStop()
14568 
    oprot.writeStructEnd()
14569 
 
14570 
  def validate(self):
14571 
    return
14572 
 
14573 
 
14574 
  def __repr__(self):
14575 
    L = ['%s=%r' % (key, value)
14576 
      for key, value in self.__dict__.iteritems()]
14577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14578 
 
14579 
  def __eq__(self, other):
14580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14581 
 
14582 
  def __ne__(self, other):
14583 
    return not (self == other)
14584 
 
14585 
class getVoucherAmount_result:
14586 
  """
14587 
  Attributes:
14588 
   - success
14589 
  """
14590 
 
14591 
  thrift_spec = (
14592 
    (0, TType.I64, 'success', None, None, ), # 0
14593 
  )
14594 
 
14595 
  def __init__(self, success=None,):
14596 
    self.success = success
14597 
 
14598 
  def read(self, iprot):
14599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14601 
      return
14602 
    iprot.readStructBegin()
14603 
    while True:
14604 
      (fname, ftype, fid) = iprot.readFieldBegin()
14605 
      if ftype == TType.STOP:
14606 
        break
14607 
      if fid == 0:
14608 
        if ftype == TType.I64:
14609 
          self.success = iprot.readI64();
14610 
        else:
14611 
          iprot.skip(ftype)
14612 
      else:
14613 
        iprot.skip(ftype)
14614 
      iprot.readFieldEnd()
14615 
    iprot.readStructEnd()
14616 
 
14617 
  def write(self, oprot):
14618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14620 
      return
14621 
    oprot.writeStructBegin('getVoucherAmount_result')
14622 
    if self.success is not None:
14623 
      oprot.writeFieldBegin('success', TType.I64, 0)
14624 
      oprot.writeI64(self.success)
14625 
      oprot.writeFieldEnd()
14626 
    oprot.writeFieldStop()
14627 
    oprot.writeStructEnd()
14628 
 
14629 
  def validate(self):
14630 
    return
14631 
 
14632 
 
14633 
  def __repr__(self):
14634 
    L = ['%s=%r' % (key, value)
14635 
      for key, value in self.__dict__.iteritems()]
14636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14637 
 
14638 
  def __eq__(self, other):
14639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14640 
 
14641 
  def __ne__(self, other):
14642 
    return not (self == other)
14643 
 
14644 
class getAllItemVouchers_args:
14645 
  """
14646 
  Attributes:
14647 
   - itemId
14648 
  """
14649 
 
14650 
  thrift_spec = (
14651 
    None, # 0
14652 
    (1, TType.I64, 'itemId', None, None, ), # 1
14653 
  )
14654 
 
14655 
  def __init__(self, itemId=None,):
14656 
    self.itemId = itemId
14657 
 
14658 
  def read(self, iprot):
14659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14661 
      return
14662 
    iprot.readStructBegin()
14663 
    while True:
14664 
      (fname, ftype, fid) = iprot.readFieldBegin()
14665 
      if ftype == TType.STOP:
14666 
        break
14667 
      if fid == 1:
14668 
        if ftype == TType.I64:
14669 
          self.itemId = iprot.readI64();
14670 
        else:
14671 
          iprot.skip(ftype)
14672 
      else:
14673 
        iprot.skip(ftype)
14674 
      iprot.readFieldEnd()
14675 
    iprot.readStructEnd()
14676 
 
14677 
  def write(self, oprot):
14678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14680 
      return
14681 
    oprot.writeStructBegin('getAllItemVouchers_args')
14682 
    if self.itemId is not None:
14683 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14684 
      oprot.writeI64(self.itemId)
14685 
      oprot.writeFieldEnd()
14686 
    oprot.writeFieldStop()
14687 
    oprot.writeStructEnd()
14688 
 
14689 
  def validate(self):
14690 
    return
14691 
 
14692 
 
14693 
  def __repr__(self):
14694 
    L = ['%s=%r' % (key, value)
14695 
      for key, value in self.__dict__.iteritems()]
14696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14697 
 
14698 
  def __eq__(self, other):
14699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14700 
 
14701 
  def __ne__(self, other):
14702 
    return not (self == other)
14703 
 
14704 
class getAllItemVouchers_result:
14705 
  """
14706 
  Attributes:
14707 
   - success
14708 
  """
14709 
 
14710 
  thrift_spec = (
14711 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14712 
  )
14713 
 
14714 
  def __init__(self, success=None,):
14715 
    self.success = success
14716 
 
14717 
  def read(self, iprot):
14718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14720 
      return
14721 
    iprot.readStructBegin()
14722 
    while True:
14723 
      (fname, ftype, fid) = iprot.readFieldBegin()
14724 
      if ftype == TType.STOP:
14725 
        break
14726 
      if fid == 0:
14727 
        if ftype == TType.LIST:
14728 
          self.success = []
7256 rajveer 14729 
          (_etype273, _size270) = iprot.readListBegin()
14730 
          for _i274 in xrange(_size270):
14731 
            _elem275 = VoucherItemMapping()
14732 
            _elem275.read(iprot)
14733 
            self.success.append(_elem275)
5944 mandeep.dh 14734 
          iprot.readListEnd()
14735 
        else:
14736 
          iprot.skip(ftype)
14737 
      else:
14738 
        iprot.skip(ftype)
14739 
      iprot.readFieldEnd()
14740 
    iprot.readStructEnd()
14741 
 
14742 
  def write(self, oprot):
14743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14745 
      return
14746 
    oprot.writeStructBegin('getAllItemVouchers_result')
14747 
    if self.success is not None:
14748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14749 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 14750 
      for iter276 in self.success:
14751 
        iter276.write(oprot)
5944 mandeep.dh 14752 
      oprot.writeListEnd()
14753 
      oprot.writeFieldEnd()
14754 
    oprot.writeFieldStop()
14755 
    oprot.writeStructEnd()
14756 
 
14757 
  def validate(self):
14758 
    return
14759 
 
14760 
 
14761 
  def __repr__(self):
14762 
    L = ['%s=%r' % (key, value)
14763 
      for key, value in self.__dict__.iteritems()]
14764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14765 
 
14766 
  def __eq__(self, other):
14767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14768 
 
14769 
  def __ne__(self, other):
14770 
    return not (self == other)
14771 
 
14772 
class isValidCatalogItemId_args:
14773 
  """
14774 
  Attributes:
14775 
   - catalog_item_id
14776 
  """
14777 
 
14778 
  thrift_spec = (
14779 
    None, # 0
14780 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14781 
  )
14782 
 
14783 
  def __init__(self, catalog_item_id=None,):
14784 
    self.catalog_item_id = catalog_item_id
14785 
 
14786 
  def read(self, iprot):
14787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14789 
      return
14790 
    iprot.readStructBegin()
14791 
    while True:
14792 
      (fname, ftype, fid) = iprot.readFieldBegin()
14793 
      if ftype == TType.STOP:
14794 
        break
14795 
      if fid == 1:
14796 
        if ftype == TType.I64:
14797 
          self.catalog_item_id = iprot.readI64();
14798 
        else:
14799 
          iprot.skip(ftype)
14800 
      else:
14801 
        iprot.skip(ftype)
14802 
      iprot.readFieldEnd()
14803 
    iprot.readStructEnd()
14804 
 
14805 
  def write(self, oprot):
14806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14808 
      return
14809 
    oprot.writeStructBegin('isValidCatalogItemId_args')
14810 
    if self.catalog_item_id is not None:
14811 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14812 
      oprot.writeI64(self.catalog_item_id)
14813 
      oprot.writeFieldEnd()
14814 
    oprot.writeFieldStop()
14815 
    oprot.writeStructEnd()
14816 
 
14817 
  def validate(self):
14818 
    return
14819 
 
14820 
 
14821 
  def __repr__(self):
14822 
    L = ['%s=%r' % (key, value)
14823 
      for key, value in self.__dict__.iteritems()]
14824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14825 
 
14826 
  def __eq__(self, other):
14827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14828 
 
14829 
  def __ne__(self, other):
14830 
    return not (self == other)
14831 
 
14832 
class isValidCatalogItemId_result:
14833 
  """
14834 
  Attributes:
14835 
   - success
14836 
  """
14837 
 
14838 
  thrift_spec = (
14839 
    (0, TType.BOOL, 'success', None, None, ), # 0
14840 
  )
14841 
 
14842 
  def __init__(self, success=None,):
14843 
    self.success = success
14844 
 
14845 
  def read(self, iprot):
14846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14848 
      return
14849 
    iprot.readStructBegin()
14850 
    while True:
14851 
      (fname, ftype, fid) = iprot.readFieldBegin()
14852 
      if ftype == TType.STOP:
14853 
        break
14854 
      if fid == 0:
14855 
        if ftype == TType.BOOL:
14856 
          self.success = iprot.readBool();
14857 
        else:
14858 
          iprot.skip(ftype)
14859 
      else:
14860 
        iprot.skip(ftype)
14861 
      iprot.readFieldEnd()
14862 
    iprot.readStructEnd()
14863 
 
14864 
  def write(self, oprot):
14865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14867 
      return
14868 
    oprot.writeStructBegin('isValidCatalogItemId_result')
14869 
    if self.success is not None:
14870 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14871 
      oprot.writeBool(self.success)
14872 
      oprot.writeFieldEnd()
14873 
    oprot.writeFieldStop()
14874 
    oprot.writeStructEnd()
14875 
 
14876 
  def validate(self):
14877 
    return
14878 
 
14879 
 
14880 
  def __repr__(self):
14881 
    L = ['%s=%r' % (key, value)
14882 
      for key, value in self.__dict__.iteritems()]
14883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14884 
 
14885 
  def __eq__(self, other):
14886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14887 
 
14888 
  def __ne__(self, other):
14889 
    return not (self == other)
6039 amit.gupta 14890 
 
14891 
class getVatPercentageForItem_args:
14892 
  """
14893 
  Attributes:
14894 
   - itemId
7330 amit.gupta 14895 
   - stateId
6039 amit.gupta 14896 
   - price
14897 
  """
14898 
 
14899 
  thrift_spec = (
14900 
    None, # 0
14901 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 14902 
    (2, TType.I64, 'stateId', None, None, ), # 2
14903 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 14904 
  )
14905 
 
7330 amit.gupta 14906 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 14907 
    self.itemId = itemId
7330 amit.gupta 14908 
    self.stateId = stateId
6039 amit.gupta 14909 
    self.price = price
14910 
 
14911 
  def read(self, iprot):
14912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14914 
      return
14915 
    iprot.readStructBegin()
14916 
    while True:
14917 
      (fname, ftype, fid) = iprot.readFieldBegin()
14918 
      if ftype == TType.STOP:
14919 
        break
14920 
      if fid == 1:
14921 
        if ftype == TType.I64:
14922 
          self.itemId = iprot.readI64();
14923 
        else:
14924 
          iprot.skip(ftype)
14925 
      elif fid == 2:
7330 amit.gupta 14926 
        if ftype == TType.I64:
14927 
          self.stateId = iprot.readI64();
14928 
        else:
14929 
          iprot.skip(ftype)
14930 
      elif fid == 3:
6039 amit.gupta 14931 
        if ftype == TType.DOUBLE:
14932 
          self.price = iprot.readDouble();
14933 
        else:
14934 
          iprot.skip(ftype)
14935 
      else:
14936 
        iprot.skip(ftype)
14937 
      iprot.readFieldEnd()
14938 
    iprot.readStructEnd()
14939 
 
14940 
  def write(self, oprot):
14941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14943 
      return
14944 
    oprot.writeStructBegin('getVatPercentageForItem_args')
14945 
    if self.itemId is not None:
14946 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14947 
      oprot.writeI64(self.itemId)
14948 
      oprot.writeFieldEnd()
7330 amit.gupta 14949 
    if self.stateId is not None:
14950 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
14951 
      oprot.writeI64(self.stateId)
14952 
      oprot.writeFieldEnd()
6039 amit.gupta 14953 
    if self.price is not None:
7330 amit.gupta 14954 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 14955 
      oprot.writeDouble(self.price)
14956 
      oprot.writeFieldEnd()
14957 
    oprot.writeFieldStop()
14958 
    oprot.writeStructEnd()
14959 
 
14960 
  def validate(self):
14961 
    return
14962 
 
14963 
 
14964 
  def __repr__(self):
14965 
    L = ['%s=%r' % (key, value)
14966 
      for key, value in self.__dict__.iteritems()]
14967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14968 
 
14969 
  def __eq__(self, other):
14970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14971 
 
14972 
  def __ne__(self, other):
14973 
    return not (self == other)
14974 
 
14975 
class getVatPercentageForItem_result:
14976 
  """
14977 
  Attributes:
14978 
   - success
7340 amit.gupta 14979 
   - cex
6039 amit.gupta 14980 
  """
14981 
 
14982 
  thrift_spec = (
14983 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 14984 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 14985 
  )
14986 
 
7340 amit.gupta 14987 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 14988 
    self.success = success
7340 amit.gupta 14989 
    self.cex = cex
6039 amit.gupta 14990 
 
14991 
  def read(self, iprot):
14992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14994 
      return
14995 
    iprot.readStructBegin()
14996 
    while True:
14997 
      (fname, ftype, fid) = iprot.readFieldBegin()
14998 
      if ftype == TType.STOP:
14999 
        break
15000 
      if fid == 0:
15001 
        if ftype == TType.DOUBLE:
15002 
          self.success = iprot.readDouble();
15003 
        else:
15004 
          iprot.skip(ftype)
7340 amit.gupta 15005 
      elif fid == 1:
15006 
        if ftype == TType.STRUCT:
15007 
          self.cex = CatalogServiceException()
15008 
          self.cex.read(iprot)
15009 
        else:
15010 
          iprot.skip(ftype)
6039 amit.gupta 15011 
      else:
15012 
        iprot.skip(ftype)
15013 
      iprot.readFieldEnd()
15014 
    iprot.readStructEnd()
15015 
 
15016 
  def write(self, oprot):
15017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15019 
      return
15020 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15021 
    if self.success is not None:
15022 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15023 
      oprot.writeDouble(self.success)
15024 
      oprot.writeFieldEnd()
7340 amit.gupta 15025 
    if self.cex is not None:
15026 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15027 
      self.cex.write(oprot)
15028 
      oprot.writeFieldEnd()
6039 amit.gupta 15029 
    oprot.writeFieldStop()
15030 
    oprot.writeStructEnd()
15031 
 
15032 
  def validate(self):
15033 
    return
15034 
 
15035 
 
15036 
  def __repr__(self):
15037 
    L = ['%s=%r' % (key, value)
15038 
      for key, value in self.__dict__.iteritems()]
15039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15040 
 
15041 
  def __eq__(self, other):
15042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15043 
 
15044 
  def __ne__(self, other):
15045 
    return not (self == other)
15046 
 
15047 
class getVatAmountForItem_args:
15048 
  """
15049 
  Attributes:
15050 
   - itemId
15051 
   - price
15052 
  """
15053 
 
15054 
  thrift_spec = (
15055 
    None, # 0
15056 
    (1, TType.I64, 'itemId', None, None, ), # 1
15057 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15058 
  )
15059 
 
15060 
  def __init__(self, itemId=None, price=None,):
15061 
    self.itemId = itemId
15062 
    self.price = price
15063 
 
15064 
  def read(self, iprot):
15065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15067 
      return
15068 
    iprot.readStructBegin()
15069 
    while True:
15070 
      (fname, ftype, fid) = iprot.readFieldBegin()
15071 
      if ftype == TType.STOP:
15072 
        break
15073 
      if fid == 1:
15074 
        if ftype == TType.I64:
15075 
          self.itemId = iprot.readI64();
15076 
        else:
15077 
          iprot.skip(ftype)
15078 
      elif fid == 2:
15079 
        if ftype == TType.DOUBLE:
15080 
          self.price = iprot.readDouble();
15081 
        else:
15082 
          iprot.skip(ftype)
15083 
      else:
15084 
        iprot.skip(ftype)
15085 
      iprot.readFieldEnd()
15086 
    iprot.readStructEnd()
15087 
 
15088 
  def write(self, oprot):
15089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15091 
      return
15092 
    oprot.writeStructBegin('getVatAmountForItem_args')
15093 
    if self.itemId is not None:
15094 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15095 
      oprot.writeI64(self.itemId)
15096 
      oprot.writeFieldEnd()
15097 
    if self.price is not None:
15098 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15099 
      oprot.writeDouble(self.price)
15100 
      oprot.writeFieldEnd()
15101 
    oprot.writeFieldStop()
15102 
    oprot.writeStructEnd()
15103 
 
15104 
  def validate(self):
15105 
    return
15106 
 
15107 
 
15108 
  def __repr__(self):
15109 
    L = ['%s=%r' % (key, value)
15110 
      for key, value in self.__dict__.iteritems()]
15111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15112 
 
15113 
  def __eq__(self, other):
15114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15115 
 
15116 
  def __ne__(self, other):
15117 
    return not (self == other)
15118 
 
15119 
class getVatAmountForItem_result:
15120 
  """
15121 
  Attributes:
15122 
   - success
15123 
  """
15124 
 
15125 
  thrift_spec = (
15126 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15127 
  )
15128 
 
15129 
  def __init__(self, success=None,):
15130 
    self.success = success
15131 
 
15132 
  def read(self, iprot):
15133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15135 
      return
15136 
    iprot.readStructBegin()
15137 
    while True:
15138 
      (fname, ftype, fid) = iprot.readFieldBegin()
15139 
      if ftype == TType.STOP:
15140 
        break
15141 
      if fid == 0:
15142 
        if ftype == TType.DOUBLE:
15143 
          self.success = iprot.readDouble();
15144 
        else:
15145 
          iprot.skip(ftype)
15146 
      else:
15147 
        iprot.skip(ftype)
15148 
      iprot.readFieldEnd()
15149 
    iprot.readStructEnd()
15150 
 
15151 
  def write(self, oprot):
15152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15154 
      return
15155 
    oprot.writeStructBegin('getVatAmountForItem_result')
15156 
    if self.success is not None:
15157 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15158 
      oprot.writeDouble(self.success)
15159 
      oprot.writeFieldEnd()
15160 
    oprot.writeFieldStop()
15161 
    oprot.writeStructEnd()
15162 
 
15163 
  def validate(self):
15164 
    return
15165 
 
15166 
 
15167 
  def __repr__(self):
15168 
    L = ['%s=%r' % (key, value)
15169 
      for key, value in self.__dict__.iteritems()]
15170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15171 
 
15172 
  def __eq__(self, other):
15173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15174 
 
15175 
  def __ne__(self, other):
15176 
    return not (self == other)
6531 vikram.rag 15177 
 
15178 
class getAllIgnoredInventoryUpdateItemsList_args:
15179 
  """
15180 
  Attributes:
15181 
   - offset
15182 
   - limit
15183 
  """
15184 
 
15185 
  thrift_spec = (
15186 
    None, # 0
15187 
    (1, TType.I32, 'offset', None, None, ), # 1
15188 
    (2, TType.I32, 'limit', None, None, ), # 2
15189 
  )
15190 
 
15191 
  def __init__(self, offset=None, limit=None,):
15192 
    self.offset = offset
15193 
    self.limit = limit
15194 
 
15195 
  def read(self, iprot):
15196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15198 
      return
15199 
    iprot.readStructBegin()
15200 
    while True:
15201 
      (fname, ftype, fid) = iprot.readFieldBegin()
15202 
      if ftype == TType.STOP:
15203 
        break
15204 
      if fid == 1:
15205 
        if ftype == TType.I32:
15206 
          self.offset = iprot.readI32();
15207 
        else:
15208 
          iprot.skip(ftype)
15209 
      elif fid == 2:
15210 
        if ftype == TType.I32:
15211 
          self.limit = iprot.readI32();
15212 
        else:
15213 
          iprot.skip(ftype)
15214 
      else:
15215 
        iprot.skip(ftype)
15216 
      iprot.readFieldEnd()
15217 
    iprot.readStructEnd()
15218 
 
15219 
  def write(self, oprot):
15220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15222 
      return
15223 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15224 
    if self.offset is not None:
15225 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15226 
      oprot.writeI32(self.offset)
15227 
      oprot.writeFieldEnd()
15228 
    if self.limit is not None:
15229 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15230 
      oprot.writeI32(self.limit)
15231 
      oprot.writeFieldEnd()
15232 
    oprot.writeFieldStop()
15233 
    oprot.writeStructEnd()
15234 
 
15235 
  def validate(self):
15236 
    return
15237 
 
15238 
 
15239 
  def __repr__(self):
15240 
    L = ['%s=%r' % (key, value)
15241 
      for key, value in self.__dict__.iteritems()]
15242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15243 
 
15244 
  def __eq__(self, other):
15245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15246 
 
15247 
  def __ne__(self, other):
15248 
    return not (self == other)
15249 
 
15250 
class getAllIgnoredInventoryUpdateItemsList_result:
15251 
  """
15252 
  Attributes:
15253 
   - success
15254 
  """
15255 
 
15256 
  thrift_spec = (
15257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15258 
  )
15259 
 
15260 
  def __init__(self, success=None,):
15261 
    self.success = success
15262 
 
15263 
  def read(self, iprot):
15264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15266 
      return
15267 
    iprot.readStructBegin()
15268 
    while True:
15269 
      (fname, ftype, fid) = iprot.readFieldBegin()
15270 
      if ftype == TType.STOP:
15271 
        break
15272 
      if fid == 0:
15273 
        if ftype == TType.LIST:
15274 
          self.success = []
7256 rajveer 15275 
          (_etype280, _size277) = iprot.readListBegin()
15276 
          for _i281 in xrange(_size277):
15277 
            _elem282 = Item()
15278 
            _elem282.read(iprot)
15279 
            self.success.append(_elem282)
6531 vikram.rag 15280 
          iprot.readListEnd()
15281 
        else:
15282 
          iprot.skip(ftype)
15283 
      else:
15284 
        iprot.skip(ftype)
15285 
      iprot.readFieldEnd()
15286 
    iprot.readStructEnd()
15287 
 
15288 
  def write(self, oprot):
15289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15291 
      return
15292 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15293 
    if self.success is not None:
15294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15295 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15296 
      for iter283 in self.success:
15297 
        iter283.write(oprot)
6531 vikram.rag 15298 
      oprot.writeListEnd()
15299 
      oprot.writeFieldEnd()
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)
6805 anupam.sin 15317 
 
6821 amar.kumar 15318 
class getAllAliveItems_args:
15319 
 
15320 
  thrift_spec = (
15321 
  )
15322 
 
15323 
  def read(self, iprot):
15324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15326 
      return
15327 
    iprot.readStructBegin()
15328 
    while True:
15329 
      (fname, ftype, fid) = iprot.readFieldBegin()
15330 
      if ftype == TType.STOP:
15331 
        break
15332 
      else:
15333 
        iprot.skip(ftype)
15334 
      iprot.readFieldEnd()
15335 
    iprot.readStructEnd()
15336 
 
15337 
  def write(self, oprot):
15338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15340 
      return
15341 
    oprot.writeStructBegin('getAllAliveItems_args')
15342 
    oprot.writeFieldStop()
15343 
    oprot.writeStructEnd()
15344 
 
15345 
  def validate(self):
15346 
    return
15347 
 
15348 
 
15349 
  def __repr__(self):
15350 
    L = ['%s=%r' % (key, value)
15351 
      for key, value in self.__dict__.iteritems()]
15352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15353 
 
15354 
  def __eq__(self, other):
15355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15356 
 
15357 
  def __ne__(self, other):
15358 
    return not (self == other)
15359 
 
15360 
class getAllAliveItems_result:
15361 
  """
15362 
  Attributes:
15363 
   - success
15364 
  """
15365 
 
15366 
  thrift_spec = (
15367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15368 
  )
15369 
 
15370 
  def __init__(self, success=None,):
15371 
    self.success = success
15372 
 
15373 
  def read(self, iprot):
15374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15376 
      return
15377 
    iprot.readStructBegin()
15378 
    while True:
15379 
      (fname, ftype, fid) = iprot.readFieldBegin()
15380 
      if ftype == TType.STOP:
15381 
        break
15382 
      if fid == 0:
15383 
        if ftype == TType.LIST:
15384 
          self.success = []
7256 rajveer 15385 
          (_etype287, _size284) = iprot.readListBegin()
15386 
          for _i288 in xrange(_size284):
15387 
            _elem289 = Item()
15388 
            _elem289.read(iprot)
15389 
            self.success.append(_elem289)
6821 amar.kumar 15390 
          iprot.readListEnd()
15391 
        else:
15392 
          iprot.skip(ftype)
15393 
      else:
15394 
        iprot.skip(ftype)
15395 
      iprot.readFieldEnd()
15396 
    iprot.readStructEnd()
15397 
 
15398 
  def write(self, oprot):
15399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15401 
      return
15402 
    oprot.writeStructBegin('getAllAliveItems_result')
15403 
    if self.success is not None:
15404 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15405 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15406 
      for iter290 in self.success:
15407 
        iter290.write(oprot)
6821 amar.kumar 15408 
      oprot.writeListEnd()
15409 
      oprot.writeFieldEnd()
15410 
    oprot.writeFieldStop()
15411 
    oprot.writeStructEnd()
15412 
 
15413 
  def validate(self):
15414 
    return
15415 
 
15416 
 
15417 
  def __repr__(self):
15418 
    L = ['%s=%r' % (key, value)
15419 
      for key, value in self.__dict__.iteritems()]
15420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15421 
 
15422 
  def __eq__(self, other):
15423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15424 
 
15425 
  def __ne__(self, other):
15426 
    return not (self == other)
15427 
 
6805 anupam.sin 15428 
class getInsuranceAmount_args:
15429 
  """
15430 
  Attributes:
15431 
   - itemId
6921 anupam.sin 15432 
   - price
6805 anupam.sin 15433 
   - insurerId
15434 
   - quantity
15435 
  """
15436 
 
15437 
  thrift_spec = (
15438 
    None, # 0
15439 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15440 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15441 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15442 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15443 
  )
15444 
 
6921 anupam.sin 15445 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15446 
    self.itemId = itemId
6921 anupam.sin 15447 
    self.price = price
6805 anupam.sin 15448 
    self.insurerId = insurerId
15449 
    self.quantity = quantity
15450 
 
15451 
  def read(self, iprot):
15452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15454 
      return
15455 
    iprot.readStructBegin()
15456 
    while True:
15457 
      (fname, ftype, fid) = iprot.readFieldBegin()
15458 
      if ftype == TType.STOP:
15459 
        break
15460 
      if fid == 1:
15461 
        if ftype == TType.I64:
15462 
          self.itemId = iprot.readI64();
15463 
        else:
15464 
          iprot.skip(ftype)
15465 
      elif fid == 2:
6921 anupam.sin 15466 
        if ftype == TType.DOUBLE:
15467 
          self.price = iprot.readDouble();
15468 
        else:
15469 
          iprot.skip(ftype)
15470 
      elif fid == 3:
6805 anupam.sin 15471 
        if ftype == TType.I64:
15472 
          self.insurerId = iprot.readI64();
15473 
        else:
15474 
          iprot.skip(ftype)
6921 anupam.sin 15475 
      elif fid == 4:
6805 anupam.sin 15476 
        if ftype == TType.I64:
15477 
          self.quantity = iprot.readI64();
15478 
        else:
15479 
          iprot.skip(ftype)
15480 
      else:
15481 
        iprot.skip(ftype)
15482 
      iprot.readFieldEnd()
15483 
    iprot.readStructEnd()
15484 
 
15485 
  def write(self, oprot):
15486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15488 
      return
15489 
    oprot.writeStructBegin('getInsuranceAmount_args')
15490 
    if self.itemId is not None:
15491 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15492 
      oprot.writeI64(self.itemId)
15493 
      oprot.writeFieldEnd()
6921 anupam.sin 15494 
    if self.price is not None:
15495 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15496 
      oprot.writeDouble(self.price)
15497 
      oprot.writeFieldEnd()
6805 anupam.sin 15498 
    if self.insurerId is not None:
6921 anupam.sin 15499 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15500 
      oprot.writeI64(self.insurerId)
15501 
      oprot.writeFieldEnd()
15502 
    if self.quantity is not None:
6921 anupam.sin 15503 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15504 
      oprot.writeI64(self.quantity)
15505 
      oprot.writeFieldEnd()
15506 
    oprot.writeFieldStop()
15507 
    oprot.writeStructEnd()
15508 
 
15509 
  def validate(self):
15510 
    return
15511 
 
15512 
 
15513 
  def __repr__(self):
15514 
    L = ['%s=%r' % (key, value)
15515 
      for key, value in self.__dict__.iteritems()]
15516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15517 
 
15518 
  def __eq__(self, other):
15519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15520 
 
15521 
  def __ne__(self, other):
15522 
    return not (self == other)
15523 
 
15524 
class getInsuranceAmount_result:
15525 
  """
15526 
  Attributes:
15527 
   - success
15528 
  """
15529 
 
15530 
  thrift_spec = (
15531 
    (0, TType.I64, 'success', None, None, ), # 0
15532 
  )
15533 
 
15534 
  def __init__(self, success=None,):
15535 
    self.success = success
15536 
 
15537 
  def read(self, iprot):
15538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15540 
      return
15541 
    iprot.readStructBegin()
15542 
    while True:
15543 
      (fname, ftype, fid) = iprot.readFieldBegin()
15544 
      if ftype == TType.STOP:
15545 
        break
15546 
      if fid == 0:
15547 
        if ftype == TType.I64:
15548 
          self.success = iprot.readI64();
15549 
        else:
15550 
          iprot.skip(ftype)
15551 
      else:
15552 
        iprot.skip(ftype)
15553 
      iprot.readFieldEnd()
15554 
    iprot.readStructEnd()
15555 
 
15556 
  def write(self, oprot):
15557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15559 
      return
15560 
    oprot.writeStructBegin('getInsuranceAmount_result')
15561 
    if self.success is not None:
15562 
      oprot.writeFieldBegin('success', TType.I64, 0)
15563 
      oprot.writeI64(self.success)
15564 
      oprot.writeFieldEnd()
15565 
    oprot.writeFieldStop()
15566 
    oprot.writeStructEnd()
15567 
 
15568 
  def validate(self):
15569 
    return
15570 
 
15571 
 
15572 
  def __repr__(self):
15573 
    L = ['%s=%r' % (key, value)
15574 
      for key, value in self.__dict__.iteritems()]
15575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15576 
 
15577 
  def __eq__(self, other):
15578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15579 
 
15580 
  def __ne__(self, other):
15581 
    return not (self == other)
15582 
 
15583 
class getInsurer_args:
15584 
  """
15585 
  Attributes:
15586 
   - insurerId
15587 
  """
15588 
 
15589 
  thrift_spec = (
15590 
    None, # 0
15591 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15592 
  )
15593 
 
15594 
  def __init__(self, insurerId=None,):
15595 
    self.insurerId = insurerId
15596 
 
15597 
  def read(self, iprot):
15598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15600 
      return
15601 
    iprot.readStructBegin()
15602 
    while True:
15603 
      (fname, ftype, fid) = iprot.readFieldBegin()
15604 
      if ftype == TType.STOP:
15605 
        break
15606 
      if fid == 1:
15607 
        if ftype == TType.I64:
15608 
          self.insurerId = iprot.readI64();
15609 
        else:
15610 
          iprot.skip(ftype)
15611 
      else:
15612 
        iprot.skip(ftype)
15613 
      iprot.readFieldEnd()
15614 
    iprot.readStructEnd()
15615 
 
15616 
  def write(self, oprot):
15617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15619 
      return
15620 
    oprot.writeStructBegin('getInsurer_args')
15621 
    if self.insurerId is not None:
15622 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15623 
      oprot.writeI64(self.insurerId)
15624 
      oprot.writeFieldEnd()
15625 
    oprot.writeFieldStop()
15626 
    oprot.writeStructEnd()
15627 
 
15628 
  def validate(self):
15629 
    return
15630 
 
15631 
 
15632 
  def __repr__(self):
15633 
    L = ['%s=%r' % (key, value)
15634 
      for key, value in self.__dict__.iteritems()]
15635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15636 
 
15637 
  def __eq__(self, other):
15638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15639 
 
15640 
  def __ne__(self, other):
15641 
    return not (self == other)
15642 
 
15643 
class getInsurer_result:
15644 
  """
15645 
  Attributes:
15646 
   - success
15647 
  """
15648 
 
15649 
  thrift_spec = (
15650 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15651 
  )
15652 
 
15653 
  def __init__(self, success=None,):
15654 
    self.success = success
15655 
 
15656 
  def read(self, iprot):
15657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15659 
      return
15660 
    iprot.readStructBegin()
15661 
    while True:
15662 
      (fname, ftype, fid) = iprot.readFieldBegin()
15663 
      if ftype == TType.STOP:
15664 
        break
15665 
      if fid == 0:
15666 
        if ftype == TType.STRUCT:
15667 
          self.success = Insurer()
15668 
          self.success.read(iprot)
15669 
        else:
15670 
          iprot.skip(ftype)
15671 
      else:
15672 
        iprot.skip(ftype)
15673 
      iprot.readFieldEnd()
15674 
    iprot.readStructEnd()
15675 
 
15676 
  def write(self, oprot):
15677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15679 
      return
15680 
    oprot.writeStructBegin('getInsurer_result')
15681 
    if self.success is not None:
15682 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15683 
      self.success.write(oprot)
15684 
      oprot.writeFieldEnd()
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)
6838 vikram.rag 15702 
 
15703 
class getAllInsurers_args:
15704 
 
15705 
  thrift_spec = (
15706 
  )
15707 
 
15708 
  def read(self, iprot):
15709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15711 
      return
15712 
    iprot.readStructBegin()
15713 
    while True:
15714 
      (fname, ftype, fid) = iprot.readFieldBegin()
15715 
      if ftype == TType.STOP:
15716 
        break
15717 
      else:
15718 
        iprot.skip(ftype)
15719 
      iprot.readFieldEnd()
15720 
    iprot.readStructEnd()
15721 
 
15722 
  def write(self, oprot):
15723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15725 
      return
15726 
    oprot.writeStructBegin('getAllInsurers_args')
15727 
    oprot.writeFieldStop()
15728 
    oprot.writeStructEnd()
15729 
 
15730 
  def validate(self):
15731 
    return
15732 
 
15733 
 
15734 
  def __repr__(self):
15735 
    L = ['%s=%r' % (key, value)
15736 
      for key, value in self.__dict__.iteritems()]
15737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15738 
 
15739 
  def __eq__(self, other):
15740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15741 
 
15742 
  def __ne__(self, other):
15743 
    return not (self == other)
15744 
 
15745 
class getAllInsurers_result:
15746 
  """
15747 
  Attributes:
15748 
   - success
15749 
  """
15750 
 
15751 
  thrift_spec = (
15752 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15753 
  )
15754 
 
15755 
  def __init__(self, success=None,):
15756 
    self.success = success
15757 
 
15758 
  def read(self, iprot):
15759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15761 
      return
15762 
    iprot.readStructBegin()
15763 
    while True:
15764 
      (fname, ftype, fid) = iprot.readFieldBegin()
15765 
      if ftype == TType.STOP:
15766 
        break
15767 
      if fid == 0:
15768 
        if ftype == TType.LIST:
15769 
          self.success = []
7256 rajveer 15770 
          (_etype294, _size291) = iprot.readListBegin()
15771 
          for _i295 in xrange(_size291):
15772 
            _elem296 = Insurer()
15773 
            _elem296.read(iprot)
15774 
            self.success.append(_elem296)
6838 vikram.rag 15775 
          iprot.readListEnd()
15776 
        else:
15777 
          iprot.skip(ftype)
15778 
      else:
15779 
        iprot.skip(ftype)
15780 
      iprot.readFieldEnd()
15781 
    iprot.readStructEnd()
15782 
 
15783 
  def write(self, oprot):
15784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15786 
      return
15787 
    oprot.writeStructBegin('getAllInsurers_result')
15788 
    if self.success is not None:
15789 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15790 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15791 
      for iter297 in self.success:
15792 
        iter297.write(oprot)
6838 vikram.rag 15793 
      oprot.writeListEnd()
15794 
      oprot.writeFieldEnd()
15795 
    oprot.writeFieldStop()
15796 
    oprot.writeStructEnd()
15797 
 
15798 
  def validate(self):
15799 
    return
15800 
 
15801 
 
15802 
  def __repr__(self):
15803 
    L = ['%s=%r' % (key, value)
15804 
      for key, value in self.__dict__.iteritems()]
15805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15806 
 
15807 
  def __eq__(self, other):
15808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15809 
 
15810 
  def __ne__(self, other):
15811 
    return not (self == other)
6962 rajveer 15812 
 
15813 
class updateInsuranceDeclaredAmount_args:
15814 
  """
15815 
  Attributes:
15816 
   - insurerId
15817 
   - amount
15818 
  """
15819 
 
15820 
  thrift_spec = (
15821 
    None, # 0
15822 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15823 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
15824 
  )
15825 
 
15826 
  def __init__(self, insurerId=None, amount=None,):
15827 
    self.insurerId = insurerId
15828 
    self.amount = amount
15829 
 
15830 
  def read(self, iprot):
15831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15833 
      return
15834 
    iprot.readStructBegin()
15835 
    while True:
15836 
      (fname, ftype, fid) = iprot.readFieldBegin()
15837 
      if ftype == TType.STOP:
15838 
        break
15839 
      if fid == 1:
15840 
        if ftype == TType.I64:
15841 
          self.insurerId = iprot.readI64();
15842 
        else:
15843 
          iprot.skip(ftype)
15844 
      elif fid == 2:
15845 
        if ftype == TType.DOUBLE:
15846 
          self.amount = iprot.readDouble();
15847 
        else:
15848 
          iprot.skip(ftype)
15849 
      else:
15850 
        iprot.skip(ftype)
15851 
      iprot.readFieldEnd()
15852 
    iprot.readStructEnd()
15853 
 
15854 
  def write(self, oprot):
15855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15857 
      return
15858 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
15859 
    if self.insurerId is not None:
15860 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15861 
      oprot.writeI64(self.insurerId)
15862 
      oprot.writeFieldEnd()
15863 
    if self.amount is not None:
15864 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
15865 
      oprot.writeDouble(self.amount)
15866 
      oprot.writeFieldEnd()
15867 
    oprot.writeFieldStop()
15868 
    oprot.writeStructEnd()
15869 
 
15870 
  def validate(self):
15871 
    return
15872 
 
15873 
 
15874 
  def __repr__(self):
15875 
    L = ['%s=%r' % (key, value)
15876 
      for key, value in self.__dict__.iteritems()]
15877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15878 
 
15879 
  def __eq__(self, other):
15880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15881 
 
15882 
  def __ne__(self, other):
15883 
    return not (self == other)
15884 
 
15885 
class updateInsuranceDeclaredAmount_result:
15886 
 
15887 
  thrift_spec = (
15888 
  )
15889 
 
15890 
  def read(self, iprot):
15891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15893 
      return
15894 
    iprot.readStructBegin()
15895 
    while True:
15896 
      (fname, ftype, fid) = iprot.readFieldBegin()
15897 
      if ftype == TType.STOP:
15898 
        break
15899 
      else:
15900 
        iprot.skip(ftype)
15901 
      iprot.readFieldEnd()
15902 
    iprot.readStructEnd()
15903 
 
15904 
  def write(self, oprot):
15905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15907 
      return
15908 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
15909 
    oprot.writeFieldStop()
15910 
    oprot.writeStructEnd()
15911 
 
15912 
  def validate(self):
15913 
    return
15914 
 
15915 
 
15916 
  def __repr__(self):
15917 
    L = ['%s=%r' % (key, value)
15918 
      for key, value in self.__dict__.iteritems()]
15919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15920 
 
15921 
  def __eq__(self, other):
15922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15923 
 
15924 
  def __ne__(self, other):
15925 
    return not (self == other)
7190 amar.kumar 15926 
 
15927 
class getFreebieForItem_args:
15928 
  """
15929 
  Attributes:
15930 
   - itemId
15931 
  """
15932 
 
15933 
  thrift_spec = (
15934 
    None, # 0
15935 
    (1, TType.I64, 'itemId', None, None, ), # 1
15936 
  )
15937 
 
15938 
  def __init__(self, itemId=None,):
15939 
    self.itemId = itemId
15940 
 
15941 
  def read(self, iprot):
15942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15944 
      return
15945 
    iprot.readStructBegin()
15946 
    while True:
15947 
      (fname, ftype, fid) = iprot.readFieldBegin()
15948 
      if ftype == TType.STOP:
15949 
        break
15950 
      if fid == 1:
15951 
        if ftype == TType.I64:
15952 
          self.itemId = iprot.readI64();
15953 
        else:
15954 
          iprot.skip(ftype)
15955 
      else:
15956 
        iprot.skip(ftype)
15957 
      iprot.readFieldEnd()
15958 
    iprot.readStructEnd()
15959 
 
15960 
  def write(self, oprot):
15961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15963 
      return
15964 
    oprot.writeStructBegin('getFreebieForItem_args')
15965 
    if self.itemId is not None:
15966 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15967 
      oprot.writeI64(self.itemId)
15968 
      oprot.writeFieldEnd()
15969 
    oprot.writeFieldStop()
15970 
    oprot.writeStructEnd()
15971 
 
15972 
  def validate(self):
15973 
    return
15974 
 
15975 
 
15976 
  def __repr__(self):
15977 
    L = ['%s=%r' % (key, value)
15978 
      for key, value in self.__dict__.iteritems()]
15979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15980 
 
15981 
  def __eq__(self, other):
15982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15983 
 
15984 
  def __ne__(self, other):
15985 
    return not (self == other)
15986 
 
15987 
class getFreebieForItem_result:
15988 
  """
15989 
  Attributes:
15990 
   - success
15991 
  """
15992 
 
15993 
  thrift_spec = (
15994 
    (0, TType.I64, 'success', None, None, ), # 0
15995 
  )
15996 
 
15997 
  def __init__(self, success=None,):
15998 
    self.success = success
15999 
 
16000 
  def read(self, iprot):
16001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16003 
      return
16004 
    iprot.readStructBegin()
16005 
    while True:
16006 
      (fname, ftype, fid) = iprot.readFieldBegin()
16007 
      if ftype == TType.STOP:
16008 
        break
16009 
      if fid == 0:
16010 
        if ftype == TType.I64:
16011 
          self.success = iprot.readI64();
16012 
        else:
16013 
          iprot.skip(ftype)
16014 
      else:
16015 
        iprot.skip(ftype)
16016 
      iprot.readFieldEnd()
16017 
    iprot.readStructEnd()
16018 
 
16019 
  def write(self, oprot):
16020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16022 
      return
16023 
    oprot.writeStructBegin('getFreebieForItem_result')
16024 
    if self.success is not None:
16025 
      oprot.writeFieldBegin('success', TType.I64, 0)
16026 
      oprot.writeI64(self.success)
16027 
      oprot.writeFieldEnd()
16028 
    oprot.writeFieldStop()
16029 
    oprot.writeStructEnd()
16030 
 
16031 
  def validate(self):
16032 
    return
16033 
 
16034 
 
16035 
  def __repr__(self):
16036 
    L = ['%s=%r' % (key, value)
16037 
      for key, value in self.__dict__.iteritems()]
16038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16039 
 
16040 
  def __eq__(self, other):
16041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16042 
 
16043 
  def __ne__(self, other):
16044 
    return not (self == other)
16045 
 
16046 
class addOrUpdateFreebieForItem_args:
16047 
  """
16048 
  Attributes:
16049 
   - freebieItem
16050 
  """
16051 
 
16052 
  thrift_spec = (
16053 
    None, # 0
16054 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16055 
  )
16056 
 
16057 
  def __init__(self, freebieItem=None,):
16058 
    self.freebieItem = freebieItem
16059 
 
16060 
  def read(self, iprot):
16061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16063 
      return
16064 
    iprot.readStructBegin()
16065 
    while True:
16066 
      (fname, ftype, fid) = iprot.readFieldBegin()
16067 
      if ftype == TType.STOP:
16068 
        break
16069 
      if fid == 1:
16070 
        if ftype == TType.STRUCT:
16071 
          self.freebieItem = FreebieItem()
16072 
          self.freebieItem.read(iprot)
16073 
        else:
16074 
          iprot.skip(ftype)
16075 
      else:
16076 
        iprot.skip(ftype)
16077 
      iprot.readFieldEnd()
16078 
    iprot.readStructEnd()
16079 
 
16080 
  def write(self, oprot):
16081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16083 
      return
16084 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16085 
    if self.freebieItem is not None:
16086 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16087 
      self.freebieItem.write(oprot)
16088 
      oprot.writeFieldEnd()
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)
16106 
 
16107 
class addOrUpdateFreebieForItem_result:
16108 
 
16109 
  thrift_spec = (
16110 
  )
16111 
 
16112 
  def read(self, iprot):
16113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16115 
      return
16116 
    iprot.readStructBegin()
16117 
    while True:
16118 
      (fname, ftype, fid) = iprot.readFieldBegin()
16119 
      if ftype == TType.STOP:
16120 
        break
16121 
      else:
16122 
        iprot.skip(ftype)
16123 
      iprot.readFieldEnd()
16124 
    iprot.readStructEnd()
16125 
 
16126 
  def write(self, oprot):
16127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16129 
      return
16130 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16131 
    oprot.writeFieldStop()
16132 
    oprot.writeStructEnd()
16133 
 
16134 
  def validate(self):
16135 
    return
16136 
 
16137 
 
16138 
  def __repr__(self):
16139 
    L = ['%s=%r' % (key, value)
16140 
      for key, value in self.__dict__.iteritems()]
16141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16142 
 
16143 
  def __eq__(self, other):
16144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16145 
 
16146 
  def __ne__(self, other):
16147 
    return not (self == other)
7256 rajveer 16148 
 
7272 amit.gupta 16149 
class addOrUpdateBrandInfo_args:
16150 
  """
16151 
  Attributes:
16152 
   - brandInfo
16153 
  """
16154 
 
16155 
  thrift_spec = (
16156 
    None, # 0
16157 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16158 
  )
16159 
 
16160 
  def __init__(self, brandInfo=None,):
16161 
    self.brandInfo = brandInfo
16162 
 
16163 
  def read(self, iprot):
16164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16166 
      return
16167 
    iprot.readStructBegin()
16168 
    while True:
16169 
      (fname, ftype, fid) = iprot.readFieldBegin()
16170 
      if ftype == TType.STOP:
16171 
        break
16172 
      if fid == 1:
16173 
        if ftype == TType.STRUCT:
16174 
          self.brandInfo = BrandInfo()
16175 
          self.brandInfo.read(iprot)
16176 
        else:
16177 
          iprot.skip(ftype)
16178 
      else:
16179 
        iprot.skip(ftype)
16180 
      iprot.readFieldEnd()
16181 
    iprot.readStructEnd()
16182 
 
16183 
  def write(self, oprot):
16184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16186 
      return
16187 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16188 
    if self.brandInfo is not None:
16189 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16190 
      self.brandInfo.write(oprot)
16191 
      oprot.writeFieldEnd()
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 addOrUpdateBrandInfo_result:
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('addOrUpdateBrandInfo_result')
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_args:
16253 
 
16254 
  thrift_spec = (
16255 
  )
16256 
 
16257 
  def read(self, iprot):
16258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16260 
      return
16261 
    iprot.readStructBegin()
16262 
    while True:
16263 
      (fname, ftype, fid) = iprot.readFieldBegin()
16264 
      if ftype == TType.STOP:
16265 
        break
16266 
      else:
16267 
        iprot.skip(ftype)
16268 
      iprot.readFieldEnd()
16269 
    iprot.readStructEnd()
16270 
 
16271 
  def write(self, oprot):
16272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16274 
      return
16275 
    oprot.writeStructBegin('getBrandInfo_args')
16276 
    oprot.writeFieldStop()
16277 
    oprot.writeStructEnd()
16278 
 
16279 
  def validate(self):
16280 
    return
16281 
 
16282 
 
16283 
  def __repr__(self):
16284 
    L = ['%s=%r' % (key, value)
16285 
      for key, value in self.__dict__.iteritems()]
16286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16287 
 
16288 
  def __eq__(self, other):
16289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16290 
 
16291 
  def __ne__(self, other):
16292 
    return not (self == other)
16293 
 
16294 
class getBrandInfo_result:
16295 
  """
16296 
  Attributes:
16297 
   - success
16298 
  """
16299 
 
16300 
  thrift_spec = (
16301 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16302 
  )
16303 
 
16304 
  def __init__(self, success=None,):
16305 
    self.success = success
16306 
 
16307 
  def read(self, iprot):
16308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16310 
      return
16311 
    iprot.readStructBegin()
16312 
    while True:
16313 
      (fname, ftype, fid) = iprot.readFieldBegin()
16314 
      if ftype == TType.STOP:
16315 
        break
16316 
      if fid == 0:
16317 
        if ftype == TType.MAP:
16318 
          self.success = {}
16319 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
16320 
          for _i302 in xrange(_size298):
16321 
            _key303 = iprot.readString();
16322 
            _val304 = BrandInfo()
16323 
            _val304.read(iprot)
16324 
            self.success[_key303] = _val304
16325 
          iprot.readMapEnd()
16326 
        else:
16327 
          iprot.skip(ftype)
16328 
      else:
16329 
        iprot.skip(ftype)
16330 
      iprot.readFieldEnd()
16331 
    iprot.readStructEnd()
16332 
 
16333 
  def write(self, oprot):
16334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16336 
      return
16337 
    oprot.writeStructBegin('getBrandInfo_result')
16338 
    if self.success is not None:
16339 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16340 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
16341 
      for kiter305,viter306 in self.success.items():
16342 
        oprot.writeString(kiter305)
16343 
        viter306.write(oprot)
16344 
      oprot.writeMapEnd()
16345 
      oprot.writeFieldEnd()
16346 
    oprot.writeFieldStop()
16347 
    oprot.writeStructEnd()
16348 
 
16349 
  def validate(self):
16350 
    return
16351 
 
16352 
 
16353 
  def __repr__(self):
16354 
    L = ['%s=%r' % (key, value)
16355 
      for key, value in self.__dict__.iteritems()]
16356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16357 
 
16358 
  def __eq__(self, other):
16359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16360 
 
16361 
  def __ne__(self, other):
16362 
    return not (self == other)
16363 
 
7256 rajveer 16364 
class getStorePricing_args:
16365 
  """
16366 
  Attributes:
16367 
   - itemId
16368 
  """
16369 
 
16370 
  thrift_spec = (
16371 
    None, # 0
16372 
    (1, TType.I64, 'itemId', None, None, ), # 1
16373 
  )
16374 
 
16375 
  def __init__(self, itemId=None,):
16376 
    self.itemId = itemId
16377 
 
16378 
  def read(self, iprot):
16379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16381 
      return
16382 
    iprot.readStructBegin()
16383 
    while True:
16384 
      (fname, ftype, fid) = iprot.readFieldBegin()
16385 
      if ftype == TType.STOP:
16386 
        break
16387 
      if fid == 1:
16388 
        if ftype == TType.I64:
16389 
          self.itemId = iprot.readI64();
16390 
        else:
16391 
          iprot.skip(ftype)
16392 
      else:
16393 
        iprot.skip(ftype)
16394 
      iprot.readFieldEnd()
16395 
    iprot.readStructEnd()
16396 
 
16397 
  def write(self, oprot):
16398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16400 
      return
16401 
    oprot.writeStructBegin('getStorePricing_args')
16402 
    if self.itemId is not None:
16403 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16404 
      oprot.writeI64(self.itemId)
16405 
      oprot.writeFieldEnd()
16406 
    oprot.writeFieldStop()
16407 
    oprot.writeStructEnd()
16408 
 
16409 
  def validate(self):
16410 
    return
16411 
 
16412 
 
16413 
  def __repr__(self):
16414 
    L = ['%s=%r' % (key, value)
16415 
      for key, value in self.__dict__.iteritems()]
16416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16417 
 
16418 
  def __eq__(self, other):
16419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16420 
 
16421 
  def __ne__(self, other):
16422 
    return not (self == other)
16423 
 
16424 
class getStorePricing_result:
16425 
  """
16426 
  Attributes:
16427 
   - success
16428 
  """
16429 
 
16430 
  thrift_spec = (
16431 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16432 
  )
16433 
 
16434 
  def __init__(self, success=None,):
16435 
    self.success = success
16436 
 
16437 
  def read(self, iprot):
16438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16440 
      return
16441 
    iprot.readStructBegin()
16442 
    while True:
16443 
      (fname, ftype, fid) = iprot.readFieldBegin()
16444 
      if ftype == TType.STOP:
16445 
        break
16446 
      if fid == 0:
16447 
        if ftype == TType.STRUCT:
16448 
          self.success = StorePricing()
16449 
          self.success.read(iprot)
16450 
        else:
16451 
          iprot.skip(ftype)
16452 
      else:
16453 
        iprot.skip(ftype)
16454 
      iprot.readFieldEnd()
16455 
    iprot.readStructEnd()
16456 
 
16457 
  def write(self, oprot):
16458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16460 
      return
16461 
    oprot.writeStructBegin('getStorePricing_result')
16462 
    if self.success is not None:
16463 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16464 
      self.success.write(oprot)
16465 
      oprot.writeFieldEnd()
16466 
    oprot.writeFieldStop()
16467 
    oprot.writeStructEnd()
16468 
 
16469 
  def validate(self):
16470 
    return
16471 
 
16472 
 
16473 
  def __repr__(self):
16474 
    L = ['%s=%r' % (key, value)
16475 
      for key, value in self.__dict__.iteritems()]
16476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16477 
 
16478 
  def __eq__(self, other):
16479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16480 
 
16481 
  def __ne__(self, other):
16482 
    return not (self == other)
7265 rajveer 16483 
 
7306 rajveer 16484 
class getStorePricings_args:
16485 
  """
16486 
  Attributes:
16487 
   - itemIds
16488 
  """
16489 
 
16490 
  thrift_spec = (
16491 
    None, # 0
16492 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16493 
  )
16494 
 
16495 
  def __init__(self, itemIds=None,):
16496 
    self.itemIds = itemIds
16497 
 
16498 
  def read(self, iprot):
16499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16501 
      return
16502 
    iprot.readStructBegin()
16503 
    while True:
16504 
      (fname, ftype, fid) = iprot.readFieldBegin()
16505 
      if ftype == TType.STOP:
16506 
        break
16507 
      if fid == 1:
16508 
        if ftype == TType.LIST:
16509 
          self.itemIds = []
16510 
          (_etype310, _size307) = iprot.readListBegin()
16511 
          for _i311 in xrange(_size307):
16512 
            _elem312 = iprot.readI64();
16513 
            self.itemIds.append(_elem312)
16514 
          iprot.readListEnd()
16515 
        else:
16516 
          iprot.skip(ftype)
16517 
      else:
16518 
        iprot.skip(ftype)
16519 
      iprot.readFieldEnd()
16520 
    iprot.readStructEnd()
16521 
 
16522 
  def write(self, oprot):
16523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16525 
      return
16526 
    oprot.writeStructBegin('getStorePricings_args')
16527 
    if self.itemIds is not None:
16528 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16529 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
16530 
      for iter313 in self.itemIds:
16531 
        oprot.writeI64(iter313)
16532 
      oprot.writeListEnd()
16533 
      oprot.writeFieldEnd()
16534 
    oprot.writeFieldStop()
16535 
    oprot.writeStructEnd()
16536 
 
16537 
  def validate(self):
16538 
    return
16539 
 
16540 
 
16541 
  def __repr__(self):
16542 
    L = ['%s=%r' % (key, value)
16543 
      for key, value in self.__dict__.iteritems()]
16544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16545 
 
16546 
  def __eq__(self, other):
16547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16548 
 
16549 
  def __ne__(self, other):
16550 
    return not (self == other)
16551 
 
16552 
class getStorePricings_result:
16553 
  """
16554 
  Attributes:
16555 
   - success
16556 
  """
16557 
 
16558 
  thrift_spec = (
16559 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16560 
  )
16561 
 
16562 
  def __init__(self, success=None,):
16563 
    self.success = success
16564 
 
16565 
  def read(self, iprot):
16566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16568 
      return
16569 
    iprot.readStructBegin()
16570 
    while True:
16571 
      (fname, ftype, fid) = iprot.readFieldBegin()
16572 
      if ftype == TType.STOP:
16573 
        break
16574 
      if fid == 0:
16575 
        if ftype == TType.LIST:
16576 
          self.success = []
16577 
          (_etype317, _size314) = iprot.readListBegin()
16578 
          for _i318 in xrange(_size314):
16579 
            _elem319 = StorePricing()
16580 
            _elem319.read(iprot)
16581 
            self.success.append(_elem319)
16582 
          iprot.readListEnd()
16583 
        else:
16584 
          iprot.skip(ftype)
16585 
      else:
16586 
        iprot.skip(ftype)
16587 
      iprot.readFieldEnd()
16588 
    iprot.readStructEnd()
16589 
 
16590 
  def write(self, oprot):
16591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16593 
      return
16594 
    oprot.writeStructBegin('getStorePricings_result')
16595 
    if self.success is not None:
16596 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16597 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16598 
      for iter320 in self.success:
16599 
        iter320.write(oprot)
16600 
      oprot.writeListEnd()
16601 
      oprot.writeFieldEnd()
16602 
    oprot.writeFieldStop()
16603 
    oprot.writeStructEnd()
16604 
 
16605 
  def validate(self):
16606 
    return
16607 
 
16608 
 
16609 
  def __repr__(self):
16610 
    L = ['%s=%r' % (key, value)
16611 
      for key, value in self.__dict__.iteritems()]
16612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16613 
 
16614 
  def __eq__(self, other):
16615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16616 
 
16617 
  def __ne__(self, other):
16618 
    return not (self == other)
16619 
 
7265 rajveer 16620 
class updateStorePricing_args:
16621 
  """
16622 
  Attributes:
16623 
   - sp
7382 rajveer 16624 
   - allColors
7265 rajveer 16625 
  """
16626 
 
16627 
  thrift_spec = (
16628 
    None, # 0
16629 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 16630 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 16631 
  )
16632 
 
7382 rajveer 16633 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 16634 
    self.sp = sp
7382 rajveer 16635 
    self.allColors = allColors
7265 rajveer 16636 
 
16637 
  def read(self, iprot):
16638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16640 
      return
16641 
    iprot.readStructBegin()
16642 
    while True:
16643 
      (fname, ftype, fid) = iprot.readFieldBegin()
16644 
      if ftype == TType.STOP:
16645 
        break
16646 
      if fid == 1:
16647 
        if ftype == TType.STRUCT:
16648 
          self.sp = StorePricing()
16649 
          self.sp.read(iprot)
16650 
        else:
16651 
          iprot.skip(ftype)
7382 rajveer 16652 
      elif fid == 2:
16653 
        if ftype == TType.BOOL:
16654 
          self.allColors = iprot.readBool();
16655 
        else:
16656 
          iprot.skip(ftype)
7265 rajveer 16657 
      else:
16658 
        iprot.skip(ftype)
16659 
      iprot.readFieldEnd()
16660 
    iprot.readStructEnd()
16661 
 
16662 
  def write(self, oprot):
16663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16665 
      return
16666 
    oprot.writeStructBegin('updateStorePricing_args')
16667 
    if self.sp is not None:
16668 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16669 
      self.sp.write(oprot)
16670 
      oprot.writeFieldEnd()
7382 rajveer 16671 
    if self.allColors is not None:
16672 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
16673 
      oprot.writeBool(self.allColors)
16674 
      oprot.writeFieldEnd()
7265 rajveer 16675 
    oprot.writeFieldStop()
16676 
    oprot.writeStructEnd()
16677 
 
16678 
  def validate(self):
16679 
    return
16680 
 
16681 
 
16682 
  def __repr__(self):
16683 
    L = ['%s=%r' % (key, value)
16684 
      for key, value in self.__dict__.iteritems()]
16685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16686 
 
16687 
  def __eq__(self, other):
16688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16689 
 
16690 
  def __ne__(self, other):
16691 
    return not (self == other)
16692 
 
16693 
class updateStorePricing_result:
16694 
 
16695 
  thrift_spec = (
16696 
  )
16697 
 
16698 
  def read(self, iprot):
16699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16701 
      return
16702 
    iprot.readStructBegin()
16703 
    while True:
16704 
      (fname, ftype, fid) = iprot.readFieldBegin()
16705 
      if ftype == TType.STOP:
16706 
        break
16707 
      else:
16708 
        iprot.skip(ftype)
16709 
      iprot.readFieldEnd()
16710 
    iprot.readStructEnd()
16711 
 
16712 
  def write(self, oprot):
16713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16715 
      return
16716 
    oprot.writeStructBegin('updateStorePricing_result')
16717 
    oprot.writeFieldStop()
16718 
    oprot.writeStructEnd()
16719 
 
16720 
  def validate(self):
16721 
    return
16722 
 
16723 
 
16724 
  def __repr__(self):
16725 
    L = ['%s=%r' % (key, value)
16726 
      for key, value in self.__dict__.iteritems()]
16727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16728 
 
16729 
  def __eq__(self, other):
16730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16731 
 
16732 
  def __ne__(self, other):
16733 
    return not (self == other)
7281 kshitij.so 16734 
 
16735 
class getAllAmazonListedItems_args:
16736 
 
16737 
  thrift_spec = (
16738 
  )
16739 
 
16740 
  def read(self, iprot):
16741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16743 
      return
16744 
    iprot.readStructBegin()
16745 
    while True:
16746 
      (fname, ftype, fid) = iprot.readFieldBegin()
16747 
      if ftype == TType.STOP:
16748 
        break
16749 
      else:
16750 
        iprot.skip(ftype)
16751 
      iprot.readFieldEnd()
16752 
    iprot.readStructEnd()
16753 
 
16754 
  def write(self, oprot):
16755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16757 
      return
16758 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16759 
    oprot.writeFieldStop()
16760 
    oprot.writeStructEnd()
16761 
 
16762 
  def validate(self):
16763 
    return
16764 
 
16765 
 
16766 
  def __repr__(self):
16767 
    L = ['%s=%r' % (key, value)
16768 
      for key, value in self.__dict__.iteritems()]
16769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16770 
 
16771 
  def __eq__(self, other):
16772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16773 
 
16774 
  def __ne__(self, other):
16775 
    return not (self == other)
16776 
 
16777 
class getAllAmazonListedItems_result:
16778 
  """
16779 
  Attributes:
16780 
   - success
16781 
  """
16782 
 
16783 
  thrift_spec = (
16784 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16785 
  )
16786 
 
16787 
  def __init__(self, success=None,):
16788 
    self.success = success
16789 
 
16790 
  def read(self, iprot):
16791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16793 
      return
16794 
    iprot.readStructBegin()
16795 
    while True:
16796 
      (fname, ftype, fid) = iprot.readFieldBegin()
16797 
      if ftype == TType.STOP:
16798 
        break
16799 
      if fid == 0:
16800 
        if ftype == TType.LIST:
16801 
          self.success = []
7306 rajveer 16802 
          (_etype324, _size321) = iprot.readListBegin()
16803 
          for _i325 in xrange(_size321):
16804 
            _elem326 = Amazonlisted()
16805 
            _elem326.read(iprot)
16806 
            self.success.append(_elem326)
7281 kshitij.so 16807 
          iprot.readListEnd()
16808 
        else:
16809 
          iprot.skip(ftype)
16810 
      else:
16811 
        iprot.skip(ftype)
16812 
      iprot.readFieldEnd()
16813 
    iprot.readStructEnd()
16814 
 
16815 
  def write(self, oprot):
16816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16818 
      return
16819 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
16820 
    if self.success is not None:
16821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 16823 
      for iter327 in self.success:
16824 
        iter327.write(oprot)
7281 kshitij.so 16825 
      oprot.writeListEnd()
16826 
      oprot.writeFieldEnd()
16827 
    oprot.writeFieldStop()
16828 
    oprot.writeStructEnd()
16829 
 
16830 
  def validate(self):
16831 
    return
16832 
 
16833 
 
16834 
  def __repr__(self):
16835 
    L = ['%s=%r' % (key, value)
16836 
      for key, value in self.__dict__.iteritems()]
16837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16838 
 
16839 
  def __eq__(self, other):
16840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16841 
 
16842 
  def __ne__(self, other):
16843 
    return not (self == other)
16844 
 
16845 
class getAmazonItemDetails_args:
16846 
  """
16847 
  Attributes:
16848 
   - itemId
16849 
  """
16850 
 
16851 
  thrift_spec = (
16852 
    None, # 0
16853 
    (1, TType.I64, 'itemId', None, None, ), # 1
16854 
  )
16855 
 
16856 
  def __init__(self, itemId=None,):
16857 
    self.itemId = itemId
16858 
 
16859 
  def read(self, iprot):
16860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16862 
      return
16863 
    iprot.readStructBegin()
16864 
    while True:
16865 
      (fname, ftype, fid) = iprot.readFieldBegin()
16866 
      if ftype == TType.STOP:
16867 
        break
16868 
      if fid == 1:
16869 
        if ftype == TType.I64:
16870 
          self.itemId = iprot.readI64();
16871 
        else:
16872 
          iprot.skip(ftype)
16873 
      else:
16874 
        iprot.skip(ftype)
16875 
      iprot.readFieldEnd()
16876 
    iprot.readStructEnd()
16877 
 
16878 
  def write(self, oprot):
16879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16881 
      return
16882 
    oprot.writeStructBegin('getAmazonItemDetails_args')
16883 
    if self.itemId is not None:
16884 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16885 
      oprot.writeI64(self.itemId)
16886 
      oprot.writeFieldEnd()
16887 
    oprot.writeFieldStop()
16888 
    oprot.writeStructEnd()
16889 
 
16890 
  def validate(self):
16891 
    return
16892 
 
16893 
 
16894 
  def __repr__(self):
16895 
    L = ['%s=%r' % (key, value)
16896 
      for key, value in self.__dict__.iteritems()]
16897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16898 
 
16899 
  def __eq__(self, other):
16900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16901 
 
16902 
  def __ne__(self, other):
16903 
    return not (self == other)
16904 
 
16905 
class getAmazonItemDetails_result:
16906 
  """
16907 
  Attributes:
16908 
   - success
16909 
  """
16910 
 
16911 
  thrift_spec = (
16912 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
16913 
  )
16914 
 
16915 
  def __init__(self, success=None,):
16916 
    self.success = success
16917 
 
16918 
  def read(self, iprot):
16919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16921 
      return
16922 
    iprot.readStructBegin()
16923 
    while True:
16924 
      (fname, ftype, fid) = iprot.readFieldBegin()
16925 
      if ftype == TType.STOP:
16926 
        break
16927 
      if fid == 0:
16928 
        if ftype == TType.STRUCT:
16929 
          self.success = Amazonlisted()
16930 
          self.success.read(iprot)
16931 
        else:
16932 
          iprot.skip(ftype)
16933 
      else:
16934 
        iprot.skip(ftype)
16935 
      iprot.readFieldEnd()
16936 
    iprot.readStructEnd()
16937 
 
16938 
  def write(self, oprot):
16939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16941 
      return
16942 
    oprot.writeStructBegin('getAmazonItemDetails_result')
16943 
    if self.success is not None:
16944 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16945 
      self.success.write(oprot)
16946 
      oprot.writeFieldEnd()
16947 
    oprot.writeFieldStop()
16948 
    oprot.writeStructEnd()
16949 
 
16950 
  def validate(self):
16951 
    return
16952 
 
16953 
 
16954 
  def __repr__(self):
16955 
    L = ['%s=%r' % (key, value)
16956 
      for key, value in self.__dict__.iteritems()]
16957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16958 
 
16959 
  def __eq__(self, other):
16960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16961 
 
16962 
  def __ne__(self, other):
16963 
    return not (self == other)
16964 
 
16965 
class updateAmazonItemDetails_args:
16966 
  """
16967 
  Attributes:
16968 
   - itemId
16969 
   - fbaPrice
16970 
   - sellingPrice
16971 
   - isFba
16972 
   - isNonFba
16973 
   - isInventoryOverride
7367 kshitij.so 16974 
   - handlingTime
16975 
   - isCustomTime
7281 kshitij.so 16976 
  """
16977 
 
16978 
  thrift_spec = (
16979 
    None, # 0
16980 
    (1, TType.I64, 'itemId', None, None, ), # 1
16981 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
16982 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
16983 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
16984 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
16985 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 16986 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
16987 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 16988 
  )
16989 
 
7367 kshitij.so 16990 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 16991 
    self.itemId = itemId
16992 
    self.fbaPrice = fbaPrice
16993 
    self.sellingPrice = sellingPrice
16994 
    self.isFba = isFba
16995 
    self.isNonFba = isNonFba
16996 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 16997 
    self.handlingTime = handlingTime
16998 
    self.isCustomTime = isCustomTime
7281 kshitij.so 16999 
 
17000 
  def read(self, iprot):
17001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17003 
      return
17004 
    iprot.readStructBegin()
17005 
    while True:
17006 
      (fname, ftype, fid) = iprot.readFieldBegin()
17007 
      if ftype == TType.STOP:
17008 
        break
17009 
      if fid == 1:
17010 
        if ftype == TType.I64:
17011 
          self.itemId = iprot.readI64();
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      elif fid == 2:
17015 
        if ftype == TType.DOUBLE:
17016 
          self.fbaPrice = iprot.readDouble();
17017 
        else:
17018 
          iprot.skip(ftype)
17019 
      elif fid == 3:
17020 
        if ftype == TType.DOUBLE:
17021 
          self.sellingPrice = iprot.readDouble();
17022 
        else:
17023 
          iprot.skip(ftype)
17024 
      elif fid == 4:
17025 
        if ftype == TType.BOOL:
17026 
          self.isFba = iprot.readBool();
17027 
        else:
17028 
          iprot.skip(ftype)
17029 
      elif fid == 5:
17030 
        if ftype == TType.BOOL:
17031 
          self.isNonFba = iprot.readBool();
17032 
        else:
17033 
          iprot.skip(ftype)
17034 
      elif fid == 6:
17035 
        if ftype == TType.BOOL:
17036 
          self.isInventoryOverride = iprot.readBool();
17037 
        else:
17038 
          iprot.skip(ftype)
7367 kshitij.so 17039 
      elif fid == 7:
17040 
        if ftype == TType.I64:
17041 
          self.handlingTime = iprot.readI64();
17042 
        else:
17043 
          iprot.skip(ftype)
17044 
      elif fid == 8:
17045 
        if ftype == TType.BOOL:
17046 
          self.isCustomTime = iprot.readBool();
17047 
        else:
17048 
          iprot.skip(ftype)
7281 kshitij.so 17049 
      else:
17050 
        iprot.skip(ftype)
17051 
      iprot.readFieldEnd()
17052 
    iprot.readStructEnd()
17053 
 
17054 
  def write(self, oprot):
17055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17057 
      return
17058 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17059 
    if self.itemId is not None:
17060 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17061 
      oprot.writeI64(self.itemId)
17062 
      oprot.writeFieldEnd()
17063 
    if self.fbaPrice is not None:
17064 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17065 
      oprot.writeDouble(self.fbaPrice)
17066 
      oprot.writeFieldEnd()
17067 
    if self.sellingPrice is not None:
17068 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17069 
      oprot.writeDouble(self.sellingPrice)
17070 
      oprot.writeFieldEnd()
17071 
    if self.isFba is not None:
17072 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17073 
      oprot.writeBool(self.isFba)
17074 
      oprot.writeFieldEnd()
17075 
    if self.isNonFba is not None:
17076 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17077 
      oprot.writeBool(self.isNonFba)
17078 
      oprot.writeFieldEnd()
17079 
    if self.isInventoryOverride is not None:
17080 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17081 
      oprot.writeBool(self.isInventoryOverride)
17082 
      oprot.writeFieldEnd()
7367 kshitij.so 17083 
    if self.handlingTime is not None:
17084 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17085 
      oprot.writeI64(self.handlingTime)
17086 
      oprot.writeFieldEnd()
17087 
    if self.isCustomTime is not None:
17088 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17089 
      oprot.writeBool(self.isCustomTime)
17090 
      oprot.writeFieldEnd()
7281 kshitij.so 17091 
    oprot.writeFieldStop()
17092 
    oprot.writeStructEnd()
17093 
 
17094 
  def validate(self):
17095 
    return
17096 
 
17097 
 
17098 
  def __repr__(self):
17099 
    L = ['%s=%r' % (key, value)
17100 
      for key, value in self.__dict__.iteritems()]
17101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17102 
 
17103 
  def __eq__(self, other):
17104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17105 
 
17106 
  def __ne__(self, other):
17107 
    return not (self == other)
17108 
 
17109 
class updateAmazonItemDetails_result:
17110 
 
17111 
  thrift_spec = (
17112 
  )
17113 
 
17114 
  def read(self, iprot):
17115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17117 
      return
17118 
    iprot.readStructBegin()
17119 
    while True:
17120 
      (fname, ftype, fid) = iprot.readFieldBegin()
17121 
      if ftype == TType.STOP:
17122 
        break
17123 
      else:
17124 
        iprot.skip(ftype)
17125 
      iprot.readFieldEnd()
17126 
    iprot.readStructEnd()
17127 
 
17128 
  def write(self, oprot):
17129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17131 
      return
17132 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17133 
    oprot.writeFieldStop()
17134 
    oprot.writeStructEnd()
17135 
 
17136 
  def validate(self):
17137 
    return
17138 
 
17139 
 
17140 
  def __repr__(self):
17141 
    L = ['%s=%r' % (key, value)
17142 
      for key, value in self.__dict__.iteritems()]
17143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17144 
 
17145 
  def __eq__(self, other):
17146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17147 
 
17148 
  def __ne__(self, other):
17149 
    return not (self == other)
17150 
 
17151 
class addAmazonItem_args:
17152 
  """
17153 
  Attributes:
17154 
   - amazonlisted
17155 
  """
17156 
 
17157 
  thrift_spec = (
17158 
    None, # 0
17159 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17160 
  )
17161 
 
17162 
  def __init__(self, amazonlisted=None,):
17163 
    self.amazonlisted = amazonlisted
17164 
 
17165 
  def read(self, iprot):
17166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17168 
      return
17169 
    iprot.readStructBegin()
17170 
    while True:
17171 
      (fname, ftype, fid) = iprot.readFieldBegin()
17172 
      if ftype == TType.STOP:
17173 
        break
17174 
      if fid == 1:
17175 
        if ftype == TType.STRUCT:
17176 
          self.amazonlisted = Amazonlisted()
17177 
          self.amazonlisted.read(iprot)
17178 
        else:
17179 
          iprot.skip(ftype)
17180 
      else:
17181 
        iprot.skip(ftype)
17182 
      iprot.readFieldEnd()
17183 
    iprot.readStructEnd()
17184 
 
17185 
  def write(self, oprot):
17186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17188 
      return
17189 
    oprot.writeStructBegin('addAmazonItem_args')
17190 
    if self.amazonlisted is not None:
17191 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17192 
      self.amazonlisted.write(oprot)
17193 
      oprot.writeFieldEnd()
17194 
    oprot.writeFieldStop()
17195 
    oprot.writeStructEnd()
17196 
 
17197 
  def validate(self):
17198 
    return
17199 
 
17200 
 
17201 
  def __repr__(self):
17202 
    L = ['%s=%r' % (key, value)
17203 
      for key, value in self.__dict__.iteritems()]
17204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17205 
 
17206 
  def __eq__(self, other):
17207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17208 
 
17209 
  def __ne__(self, other):
17210 
    return not (self == other)
17211 
 
17212 
class addAmazonItem_result:
17213 
 
17214 
  thrift_spec = (
17215 
  )
17216 
 
17217 
  def read(self, iprot):
17218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17220 
      return
17221 
    iprot.readStructBegin()
17222 
    while True:
17223 
      (fname, ftype, fid) = iprot.readFieldBegin()
17224 
      if ftype == TType.STOP:
17225 
        break
17226 
      else:
17227 
        iprot.skip(ftype)
17228 
      iprot.readFieldEnd()
17229 
    iprot.readStructEnd()
17230 
 
17231 
  def write(self, oprot):
17232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17234 
      return
17235 
    oprot.writeStructBegin('addAmazonItem_result')
17236 
    oprot.writeFieldStop()
17237 
    oprot.writeStructEnd()
17238 
 
17239 
  def validate(self):
17240 
    return
17241 
 
17242 
 
17243 
  def __repr__(self):
17244 
    L = ['%s=%r' % (key, value)
17245 
      for key, value in self.__dict__.iteritems()]
17246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17247 
 
17248 
  def __eq__(self, other):
17249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17250 
 
17251 
  def __ne__(self, other):
17252 
    return not (self == other)
7291 vikram.rag 17253 
 
17254 
class getAsinItems_args:
17255 
 
17256 
  thrift_spec = (
17257 
  )
17258 
 
17259 
  def read(self, iprot):
17260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17262 
      return
17263 
    iprot.readStructBegin()
17264 
    while True:
17265 
      (fname, ftype, fid) = iprot.readFieldBegin()
17266 
      if ftype == TType.STOP:
17267 
        break
17268 
      else:
17269 
        iprot.skip(ftype)
17270 
      iprot.readFieldEnd()
17271 
    iprot.readStructEnd()
17272 
 
17273 
  def write(self, oprot):
17274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17276 
      return
17277 
    oprot.writeStructBegin('getAsinItems_args')
17278 
    oprot.writeFieldStop()
17279 
    oprot.writeStructEnd()
17280 
 
17281 
  def validate(self):
17282 
    return
17283 
 
17284 
 
17285 
  def __repr__(self):
17286 
    L = ['%s=%r' % (key, value)
17287 
      for key, value in self.__dict__.iteritems()]
17288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17289 
 
17290 
  def __eq__(self, other):
17291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17292 
 
17293 
  def __ne__(self, other):
17294 
    return not (self == other)
17295 
 
17296 
class getAsinItems_result:
17297 
  """
17298 
  Attributes:
17299 
   - success
17300 
  """
17301 
 
17302 
  thrift_spec = (
17303 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17304 
  )
17305 
 
17306 
  def __init__(self, success=None,):
17307 
    self.success = success
17308 
 
17309 
  def read(self, iprot):
17310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17312 
      return
17313 
    iprot.readStructBegin()
17314 
    while True:
17315 
      (fname, ftype, fid) = iprot.readFieldBegin()
17316 
      if ftype == TType.STOP:
17317 
        break
17318 
      if fid == 0:
17319 
        if ftype == TType.LIST:
17320 
          self.success = []
7306 rajveer 17321 
          (_etype331, _size328) = iprot.readListBegin()
17322 
          for _i332 in xrange(_size328):
17323 
            _elem333 = Item()
17324 
            _elem333.read(iprot)
17325 
            self.success.append(_elem333)
7291 vikram.rag 17326 
          iprot.readListEnd()
17327 
        else:
17328 
          iprot.skip(ftype)
17329 
      else:
17330 
        iprot.skip(ftype)
17331 
      iprot.readFieldEnd()
17332 
    iprot.readStructEnd()
17333 
 
17334 
  def write(self, oprot):
17335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17337 
      return
17338 
    oprot.writeStructBegin('getAsinItems_result')
17339 
    if self.success is not None:
17340 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17341 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17342 
      for iter334 in self.success:
17343 
        iter334.write(oprot)
7291 vikram.rag 17344 
      oprot.writeListEnd()
17345 
      oprot.writeFieldEnd()
17346 
    oprot.writeFieldStop()
17347 
    oprot.writeStructEnd()
17348 
 
17349 
  def validate(self):
17350 
    return
17351 
 
17352 
 
17353 
  def __repr__(self):
17354 
    L = ['%s=%r' % (key, value)
17355 
      for key, value in self.__dict__.iteritems()]
17356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17357 
 
17358 
  def __eq__(self, other):
17359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17360 
 
17361 
  def __ne__(self, other):
17362 
    return not (self == other)
17363 
 
17364 
class getAllFbaListedItems_args:
17365 
 
17366 
  thrift_spec = (
17367 
  )
17368 
 
17369 
  def read(self, iprot):
17370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17372 
      return
17373 
    iprot.readStructBegin()
17374 
    while True:
17375 
      (fname, ftype, fid) = iprot.readFieldBegin()
17376 
      if ftype == TType.STOP:
17377 
        break
17378 
      else:
17379 
        iprot.skip(ftype)
17380 
      iprot.readFieldEnd()
17381 
    iprot.readStructEnd()
17382 
 
17383 
  def write(self, oprot):
17384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17386 
      return
17387 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17388 
    oprot.writeFieldStop()
17389 
    oprot.writeStructEnd()
17390 
 
17391 
  def validate(self):
17392 
    return
17393 
 
17394 
 
17395 
  def __repr__(self):
17396 
    L = ['%s=%r' % (key, value)
17397 
      for key, value in self.__dict__.iteritems()]
17398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17399 
 
17400 
  def __eq__(self, other):
17401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17402 
 
17403 
  def __ne__(self, other):
17404 
    return not (self == other)
17405 
 
17406 
class getAllFbaListedItems_result:
17407 
  """
17408 
  Attributes:
17409 
   - success
17410 
  """
17411 
 
17412 
  thrift_spec = (
17413 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17414 
  )
17415 
 
17416 
  def __init__(self, success=None,):
17417 
    self.success = success
17418 
 
17419 
  def read(self, iprot):
17420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17422 
      return
17423 
    iprot.readStructBegin()
17424 
    while True:
17425 
      (fname, ftype, fid) = iprot.readFieldBegin()
17426 
      if ftype == TType.STOP:
17427 
        break
17428 
      if fid == 0:
17429 
        if ftype == TType.LIST:
17430 
          self.success = []
7306 rajveer 17431 
          (_etype338, _size335) = iprot.readListBegin()
17432 
          for _i339 in xrange(_size335):
17433 
            _elem340 = Amazonlisted()
17434 
            _elem340.read(iprot)
17435 
            self.success.append(_elem340)
7291 vikram.rag 17436 
          iprot.readListEnd()
17437 
        else:
17438 
          iprot.skip(ftype)
17439 
      else:
17440 
        iprot.skip(ftype)
17441 
      iprot.readFieldEnd()
17442 
    iprot.readStructEnd()
17443 
 
17444 
  def write(self, oprot):
17445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17447 
      return
17448 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17449 
    if self.success is not None:
17450 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17451 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17452 
      for iter341 in self.success:
17453 
        iter341.write(oprot)
7291 vikram.rag 17454 
      oprot.writeListEnd()
17455 
      oprot.writeFieldEnd()
17456 
    oprot.writeFieldStop()
17457 
    oprot.writeStructEnd()
17458 
 
17459 
  def validate(self):
17460 
    return
17461 
 
17462 
 
17463 
  def __repr__(self):
17464 
    L = ['%s=%r' % (key, value)
17465 
      for key, value in self.__dict__.iteritems()]
17466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17467 
 
17468 
  def __eq__(self, other):
17469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17470 
 
17471 
  def __ne__(self, other):
17472 
    return not (self == other)
17473 
 
17474 
class getAllNonFbaListedItems_args:
17475 
 
17476 
  thrift_spec = (
17477 
  )
17478 
 
17479 
  def read(self, iprot):
17480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17482 
      return
17483 
    iprot.readStructBegin()
17484 
    while True:
17485 
      (fname, ftype, fid) = iprot.readFieldBegin()
17486 
      if ftype == TType.STOP:
17487 
        break
17488 
      else:
17489 
        iprot.skip(ftype)
17490 
      iprot.readFieldEnd()
17491 
    iprot.readStructEnd()
17492 
 
17493 
  def write(self, oprot):
17494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17496 
      return
17497 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17498 
    oprot.writeFieldStop()
17499 
    oprot.writeStructEnd()
17500 
 
17501 
  def validate(self):
17502 
    return
17503 
 
17504 
 
17505 
  def __repr__(self):
17506 
    L = ['%s=%r' % (key, value)
17507 
      for key, value in self.__dict__.iteritems()]
17508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17509 
 
17510 
  def __eq__(self, other):
17511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17512 
 
17513 
  def __ne__(self, other):
17514 
    return not (self == other)
17515 
 
17516 
class getAllNonFbaListedItems_result:
17517 
  """
17518 
  Attributes:
17519 
   - success
17520 
  """
17521 
 
17522 
  thrift_spec = (
17523 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17524 
  )
17525 
 
17526 
  def __init__(self, success=None,):
17527 
    self.success = success
17528 
 
17529 
  def read(self, iprot):
17530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17532 
      return
17533 
    iprot.readStructBegin()
17534 
    while True:
17535 
      (fname, ftype, fid) = iprot.readFieldBegin()
17536 
      if ftype == TType.STOP:
17537 
        break
17538 
      if fid == 0:
17539 
        if ftype == TType.LIST:
17540 
          self.success = []
7306 rajveer 17541 
          (_etype345, _size342) = iprot.readListBegin()
17542 
          for _i346 in xrange(_size342):
17543 
            _elem347 = Amazonlisted()
17544 
            _elem347.read(iprot)
17545 
            self.success.append(_elem347)
7291 vikram.rag 17546 
          iprot.readListEnd()
17547 
        else:
17548 
          iprot.skip(ftype)
17549 
      else:
17550 
        iprot.skip(ftype)
17551 
      iprot.readFieldEnd()
17552 
    iprot.readStructEnd()
17553 
 
17554 
  def write(self, oprot):
17555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17557 
      return
17558 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17559 
    if self.success is not None:
17560 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17561 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17562 
      for iter348 in self.success:
17563 
        iter348.write(oprot)
7291 vikram.rag 17564 
      oprot.writeListEnd()
17565 
      oprot.writeFieldEnd()
17566 
    oprot.writeFieldStop()
17567 
    oprot.writeStructEnd()
17568 
 
17569 
  def validate(self):
17570 
    return
17571 
 
17572 
 
17573 
  def __repr__(self):
17574 
    L = ['%s=%r' % (key, value)
17575 
      for key, value in self.__dict__.iteritems()]
17576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17577 
 
17578 
  def __eq__(self, other):
17579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17580 
 
17581 
  def __ne__(self, other):
17582 
    return not (self == other)