Subversion Repositories SmartDukaan

Rev

Rev 8619 | Rev 9155 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
8590 kshitij.so 316 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 317 
    """
8579 kshitij.so 318 
    Banner Related
319 
 
6850 kshitij.so 320 
    Parameters:
8590 kshitij.so 321 
     - bannerCongregate
6850 kshitij.so 322 
    """
323 
    pass
324 
 
8579 kshitij.so 325 
  def updateBanner(self, banner):
326 
    """
327 
    Parameters:
328 
     - banner
329 
    """
330 
    pass
331 
 
6850 kshitij.so 332 
  def getAllBanners(self, ):
333 
    pass
334 
 
335 
  def deleteBanner(self, bannerName):
336 
    """
337 
    Parameters:
338 
     - bannerName
339 
    """
340 
    pass
341 
 
342 
  def getBannerDetails(self, bannerName):
343 
    """
344 
    Parameters:
345 
     - bannerName
346 
    """
347 
    pass
348 
 
349 
  def getActiveBanners(self, ):
350 
    pass
351 
 
8579 kshitij.so 352 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 353 
    """
354 
    Parameters:
8579 kshitij.so 355 
     - bannerMaps
6849 kshitij.so 356 
    """
357 
    pass
358 
 
8579 kshitij.so 359 
  def updateBannerMap(self, bannerMap):
360 
    """
361 
    Parameters:
362 
     - bannerMap
363 
    """
364 
    pass
365 
 
6849 kshitij.so 366 
  def deleteBannerMap(self, bannerName):
367 
    """
368 
    Parameters:
369 
     - bannerName
370 
    """
371 
    pass
372 
 
373 
  def getBannerMapDetails(self, bannerName):
374 
    """
375 
    Parameters:
376 
     - bannerName
377 
    """
378 
    pass
379 
 
8579 kshitij.so 380 
  def addBannerUri(self, bannerUriMappings):
381 
    """
382 
    Parameters:
383 
     - bannerUriMappings
384 
    """
385 
    pass
386 
 
387 
  def getUriMapping(self, bannerName):
388 
    """
389 
    Parameters:
390 
     - bannerName
391 
    """
392 
    pass
393 
 
394 
  def addCampaign(self, campaign):
395 
    """
396 
    Parameters:
397 
     - campaign
398 
    """
399 
    pass
400 
 
401 
  def getCampaigns(self, campaignName):
402 
    """
403 
    Parameters:
404 
     - campaignName
405 
    """
406 
    pass
407 
 
408 
  def deleteCampaign(self, campaignId):
409 
    """
410 
    Parameters:
411 
     - campaignId
412 
    """
413 
    pass
414 
 
415 
  def getAllCampaigns(self, ):
416 
    pass
417 
 
5944 mandeep.dh 418 
  def deleteSimilarItem(self, itemId, catalogItemId):
419 
    """
420 
    Delete similar item.
421 
 
422 
    Parameters:
423 
     - itemId
424 
     - catalogItemId
425 
    """
426 
    pass
427 
 
428 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
429 
    """
430 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
431 
    If yes, returns the itemId else returns 0
432 
 
433 
    Parameters:
434 
     - brand
435 
     - modelNumber
436 
     - modelName
437 
     - color
438 
    """
439 
    pass
440 
 
441 
  def validateRiskyStatus(self, itemId):
442 
    """
443 
    Check wether item is risky and change status if inventory is not available for risky items
444 
 
445 
    Parameters:
446 
     - itemId
447 
    """
448 
    pass
449 
 
450 
  def changeItemRiskyFlag(self, itemId, risky):
451 
    """
452 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
453 
 
454 
    Parameters:
455 
     - itemId
456 
     - risky
457 
    """
458 
    pass
459 
 
460 
  def getItemsByRiskyFlag(self, ):
461 
    """
462 
    Returns list of items marked as risky.
463 
    """
464 
    pass
465 
 
466 
  def getItemsForMasterSheet(self, category, brand):
467 
    """
468 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
469 
 
470 
    Parameters:
471 
     - category
472 
     - brand
473 
    """
474 
    pass
475 
 
476 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
477 
    """
478 
    Returns list of catalog ids of items with same similarity index as of the given itemId
479 
 
480 
    Parameters:
481 
     - beginIndex
482 
     - totalItems
483 
     - itemId
484 
    """
485 
    pass
486 
 
487 
  def addProductNotification(self, itemId, email):
488 
    """
489 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
490 
 
491 
    Parameters:
492 
     - itemId
493 
     - email
494 
    """
495 
    pass
496 
 
497 
  def sendProductNotifications(self, ):
498 
    """
499 
    Send the product notifications to the users for items which has stock.
500 
    """
501 
    pass
502 
 
503 
  def getAllBrandsByCategory(self, categoryId):
504 
    """
505 
    Returns list of brand names for a given category Id
506 
 
507 
    Parameters:
508 
     - categoryId
509 
    """
510 
    pass
511 
 
512 
  def getAllBrands(self, ):
513 
    """
514 
    Returns list of brand names
515 
    """
516 
    pass
517 
 
518 
  def getAllSources(self, ):
519 
    """
520 
    Return list of all sources
521 
    """
522 
    pass
523 
 
524 
  def getItemPricingBySource(self, itemId, sourceId):
525 
    """
526 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
527 
 
528 
    Parameters:
529 
     - itemId
530 
     - sourceId
531 
    """
532 
    pass
533 
 
534 
  def addSourceItemPricing(self, sourceItemPricing):
535 
    """
536 
    Adds prices to be displayed corresponding to the item if user comes from a source.
537 
    If item is not found or source is not found, it will throw exception.
538 
 
539 
    Parameters:
540 
     - sourceItemPricing
541 
    """
542 
    pass
543 
 
544 
  def getAllSourcePricing(self, itemId):
545 
    """
546 
    Returns the list of source pricing information of an item.
547 
    Raises an exception if item not found corresponding to itemId
548 
 
549 
    Parameters:
550 
     - itemId
551 
    """
552 
    pass
553 
 
554 
  def getItemForSource(self, item_id, sourceId):
555 
    """
556 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
557 
 
558 
    Parameters:
559 
     - item_id
560 
     - sourceId
561 
    """
562 
    pass
563 
 
564 
  def searchItemsInRange(self, searchTerms, offset, limit):
565 
    """
566 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
567 
 
568 
    Parameters:
569 
     - searchTerms
570 
     - offset
571 
     - limit
572 
    """
573 
    pass
574 
 
575 
  def getSearchResultCount(self, searchTerms):
576 
    """
577 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
578 
 
579 
    Parameters:
580 
     - searchTerms
581 
    """
582 
    pass
583 
 
584 
  def getProductNotifications(self, startDateTime):
585 
    """
586 
    Returns a list of product notifications added after a supplied datetime
587 
 
588 
    Parameters:
589 
     - startDateTime
590 
    """
591 
    pass
592 
 
7897 amar.kumar 593 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 594 
    """
595 
    Returns a list of count of requests for product notification against each item
596 
 
597 
    Parameters:
598 
     - startDateTime
7897 amar.kumar 599 
     - categoryId
5944 mandeep.dh 600 
    """
601 
    pass
602 
 
603 
  def addAuthorizationLog(self, itemId, username, reason):
604 
    """
605 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
606 
 
607 
    Parameters:
608 
     - itemId
609 
     - username
610 
     - reason
611 
    """
612 
    pass
613 
 
614 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
615 
    """
616 
    Parameters:
617 
     - catalog_item_id
618 
     - voucherType
619 
     - voucherAmount
620 
    """
621 
    pass
622 
 
623 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
624 
    """
625 
    Parameters:
626 
     - catalog_item_id
627 
     - voucherType
628 
    """
629 
    pass
630 
 
631 
  def getVoucherAmount(self, itemId, voucherType):
632 
    """
633 
    Parameters:
634 
     - itemId
635 
     - voucherType
636 
    """
637 
    pass
638 
 
639 
  def getAllItemVouchers(self, itemId):
640 
    """
641 
    Parameters:
642 
     - itemId
643 
    """
644 
    pass
645 
 
646 
  def isValidCatalogItemId(self, catalog_item_id):
647 
    """
648 
    Parameters:
649 
     - catalog_item_id
650 
    """
651 
    pass
652 
 
7330 amit.gupta 653 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 654 
    """
655 
    Parameters:
656 
     - itemId
7330 amit.gupta 657 
     - stateId
6039 amit.gupta 658 
     - price
659 
    """
660 
    pass
5944 mandeep.dh 661 
 
6039 amit.gupta 662 
  def getVatAmountForItem(self, itemId, price):
663 
    """
664 
    Parameters:
665 
     - itemId
666 
     - price
667 
    """
668 
    pass
669 
 
6531 vikram.rag 670 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
671 
    """
672 
    Parameters:
673 
     - offset
674 
     - limit
675 
    """
676 
    pass
6039 amit.gupta 677 
 
6821 amar.kumar 678 
  def getAllAliveItems(self, ):
679 
    pass
680 
 
6921 anupam.sin 681 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 682 
    """
683 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 684 
 
6805 anupam.sin 685 
    Parameters:
686 
     - itemId
6921 anupam.sin 687 
     - price
6805 anupam.sin 688 
     - insurerId
689 
     - quantity
690 
    """
691 
    pass
692 
 
693 
  def getInsurer(self, insurerId):
694 
    """
695 
    Parameters:
696 
     - insurerId
697 
    """
698 
    pass
699 
 
6838 vikram.rag 700 
  def getAllInsurers(self, ):
701 
    pass
6805 anupam.sin 702 
 
6962 rajveer 703 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
704 
    """
705 
    Parameters:
706 
     - insurerId
707 
     - amount
708 
    """
709 
    pass
6838 vikram.rag 710 
 
7190 amar.kumar 711 
  def getFreebieForItem(self, itemId):
712 
    """
713 
    Parameters:
714 
     - itemId
715 
    """
716 
    pass
6962 rajveer 717 
 
7190 amar.kumar 718 
  def addOrUpdateFreebieForItem(self, freebieItem):
719 
    """
720 
    Parameters:
721 
     - freebieItem
722 
    """
723 
    pass
724 
 
7272 amit.gupta 725 
  def addOrUpdateBrandInfo(self, brandInfo):
726 
    """
727 
    Parameters:
728 
     - brandInfo
729 
    """
730 
    pass
731 
 
732 
  def getBrandInfo(self, ):
733 
    pass
734 
 
7256 rajveer 735 
  def getStorePricing(self, itemId):
736 
    """
737 
    Parameters:
738 
     - itemId
739 
    """
740 
    pass
7190 amar.kumar 741 
 
7306 rajveer 742 
  def getStorePricings(self, itemIds):
743 
    """
744 
    Parameters:
745 
     - itemIds
746 
    """
747 
    pass
748 
 
7382 rajveer 749 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 750 
    """
751 
    Parameters:
752 
     - sp
7382 rajveer 753 
     - allColors
7265 rajveer 754 
    """
755 
    pass
7256 rajveer 756 
 
7281 kshitij.so 757 
  def getAllAmazonListedItems(self, ):
758 
    pass
7265 rajveer 759 
 
8619 kshitij.so 760 
  def searchAmazonItems(self, searchTerm, offset, limit):
761 
    """
762 
    Parameters:
763 
     - searchTerm
764 
     - offset
765 
     - limit
766 
    """
767 
    pass
768 
 
769 
  def getAmazonSearchResultCount(self, searchTerm):
770 
    """
771 
    Parameters:
772 
     - searchTerm
773 
    """
774 
    pass
775 
 
776 
  def getCountForAmazonlistedItems(self, ):
777 
    pass
778 
 
7281 kshitij.so 779 
  def getAmazonItemDetails(self, itemId):
780 
    """
781 
    Parameters:
782 
     - itemId
783 
    """
784 
    pass
785 
 
8168 kshitij.so 786 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 787 
    """
788 
    Parameters:
8168 kshitij.so 789 
     - amazonlisted
7281 kshitij.so 790 
    """
791 
    pass
792 
 
793 
  def addAmazonItem(self, amazonlisted):
794 
    """
795 
    Parameters:
796 
     - amazonlisted
797 
    """
798 
    pass
799 
 
7291 vikram.rag 800 
  def getAsinItems(self, ):
801 
    pass
7281 kshitij.so 802 
 
7291 vikram.rag 803 
  def getAllFbaListedItems(self, ):
804 
    pass
805 
 
806 
  def getAllNonFbaListedItems(self, ):
807 
    pass
808 
 
7460 kshitij.so 809 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
810 
    """
811 
    Parameters:
812 
     - itemId
813 
     - holdInventory
814 
     - defaultInventory
815 
    """
816 
    pass
7291 vikram.rag 817 
 
7770 kshitij.so 818 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
819 
    """
820 
    Parameters:
821 
     - type
822 
     - sku
823 
     - timestamp
824 
    """
825 
    pass
7460 kshitij.so 826 
 
7897 amar.kumar 827 
  def getAllParentCategories(self, ):
828 
    pass
7770 kshitij.so 829 
 
7977 kshitij.so 830 
  def addPageViewEvent(self, pageViewEvents):
831 
    """
832 
    Parameters:
833 
     - pageViewEvents
834 
    """
835 
    pass
7897 amar.kumar 836 
 
7977 kshitij.so 837 
  def addCartEvent(self, cartEvents):
838 
    """
839 
    Parameters:
840 
     - cartEvents
841 
    """
842 
    pass
843 
 
8182 amar.kumar 844 
  def addEbayItem(self, ebayItem):
845 
    """
846 
    Parameters:
847 
     - ebayItem
848 
    """
849 
    pass
850 
 
851 
  def getEbayItem(self, listingId):
852 
    """
853 
    Parameters:
854 
     - listingId
855 
    """
856 
    pass
857 
 
858 
  def updateEbayItem(self, ebayItem):
859 
    """
860 
    Parameters:
861 
     - ebayItem
862 
    """
863 
    pass
864 
 
8139 kshitij.so 865 
  def getAmazonListedItems(self, offset, limit):
866 
    """
867 
    Parameters:
868 
     - offset
869 
     - limit
870 
    """
871 
    pass
7977 kshitij.so 872 
 
8168 kshitij.so 873 
  def updateAmazonAttributesInBulk(self, amazonlisted):
874 
    """
875 
    Parameters:
876 
     - amazonlisted
877 
    """
878 
    pass
8139 kshitij.so 879 
 
8379 vikram.rag 880 
  def getAllItemstoListOnFba(self, ):
881 
    pass
8168 kshitij.so 882 
 
8379 vikram.rag 883 
  def getAllItemstoListOnNonFba(self, ):
884 
    pass
885 
 
8616 vikram.rag 886 
  def getAllSnapdealListedActiveItems(self, ):
887 
    pass
8379 vikram.rag 888 
 
8619 kshitij.so 889 
  def updateAsin(self, item):
890 
    """
891 
    Parameters:
892 
     - item
893 
    """
894 
    pass
8616 vikram.rag 895 
 
8739 vikram.rag 896 
  def addOrUpdateSnapdealItem(self, snapdealitem):
897 
    """
898 
    Parameters:
899 
     - snapdealitem
900 
    """
901 
    pass
8619 kshitij.so 902 
 
8739 vikram.rag 903 
  def getSnapdealItem(self, item_id):
904 
    """
905 
    Parameters:
906 
     - item_id
907 
    """
908 
    pass
909 
 
910 
  def getAllSnapdealItems(self, ):
911 
    pass
912 
 
913 
 
5944 mandeep.dh 914 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
915 
  def __init__(self, iprot, oprot=None):
916 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
917 
 
918 
  def addItem(self, item):
919 
    """
920 
    Availability and inventory attributes
921 
 
922 
    Parameters:
923 
     - item
924 
    """
925 
    self.send_addItem(item)
926 
    return self.recv_addItem()
927 
 
928 
  def send_addItem(self, item):
929 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
930 
    args = addItem_args()
931 
    args.item = item
932 
    args.write(self._oprot)
933 
    self._oprot.writeMessageEnd()
934 
    self._oprot.trans.flush()
935 
 
936 
  def recv_addItem(self, ):
937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
938 
    if mtype == TMessageType.EXCEPTION:
939 
      x = TApplicationException()
940 
      x.read(self._iprot)
941 
      self._iprot.readMessageEnd()
942 
      raise x
943 
    result = addItem_result()
944 
    result.read(self._iprot)
945 
    self._iprot.readMessageEnd()
946 
    if result.success is not None:
947 
      return result.success
948 
    if result.cex is not None:
949 
      raise result.cex
950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
951 
 
952 
  def updateItem(self, item):
953 
    """
954 
    Parameters:
955 
     - item
956 
    """
957 
    self.send_updateItem(item)
958 
    return self.recv_updateItem()
959 
 
960 
  def send_updateItem(self, item):
961 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
962 
    args = updateItem_args()
963 
    args.item = item
964 
    args.write(self._oprot)
965 
    self._oprot.writeMessageEnd()
966 
    self._oprot.trans.flush()
967 
 
968 
  def recv_updateItem(self, ):
969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
970 
    if mtype == TMessageType.EXCEPTION:
971 
      x = TApplicationException()
972 
      x.read(self._iprot)
973 
      self._iprot.readMessageEnd()
974 
      raise x
975 
    result = updateItem_result()
976 
    result.read(self._iprot)
977 
    self._iprot.readMessageEnd()
978 
    if result.success is not None:
979 
      return result.success
980 
    if result.cex is not None:
981 
      raise result.cex
982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
983 
 
984 
  def isActive(self, itemId):
985 
    """
986 
    Checks if the item given to the corresponding itemId is active. If it's active,
987 
    whether it's risky and if it's risky, its inventory position.
988 
 
989 
    Parameters:
990 
     - itemId
991 
    """
992 
    self.send_isActive(itemId)
993 
    return self.recv_isActive()
994 
 
995 
  def send_isActive(self, itemId):
996 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
997 
    args = isActive_args()
998 
    args.itemId = itemId
999 
    args.write(self._oprot)
1000 
    self._oprot.writeMessageEnd()
1001 
    self._oprot.trans.flush()
1002 
 
1003 
  def recv_isActive(self, ):
1004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1005 
    if mtype == TMessageType.EXCEPTION:
1006 
      x = TApplicationException()
1007 
      x.read(self._iprot)
1008 
      self._iprot.readMessageEnd()
1009 
      raise x
1010 
    result = isActive_result()
1011 
    result.read(self._iprot)
1012 
    self._iprot.readMessageEnd()
1013 
    if result.success is not None:
1014 
      return result.success
1015 
    if result.isex is not None:
1016 
      raise result.isex
1017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
1018 
 
7438 amit.gupta 1019 
  def getItemsStatus(self, itemIds):
1020 
    """
1021 
    Parameters:
1022 
     - itemIds
1023 
    """
1024 
    self.send_getItemsStatus(itemIds)
1025 
    return self.recv_getItemsStatus()
1026 
 
1027 
  def send_getItemsStatus(self, itemIds):
1028 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
1029 
    args = getItemsStatus_args()
1030 
    args.itemIds = itemIds
1031 
    args.write(self._oprot)
1032 
    self._oprot.writeMessageEnd()
1033 
    self._oprot.trans.flush()
1034 
 
1035 
  def recv_getItemsStatus(self, ):
1036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1037 
    if mtype == TMessageType.EXCEPTION:
1038 
      x = TApplicationException()
1039 
      x.read(self._iprot)
1040 
      self._iprot.readMessageEnd()
1041 
      raise x
1042 
    result = getItemsStatus_result()
1043 
    result.read(self._iprot)
1044 
    self._iprot.readMessageEnd()
1045 
    if result.success is not None:
1046 
      return result.success
1047 
    if result.isex is not None:
1048 
      raise result.isex
1049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
1050 
 
5944 mandeep.dh 1051 
  def getItemStatusDescription(self, itemId):
1052 
    """
1053 
    Parameters:
1054 
     - itemId
1055 
    """
1056 
    self.send_getItemStatusDescription(itemId)
1057 
    return self.recv_getItemStatusDescription()
1058 
 
1059 
  def send_getItemStatusDescription(self, itemId):
1060 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
1061 
    args = getItemStatusDescription_args()
1062 
    args.itemId = itemId
1063 
    args.write(self._oprot)
1064 
    self._oprot.writeMessageEnd()
1065 
    self._oprot.trans.flush()
1066 
 
1067 
  def recv_getItemStatusDescription(self, ):
1068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1069 
    if mtype == TMessageType.EXCEPTION:
1070 
      x = TApplicationException()
1071 
      x.read(self._iprot)
1072 
      self._iprot.readMessageEnd()
1073 
      raise x
1074 
    result = getItemStatusDescription_result()
1075 
    result.read(self._iprot)
1076 
    self._iprot.readMessageEnd()
1077 
    if result.success is not None:
1078 
      return result.success
1079 
    if result.isex is not None:
1080 
      raise result.isex
1081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
1082 
 
1083 
  def startItemOn(self, item_id, timestamp):
1084 
    """
1085 
    Parameters:
1086 
     - item_id
1087 
     - timestamp
1088 
    """
1089 
    self.send_startItemOn(item_id, timestamp)
1090 
    self.recv_startItemOn()
1091 
 
1092 
  def send_startItemOn(self, item_id, timestamp):
1093 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
1094 
    args = startItemOn_args()
1095 
    args.item_id = item_id
1096 
    args.timestamp = timestamp
1097 
    args.write(self._oprot)
1098 
    self._oprot.writeMessageEnd()
1099 
    self._oprot.trans.flush()
1100 
 
1101 
  def recv_startItemOn(self, ):
1102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1103 
    if mtype == TMessageType.EXCEPTION:
1104 
      x = TApplicationException()
1105 
      x.read(self._iprot)
1106 
      self._iprot.readMessageEnd()
1107 
      raise x
1108 
    result = startItemOn_result()
1109 
    result.read(self._iprot)
1110 
    self._iprot.readMessageEnd()
1111 
    if result.cex is not None:
1112 
      raise result.cex
1113 
    return
1114 
 
1115 
  def retireItemOn(self, item_id, timestamp):
1116 
    """
1117 
    Parameters:
1118 
     - item_id
1119 
     - timestamp
1120 
    """
1121 
    self.send_retireItemOn(item_id, timestamp)
1122 
    self.recv_retireItemOn()
1123 
 
1124 
  def send_retireItemOn(self, item_id, timestamp):
1125 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
1126 
    args = retireItemOn_args()
1127 
    args.item_id = item_id
1128 
    args.timestamp = timestamp
1129 
    args.write(self._oprot)
1130 
    self._oprot.writeMessageEnd()
1131 
    self._oprot.trans.flush()
1132 
 
1133 
  def recv_retireItemOn(self, ):
1134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1135 
    if mtype == TMessageType.EXCEPTION:
1136 
      x = TApplicationException()
1137 
      x.read(self._iprot)
1138 
      self._iprot.readMessageEnd()
1139 
      raise x
1140 
    result = retireItemOn_result()
1141 
    result.read(self._iprot)
1142 
    self._iprot.readMessageEnd()
1143 
    if result.cex is not None:
1144 
      raise result.cex
1145 
    return
1146 
 
1147 
  def changeItemStatus(self, item_id, timestamp, newstatus):
1148 
    """
1149 
    Parameters:
1150 
     - item_id
1151 
     - timestamp
1152 
     - newstatus
1153 
    """
1154 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1155 
    self.recv_changeItemStatus()
1156 
 
1157 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1158 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1159 
    args = changeItemStatus_args()
1160 
    args.item_id = item_id
1161 
    args.timestamp = timestamp
1162 
    args.newstatus = newstatus
1163 
    args.write(self._oprot)
1164 
    self._oprot.writeMessageEnd()
1165 
    self._oprot.trans.flush()
1166 
 
1167 
  def recv_changeItemStatus(self, ):
1168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1169 
    if mtype == TMessageType.EXCEPTION:
1170 
      x = TApplicationException()
1171 
      x.read(self._iprot)
1172 
      self._iprot.readMessageEnd()
1173 
      raise x
1174 
    result = changeItemStatus_result()
1175 
    result.read(self._iprot)
1176 
    self._iprot.readMessageEnd()
1177 
    if result.cex is not None:
1178 
      raise result.cex
1179 
    return
1180 
 
1181 
  def getItem(self, item_id):
1182 
    """
1183 
    Parameters:
1184 
     - item_id
1185 
    """
1186 
    self.send_getItem(item_id)
1187 
    return self.recv_getItem()
1188 
 
1189 
  def send_getItem(self, item_id):
1190 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1191 
    args = getItem_args()
1192 
    args.item_id = item_id
1193 
    args.write(self._oprot)
1194 
    self._oprot.writeMessageEnd()
1195 
    self._oprot.trans.flush()
1196 
 
1197 
  def recv_getItem(self, ):
1198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1199 
    if mtype == TMessageType.EXCEPTION:
1200 
      x = TApplicationException()
1201 
      x.read(self._iprot)
1202 
      self._iprot.readMessageEnd()
1203 
      raise x
1204 
    result = getItem_result()
1205 
    result.read(self._iprot)
1206 
    self._iprot.readMessageEnd()
1207 
    if result.success is not None:
1208 
      return result.success
1209 
    if result.cex is not None:
1210 
      raise result.cex
1211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1212 
 
1213 
  def getItemsByCatalogId(self, catalog_item_id):
1214 
    """
1215 
    Parameters:
1216 
     - catalog_item_id
1217 
    """
1218 
    self.send_getItemsByCatalogId(catalog_item_id)
1219 
    return self.recv_getItemsByCatalogId()
1220 
 
1221 
  def send_getItemsByCatalogId(self, catalog_item_id):
1222 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1223 
    args = getItemsByCatalogId_args()
1224 
    args.catalog_item_id = catalog_item_id
1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_getItemsByCatalogId(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = getItemsByCatalogId_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
1239 
    if result.success is not None:
1240 
      return result.success
1241 
    if result.cex is not None:
1242 
      raise result.cex
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1244 
 
1245 
  def getValidItemsByCatalogId(self, catalog_item_id):
1246 
    """
1247 
    Parameters:
1248 
     - catalog_item_id
1249 
    """
1250 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1251 
    return self.recv_getValidItemsByCatalogId()
1252 
 
1253 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1254 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1255 
    args = getValidItemsByCatalogId_args()
1256 
    args.catalog_item_id = catalog_item_id
1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
1261 
  def recv_getValidItemsByCatalogId(self, ):
1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
1268 
    result = getValidItemsByCatalogId_result()
1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
1271 
    if result.success is not None:
1272 
      return result.success
1273 
    if result.cex is not None:
1274 
      raise result.cex
1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1276 
 
1277 
  def getAllItems(self, isActive):
1278 
    """
1279 
    Parameters:
1280 
     - isActive
1281 
    """
1282 
    self.send_getAllItems(isActive)
1283 
    return self.recv_getAllItems()
1284 
 
1285 
  def send_getAllItems(self, isActive):
1286 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1287 
    args = getAllItems_args()
1288 
    args.isActive = isActive
1289 
    args.write(self._oprot)
1290 
    self._oprot.writeMessageEnd()
1291 
    self._oprot.trans.flush()
1292 
 
1293 
  def recv_getAllItems(self, ):
1294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1295 
    if mtype == TMessageType.EXCEPTION:
1296 
      x = TApplicationException()
1297 
      x.read(self._iprot)
1298 
      self._iprot.readMessageEnd()
1299 
      raise x
1300 
    result = getAllItems_result()
1301 
    result.read(self._iprot)
1302 
    self._iprot.readMessageEnd()
1303 
    if result.success is not None:
1304 
      return result.success
1305 
    if result.cex is not None:
1306 
      raise result.cex
1307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1308 
 
1309 
  def getAllItemsByStatus(self, itemStatus):
1310 
    """
1311 
    Parameters:
1312 
     - itemStatus
1313 
    """
1314 
    self.send_getAllItemsByStatus(itemStatus)
1315 
    return self.recv_getAllItemsByStatus()
1316 
 
1317 
  def send_getAllItemsByStatus(self, itemStatus):
1318 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1319 
    args = getAllItemsByStatus_args()
1320 
    args.itemStatus = itemStatus
1321 
    args.write(self._oprot)
1322 
    self._oprot.writeMessageEnd()
1323 
    self._oprot.trans.flush()
1324 
 
1325 
  def recv_getAllItemsByStatus(self, ):
1326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1327 
    if mtype == TMessageType.EXCEPTION:
1328 
      x = TApplicationException()
1329 
      x.read(self._iprot)
1330 
      self._iprot.readMessageEnd()
1331 
      raise x
1332 
    result = getAllItemsByStatus_result()
1333 
    result.read(self._iprot)
1334 
    self._iprot.readMessageEnd()
1335 
    if result.success is not None:
1336 
      return result.success
1337 
    if result.cex is not None:
1338 
      raise result.cex
1339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1340 
 
1341 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1342 
    """
1343 
    Parameters:
1344 
     - entityId
1345 
     - category
1346 
     - brand
1347 
     - modelName
1348 
     - modelNumber
1349 
    """
1350 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1351 
    return self.recv_markItemAsContentComplete()
1352 
 
1353 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1354 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1355 
    args = markItemAsContentComplete_args()
1356 
    args.entityId = entityId
1357 
    args.category = category
1358 
    args.brand = brand
1359 
    args.modelName = modelName
1360 
    args.modelNumber = modelNumber
1361 
    args.write(self._oprot)
1362 
    self._oprot.writeMessageEnd()
1363 
    self._oprot.trans.flush()
1364 
 
1365 
  def recv_markItemAsContentComplete(self, ):
1366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1367 
    if mtype == TMessageType.EXCEPTION:
1368 
      x = TApplicationException()
1369 
      x.read(self._iprot)
1370 
      self._iprot.readMessageEnd()
1371 
      raise x
1372 
    result = markItemAsContentComplete_result()
1373 
    result.read(self._iprot)
1374 
    self._iprot.readMessageEnd()
1375 
    if result.success is not None:
1376 
      return result.success
1377 
    if result.cex is not None:
1378 
      raise result.cex
1379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1380 
 
1381 
  def getAllItemsInRange(self, offset, limit):
1382 
    """
1383 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1384 
 
1385 
    Parameters:
1386 
     - offset
1387 
     - limit
1388 
    """
1389 
    self.send_getAllItemsInRange(offset, limit)
1390 
    return self.recv_getAllItemsInRange()
1391 
 
1392 
  def send_getAllItemsInRange(self, offset, limit):
1393 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1394 
    args = getAllItemsInRange_args()
1395 
    args.offset = offset
1396 
    args.limit = limit
1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_getAllItemsInRange(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = getAllItemsInRange_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
1411 
    if result.success is not None:
1412 
      return result.success
1413 
    if result.cex is not None:
1414 
      raise result.cex
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1416 
 
1417 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1418 
    """
1419 
    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.
1420 
 
1421 
    Parameters:
1422 
     - itemStatus
1423 
     - offset
1424 
     - limit
1425 
    """
1426 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1427 
    return self.recv_getAllItemsByStatusInRange()
1428 
 
1429 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1430 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1431 
    args = getAllItemsByStatusInRange_args()
1432 
    args.itemStatus = itemStatus
1433 
    args.offset = offset
1434 
    args.limit = limit
1435 
    args.write(self._oprot)
1436 
    self._oprot.writeMessageEnd()
1437 
    self._oprot.trans.flush()
1438 
 
1439 
  def recv_getAllItemsByStatusInRange(self, ):
1440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1441 
    if mtype == TMessageType.EXCEPTION:
1442 
      x = TApplicationException()
1443 
      x.read(self._iprot)
1444 
      self._iprot.readMessageEnd()
1445 
      raise x
1446 
    result = getAllItemsByStatusInRange_result()
1447 
    result.read(self._iprot)
1448 
    self._iprot.readMessageEnd()
1449 
    if result.success is not None:
1450 
      return result.success
1451 
    if result.cex is not None:
1452 
      raise result.cex
1453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1454 
 
1455 
  def getItemCountByStatus(self, useStatus, itemStatus):
1456 
    """
1457 
    Gets a count of all items by status
1458 
 
1459 
    Parameters:
1460 
     - useStatus
1461 
     - itemStatus
1462 
    """
1463 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1464 
    return self.recv_getItemCountByStatus()
1465 
 
1466 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1467 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1468 
    args = getItemCountByStatus_args()
1469 
    args.useStatus = useStatus
1470 
    args.itemStatus = itemStatus
1471 
    args.write(self._oprot)
1472 
    self._oprot.writeMessageEnd()
1473 
    self._oprot.trans.flush()
1474 
 
1475 
  def recv_getItemCountByStatus(self, ):
1476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1477 
    if mtype == TMessageType.EXCEPTION:
1478 
      x = TApplicationException()
1479 
      x.read(self._iprot)
1480 
      self._iprot.readMessageEnd()
1481 
      raise x
1482 
    result = getItemCountByStatus_result()
1483 
    result.read(self._iprot)
1484 
    self._iprot.readMessageEnd()
1485 
    if result.success is not None:
1486 
      return result.success
1487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1488 
 
1489 
  def getBestSellers(self, ):
1490 
    self.send_getBestSellers()
1491 
    return self.recv_getBestSellers()
1492 
 
1493 
  def send_getBestSellers(self, ):
1494 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1495 
    args = getBestSellers_args()
1496 
    args.write(self._oprot)
1497 
    self._oprot.writeMessageEnd()
1498 
    self._oprot.trans.flush()
1499 
 
1500 
  def recv_getBestSellers(self, ):
1501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1502 
    if mtype == TMessageType.EXCEPTION:
1503 
      x = TApplicationException()
1504 
      x.read(self._iprot)
1505 
      self._iprot.readMessageEnd()
1506 
      raise x
1507 
    result = getBestSellers_result()
1508 
    result.read(self._iprot)
1509 
    self._iprot.readMessageEnd()
1510 
    if result.success is not None:
1511 
      return result.success
1512 
    if result.isex is not None:
1513 
      raise result.isex
1514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1515 
 
1516 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1517 
    """
1518 
    Parameters:
1519 
     - beginIndex
1520 
     - totalItems
1521 
     - brand
1522 
     - category
1523 
    """
1524 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1525 
    return self.recv_getBestSellersCatalogIds()
1526 
 
1527 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1528 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1529 
    args = getBestSellersCatalogIds_args()
1530 
    args.beginIndex = beginIndex
1531 
    args.totalItems = totalItems
1532 
    args.brand = brand
1533 
    args.category = category
1534 
    args.write(self._oprot)
1535 
    self._oprot.writeMessageEnd()
1536 
    self._oprot.trans.flush()
1537 
 
1538 
  def recv_getBestSellersCatalogIds(self, ):
1539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1540 
    if mtype == TMessageType.EXCEPTION:
1541 
      x = TApplicationException()
1542 
      x.read(self._iprot)
1543 
      self._iprot.readMessageEnd()
1544 
      raise x
1545 
    result = getBestSellersCatalogIds_result()
1546 
    result.read(self._iprot)
1547 
    self._iprot.readMessageEnd()
1548 
    if result.success is not None:
1549 
      return result.success
1550 
    if result.cex is not None:
1551 
      raise result.cex
1552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1553 
 
1554 
  def getBestSellersCount(self, ):
1555 
    self.send_getBestSellersCount()
1556 
    return self.recv_getBestSellersCount()
1557 
 
1558 
  def send_getBestSellersCount(self, ):
1559 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1560 
    args = getBestSellersCount_args()
1561 
    args.write(self._oprot)
1562 
    self._oprot.writeMessageEnd()
1563 
    self._oprot.trans.flush()
1564 
 
1565 
  def recv_getBestSellersCount(self, ):
1566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1567 
    if mtype == TMessageType.EXCEPTION:
1568 
      x = TApplicationException()
1569 
      x.read(self._iprot)
1570 
      self._iprot.readMessageEnd()
1571 
      raise x
1572 
    result = getBestSellersCount_result()
1573 
    result.read(self._iprot)
1574 
    self._iprot.readMessageEnd()
1575 
    if result.success is not None:
1576 
      return result.success
1577 
    if result.cex is not None:
1578 
      raise result.cex
1579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1580 
 
1581 
  def getBestDeals(self, ):
1582 
    self.send_getBestDeals()
1583 
    return self.recv_getBestDeals()
1584 
 
1585 
  def send_getBestDeals(self, ):
1586 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1587 
    args = getBestDeals_args()
1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
1592 
  def recv_getBestDeals(self, ):
1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
1599 
    result = getBestDeals_result()
1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
1602 
    if result.success is not None:
1603 
      return result.success
1604 
    if result.isex is not None:
1605 
      raise result.isex
1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1607 
 
1608 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1609 
    """
1610 
    Parameters:
1611 
     - beginIndex
1612 
     - totalItems
1613 
     - brand
1614 
     - category
1615 
    """
1616 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1617 
    return self.recv_getBestDealsCatalogIds()
1618 
 
1619 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1620 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1621 
    args = getBestDealsCatalogIds_args()
1622 
    args.beginIndex = beginIndex
1623 
    args.totalItems = totalItems
1624 
    args.brand = brand
1625 
    args.category = category
1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
1630 
  def recv_getBestDealsCatalogIds(self, ):
1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
1637 
    result = getBestDealsCatalogIds_result()
1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
1640 
    if result.success is not None:
1641 
      return result.success
1642 
    if result.cex is not None:
1643 
      raise result.cex
1644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1645 
 
1646 
  def getBestDealsCount(self, ):
1647 
    self.send_getBestDealsCount()
1648 
    return self.recv_getBestDealsCount()
1649 
 
1650 
  def send_getBestDealsCount(self, ):
1651 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1652 
    args = getBestDealsCount_args()
1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
1657 
  def recv_getBestDealsCount(self, ):
1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
1664 
    result = getBestDealsCount_result()
1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
1667 
    if result.success is not None:
1668 
      return result.success
1669 
    if result.cex is not None:
1670 
      raise result.cex
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1672 
 
1673 
  def getComingSoon(self, ):
1674 
    self.send_getComingSoon()
1675 
    return self.recv_getComingSoon()
1676 
 
1677 
  def send_getComingSoon(self, ):
1678 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1679 
    args = getComingSoon_args()
1680 
    args.write(self._oprot)
1681 
    self._oprot.writeMessageEnd()
1682 
    self._oprot.trans.flush()
1683 
 
1684 
  def recv_getComingSoon(self, ):
1685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1686 
    if mtype == TMessageType.EXCEPTION:
1687 
      x = TApplicationException()
1688 
      x.read(self._iprot)
1689 
      self._iprot.readMessageEnd()
1690 
      raise x
1691 
    result = getComingSoon_result()
1692 
    result.read(self._iprot)
1693 
    self._iprot.readMessageEnd()
1694 
    if result.success is not None:
1695 
      return result.success
1696 
    if result.isex is not None:
1697 
      raise result.isex
1698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1699 
 
1700 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1701 
    """
1702 
    Parameters:
1703 
     - beginIndex
1704 
     - totalItems
1705 
     - brand
1706 
     - category
1707 
    """
1708 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1709 
    return self.recv_getComingSoonCatalogIds()
1710 
 
1711 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1712 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1713 
    args = getComingSoonCatalogIds_args()
1714 
    args.beginIndex = beginIndex
1715 
    args.totalItems = totalItems
1716 
    args.brand = brand
1717 
    args.category = category
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_getComingSoonCatalogIds(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = getComingSoonCatalogIds_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
1732 
    if result.success is not None:
1733 
      return result.success
1734 
    if result.cex is not None:
1735 
      raise result.cex
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1737 
 
1738 
  def getComingSoonCount(self, ):
1739 
    self.send_getComingSoonCount()
1740 
    return self.recv_getComingSoonCount()
1741 
 
1742 
  def send_getComingSoonCount(self, ):
1743 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1744 
    args = getComingSoonCount_args()
1745 
    args.write(self._oprot)
1746 
    self._oprot.writeMessageEnd()
1747 
    self._oprot.trans.flush()
1748 
 
1749 
  def recv_getComingSoonCount(self, ):
1750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1751 
    if mtype == TMessageType.EXCEPTION:
1752 
      x = TApplicationException()
1753 
      x.read(self._iprot)
1754 
      self._iprot.readMessageEnd()
1755 
      raise x
1756 
    result = getComingSoonCount_result()
1757 
    result.read(self._iprot)
1758 
    self._iprot.readMessageEnd()
1759 
    if result.success is not None:
1760 
      return result.success
1761 
    if result.cex is not None:
1762 
      raise result.cex
1763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1764 
 
1765 
  def getLatestArrivals(self, ):
1766 
    """
1767 
    Returns a list of items sorted in the descending order by start date.
1768 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1769 
    """
1770 
    self.send_getLatestArrivals()
1771 
    return self.recv_getLatestArrivals()
1772 
 
1773 
  def send_getLatestArrivals(self, ):
1774 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1775 
    args = getLatestArrivals_args()
1776 
    args.write(self._oprot)
1777 
    self._oprot.writeMessageEnd()
1778 
    self._oprot.trans.flush()
1779 
 
1780 
  def recv_getLatestArrivals(self, ):
1781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1782 
    if mtype == TMessageType.EXCEPTION:
1783 
      x = TApplicationException()
1784 
      x.read(self._iprot)
1785 
      self._iprot.readMessageEnd()
1786 
      raise x
1787 
    result = getLatestArrivals_result()
1788 
    result.read(self._iprot)
1789 
    self._iprot.readMessageEnd()
1790 
    if result.success is not None:
1791 
      return result.success
1792 
    if result.isex is not None:
1793 
      raise result.isex
1794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1795 
 
1796 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1797 
    """
1798 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1799 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1800 
 
1801 
    Parameters:
1802 
     - beginIndex
1803 
     - totalItems
1804 
     - brand
1805 
     - categories
1806 
    """
1807 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1808 
    return self.recv_getLatestArrivalsCatalogIds()
1809 
 
1810 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1811 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1812 
    args = getLatestArrivalsCatalogIds_args()
1813 
    args.beginIndex = beginIndex
1814 
    args.totalItems = totalItems
1815 
    args.brand = brand
1816 
    args.categories = categories
1817 
    args.write(self._oprot)
1818 
    self._oprot.writeMessageEnd()
1819 
    self._oprot.trans.flush()
1820 
 
1821 
  def recv_getLatestArrivalsCatalogIds(self, ):
1822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1823 
    if mtype == TMessageType.EXCEPTION:
1824 
      x = TApplicationException()
1825 
      x.read(self._iprot)
1826 
      self._iprot.readMessageEnd()
1827 
      raise x
1828 
    result = getLatestArrivalsCatalogIds_result()
1829 
    result.read(self._iprot)
1830 
    self._iprot.readMessageEnd()
1831 
    if result.success is not None:
1832 
      return result.success
1833 
    if result.cex is not None:
1834 
      raise result.cex
1835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1836 
 
1837 
  def getLatestArrivalsCount(self, ):
1838 
    """
1839 
    Get the total number of latest arrivals we are willing to show.
1840 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1841 
    """
1842 
    self.send_getLatestArrivalsCount()
1843 
    return self.recv_getLatestArrivalsCount()
1844 
 
1845 
  def send_getLatestArrivalsCount(self, ):
1846 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1847 
    args = getLatestArrivalsCount_args()
1848 
    args.write(self._oprot)
1849 
    self._oprot.writeMessageEnd()
1850 
    self._oprot.trans.flush()
1851 
 
1852 
  def recv_getLatestArrivalsCount(self, ):
1853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1854 
    if mtype == TMessageType.EXCEPTION:
1855 
      x = TApplicationException()
1856 
      x.read(self._iprot)
1857 
      self._iprot.readMessageEnd()
1858 
      raise x
1859 
    result = getLatestArrivalsCount_result()
1860 
    result.read(self._iprot)
1861 
    self._iprot.readMessageEnd()
1862 
    if result.success is not None:
1863 
      return result.success
1864 
    if result.cex is not None:
1865 
      raise result.cex
1866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1867 
 
1868 
  def generateNewEntityID(self, ):
1869 
    self.send_generateNewEntityID()
1870 
    return self.recv_generateNewEntityID()
1871 
 
1872 
  def send_generateNewEntityID(self, ):
1873 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1874 
    args = generateNewEntityID_args()
1875 
    args.write(self._oprot)
1876 
    self._oprot.writeMessageEnd()
1877 
    self._oprot.trans.flush()
1878 
 
1879 
  def recv_generateNewEntityID(self, ):
1880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1881 
    if mtype == TMessageType.EXCEPTION:
1882 
      x = TApplicationException()
1883 
      x.read(self._iprot)
1884 
      self._iprot.readMessageEnd()
1885 
      raise x
1886 
    result = generateNewEntityID_result()
1887 
    result.read(self._iprot)
1888 
    self._iprot.readMessageEnd()
1889 
    if result.success is not None:
1890 
      return result.success
1891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1892 
 
1893 
  def addCategory(self, category):
1894 
    """
1895 
    All category related functions
1896 
 
1897 
    Parameters:
1898 
     - category
1899 
    """
1900 
    self.send_addCategory(category)
1901 
    return self.recv_addCategory()
1902 
 
1903 
  def send_addCategory(self, category):
1904 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1905 
    args = addCategory_args()
1906 
    args.category = category
1907 
    args.write(self._oprot)
1908 
    self._oprot.writeMessageEnd()
1909 
    self._oprot.trans.flush()
1910 
 
1911 
  def recv_addCategory(self, ):
1912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1913 
    if mtype == TMessageType.EXCEPTION:
1914 
      x = TApplicationException()
1915 
      x.read(self._iprot)
1916 
      self._iprot.readMessageEnd()
1917 
      raise x
1918 
    result = addCategory_result()
1919 
    result.read(self._iprot)
1920 
    self._iprot.readMessageEnd()
1921 
    if result.success is not None:
1922 
      return result.success
1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1924 
 
1925 
  def getCategory(self, id):
1926 
    """
1927 
    Parameters:
1928 
     - id
1929 
    """
1930 
    self.send_getCategory(id)
1931 
    return self.recv_getCategory()
1932 
 
1933 
  def send_getCategory(self, id):
1934 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1935 
    args = getCategory_args()
1936 
    args.id = id
1937 
    args.write(self._oprot)
1938 
    self._oprot.writeMessageEnd()
1939 
    self._oprot.trans.flush()
1940 
 
1941 
  def recv_getCategory(self, ):
1942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1943 
    if mtype == TMessageType.EXCEPTION:
1944 
      x = TApplicationException()
1945 
      x.read(self._iprot)
1946 
      self._iprot.readMessageEnd()
1947 
      raise x
1948 
    result = getCategory_result()
1949 
    result.read(self._iprot)
1950 
    self._iprot.readMessageEnd()
1951 
    if result.success is not None:
1952 
      return result.success
1953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1954 
 
1955 
  def getAllCategories(self, ):
1956 
    self.send_getAllCategories()
1957 
    return self.recv_getAllCategories()
1958 
 
1959 
  def send_getAllCategories(self, ):
1960 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1961 
    args = getAllCategories_args()
1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
1966 
  def recv_getAllCategories(self, ):
1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
1973 
    result = getAllCategories_result()
1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
1976 
    if result.success is not None:
1977 
      return result.success
1978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1979 
 
1980 
  def getAllSimilarItems(self, itemId):
1981 
    """
1982 
    Returns the list of similar items.
1983 
 
1984 
    Parameters:
1985 
     - itemId
1986 
    """
1987 
    self.send_getAllSimilarItems(itemId)
1988 
    return self.recv_getAllSimilarItems()
1989 
 
1990 
  def send_getAllSimilarItems(self, itemId):
1991 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1992 
    args = getAllSimilarItems_args()
1993 
    args.itemId = itemId
1994 
    args.write(self._oprot)
1995 
    self._oprot.writeMessageEnd()
1996 
    self._oprot.trans.flush()
1997 
 
1998 
  def recv_getAllSimilarItems(self, ):
1999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2000 
    if mtype == TMessageType.EXCEPTION:
2001 
      x = TApplicationException()
2002 
      x.read(self._iprot)
2003 
      self._iprot.readMessageEnd()
2004 
      raise x
2005 
    result = getAllSimilarItems_result()
2006 
    result.read(self._iprot)
2007 
    self._iprot.readMessageEnd()
2008 
    if result.success is not None:
2009 
      return result.success
2010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
2011 
 
2012 
  def addSimilarItem(self, itemId, catalogItemId):
2013 
    """
2014 
    Adds similar item.
2015 
 
2016 
    Parameters:
2017 
     - itemId
2018 
     - catalogItemId
2019 
    """
2020 
    self.send_addSimilarItem(itemId, catalogItemId)
2021 
    return self.recv_addSimilarItem()
2022 
 
2023 
  def send_addSimilarItem(self, itemId, catalogItemId):
2024 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
2025 
    args = addSimilarItem_args()
2026 
    args.itemId = itemId
2027 
    args.catalogItemId = catalogItemId
2028 
    args.write(self._oprot)
2029 
    self._oprot.writeMessageEnd()
2030 
    self._oprot.trans.flush()
2031 
 
2032 
  def recv_addSimilarItem(self, ):
2033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2034 
    if mtype == TMessageType.EXCEPTION:
2035 
      x = TApplicationException()
2036 
      x.read(self._iprot)
2037 
      self._iprot.readMessageEnd()
2038 
      raise x
2039 
    result = addSimilarItem_result()
2040 
    result.read(self._iprot)
2041 
    self._iprot.readMessageEnd()
2042 
    if result.success is not None:
2043 
      return result.success
2044 
    if result.cex is not None:
2045 
      raise result.cex
2046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
2047 
 
6512 kshitij.so 2048 
  def addTag(self, displayName, itemId):
2049 
    """
2050 
    Tag Related
2051 
 
2052 
    Parameters:
2053 
     - displayName
2054 
     - itemId
2055 
    """
2056 
    self.send_addTag(displayName, itemId)
2057 
    return self.recv_addTag()
2058 
 
2059 
  def send_addTag(self, displayName, itemId):
2060 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
2061 
    args = addTag_args()
2062 
    args.displayName = displayName
2063 
    args.itemId = itemId
2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
2068 
  def recv_addTag(self, ):
2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
2075 
    result = addTag_result()
2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
2078 
    if result.success is not None:
2079 
      return result.success
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
2081 
 
2082 
  def deleteEntityTag(self, displayName, itemId):
2083 
    """
2084 
    Parameters:
2085 
     - displayName
2086 
     - itemId
2087 
    """
2088 
    self.send_deleteEntityTag(displayName, itemId)
2089 
    return self.recv_deleteEntityTag()
2090 
 
2091 
  def send_deleteEntityTag(self, displayName, itemId):
2092 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
2093 
    args = deleteEntityTag_args()
2094 
    args.displayName = displayName
2095 
    args.itemId = itemId
2096 
    args.write(self._oprot)
2097 
    self._oprot.writeMessageEnd()
2098 
    self._oprot.trans.flush()
2099 
 
2100 
  def recv_deleteEntityTag(self, ):
2101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2102 
    if mtype == TMessageType.EXCEPTION:
2103 
      x = TApplicationException()
2104 
      x.read(self._iprot)
2105 
      self._iprot.readMessageEnd()
2106 
      raise x
2107 
    result = deleteEntityTag_result()
2108 
    result.read(self._iprot)
2109 
    self._iprot.readMessageEnd()
2110 
    if result.success is not None:
2111 
      return result.success
2112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
2113 
 
2114 
  def deleteTag(self, displayName):
2115 
    """
2116 
    Parameters:
2117 
     - displayName
2118 
    """
2119 
    self.send_deleteTag(displayName)
2120 
    return self.recv_deleteTag()
2121 
 
2122 
  def send_deleteTag(self, displayName):
2123 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
2124 
    args = deleteTag_args()
2125 
    args.displayName = displayName
2126 
    args.write(self._oprot)
2127 
    self._oprot.writeMessageEnd()
2128 
    self._oprot.trans.flush()
2129 
 
2130 
  def recv_deleteTag(self, ):
2131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2132 
    if mtype == TMessageType.EXCEPTION:
2133 
      x = TApplicationException()
2134 
      x.read(self._iprot)
2135 
      self._iprot.readMessageEnd()
2136 
      raise x
2137 
    result = deleteTag_result()
2138 
    result.read(self._iprot)
2139 
    self._iprot.readMessageEnd()
2140 
    if result.success is not None:
2141 
      return result.success
2142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
2143 
 
2144 
  def getAllTags(self, ):
2145 
    self.send_getAllTags()
2146 
    return self.recv_getAllTags()
2147 
 
2148 
  def send_getAllTags(self, ):
2149 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
2150 
    args = getAllTags_args()
2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
2155 
  def recv_getAllTags(self, ):
2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
2162 
    result = getAllTags_result()
2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
2165 
    if result.success is not None:
2166 
      return result.success
2167 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2168 
 
2169 
  def getAllEntitiesByTagName(self, displayName):
2170 
    """
2171 
    Parameters:
2172 
     - displayName
2173 
    """
2174 
    self.send_getAllEntitiesByTagName(displayName)
2175 
    return self.recv_getAllEntitiesByTagName()
2176 
 
2177 
  def send_getAllEntitiesByTagName(self, displayName):
2178 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2179 
    args = getAllEntitiesByTagName_args()
2180 
    args.displayName = displayName
2181 
    args.write(self._oprot)
2182 
    self._oprot.writeMessageEnd()
2183 
    self._oprot.trans.flush()
2184 
 
2185 
  def recv_getAllEntitiesByTagName(self, ):
2186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2187 
    if mtype == TMessageType.EXCEPTION:
2188 
      x = TApplicationException()
2189 
      x.read(self._iprot)
2190 
      self._iprot.readMessageEnd()
2191 
      raise x
2192 
    result = getAllEntitiesByTagName_result()
2193 
    result.read(self._iprot)
2194 
    self._iprot.readMessageEnd()
2195 
    if result.success is not None:
2196 
      return result.success
2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2198 
 
6845 amit.gupta 2199 
  def getAllEntityTags(self, ):
2200 
    self.send_getAllEntityTags()
2201 
    return self.recv_getAllEntityTags()
2202 
 
2203 
  def send_getAllEntityTags(self, ):
2204 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2205 
    args = getAllEntityTags_args()
2206 
    args.write(self._oprot)
2207 
    self._oprot.writeMessageEnd()
2208 
    self._oprot.trans.flush()
2209 
 
2210 
  def recv_getAllEntityTags(self, ):
2211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2212 
    if mtype == TMessageType.EXCEPTION:
2213 
      x = TApplicationException()
2214 
      x.read(self._iprot)
2215 
      self._iprot.readMessageEnd()
2216 
      raise x
2217 
    result = getAllEntityTags_result()
2218 
    result.read(self._iprot)
2219 
    self._iprot.readMessageEnd()
2220 
    if result.success is not None:
2221 
      return result.success
2222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2223 
 
8590 kshitij.so 2224 
  def addBanner(self, bannerCongregate):
6850 kshitij.so 2225 
    """
8579 kshitij.so 2226 
    Banner Related
2227 
 
6850 kshitij.so 2228 
    Parameters:
8590 kshitij.so 2229 
     - bannerCongregate
6850 kshitij.so 2230 
    """
8590 kshitij.so 2231 
    self.send_addBanner(bannerCongregate)
2232 
    self.recv_addBanner()
6850 kshitij.so 2233 
 
8590 kshitij.so 2234 
  def send_addBanner(self, bannerCongregate):
6850 kshitij.so 2235 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2236 
    args = addBanner_args()
8590 kshitij.so 2237 
    args.bannerCongregate = bannerCongregate
6850 kshitij.so 2238 
    args.write(self._oprot)
2239 
    self._oprot.writeMessageEnd()
2240 
    self._oprot.trans.flush()
2241 
 
2242 
  def recv_addBanner(self, ):
2243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2244 
    if mtype == TMessageType.EXCEPTION:
2245 
      x = TApplicationException()
2246 
      x.read(self._iprot)
2247 
      self._iprot.readMessageEnd()
2248 
      raise x
2249 
    result = addBanner_result()
2250 
    result.read(self._iprot)
2251 
    self._iprot.readMessageEnd()
8590 kshitij.so 2252 
    return
6850 kshitij.so 2253 
 
8579 kshitij.so 2254 
  def updateBanner(self, banner):
2255 
    """
2256 
    Parameters:
2257 
     - banner
2258 
    """
2259 
    self.send_updateBanner(banner)
2260 
    return self.recv_updateBanner()
2261 
 
2262 
  def send_updateBanner(self, banner):
2263 
    self._oprot.writeMessageBegin('updateBanner', TMessageType.CALL, self._seqid)
2264 
    args = updateBanner_args()
2265 
    args.banner = banner
2266 
    args.write(self._oprot)
2267 
    self._oprot.writeMessageEnd()
2268 
    self._oprot.trans.flush()
2269 
 
2270 
  def recv_updateBanner(self, ):
2271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2272 
    if mtype == TMessageType.EXCEPTION:
2273 
      x = TApplicationException()
2274 
      x.read(self._iprot)
2275 
      self._iprot.readMessageEnd()
2276 
      raise x
2277 
    result = updateBanner_result()
2278 
    result.read(self._iprot)
2279 
    self._iprot.readMessageEnd()
2280 
    if result.success is not None:
2281 
      return result.success
2282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBanner failed: unknown result");
2283 
 
6850 kshitij.so 2284 
  def getAllBanners(self, ):
2285 
    self.send_getAllBanners()
2286 
    return self.recv_getAllBanners()
2287 
 
2288 
  def send_getAllBanners(self, ):
2289 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2290 
    args = getAllBanners_args()
2291 
    args.write(self._oprot)
2292 
    self._oprot.writeMessageEnd()
2293 
    self._oprot.trans.flush()
2294 
 
2295 
  def recv_getAllBanners(self, ):
2296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2297 
    if mtype == TMessageType.EXCEPTION:
2298 
      x = TApplicationException()
2299 
      x.read(self._iprot)
2300 
      self._iprot.readMessageEnd()
2301 
      raise x
2302 
    result = getAllBanners_result()
2303 
    result.read(self._iprot)
2304 
    self._iprot.readMessageEnd()
2305 
    if result.success is not None:
2306 
      return result.success
2307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2308 
 
2309 
  def deleteBanner(self, bannerName):
2310 
    """
2311 
    Parameters:
2312 
     - bannerName
2313 
    """
2314 
    self.send_deleteBanner(bannerName)
2315 
    return self.recv_deleteBanner()
2316 
 
2317 
  def send_deleteBanner(self, bannerName):
2318 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2319 
    args = deleteBanner_args()
2320 
    args.bannerName = bannerName
2321 
    args.write(self._oprot)
2322 
    self._oprot.writeMessageEnd()
2323 
    self._oprot.trans.flush()
2324 
 
2325 
  def recv_deleteBanner(self, ):
2326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2327 
    if mtype == TMessageType.EXCEPTION:
2328 
      x = TApplicationException()
2329 
      x.read(self._iprot)
2330 
      self._iprot.readMessageEnd()
2331 
      raise x
2332 
    result = deleteBanner_result()
2333 
    result.read(self._iprot)
2334 
    self._iprot.readMessageEnd()
2335 
    if result.success is not None:
2336 
      return result.success
2337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2338 
 
2339 
  def getBannerDetails(self, bannerName):
2340 
    """
2341 
    Parameters:
2342 
     - bannerName
2343 
    """
2344 
    self.send_getBannerDetails(bannerName)
2345 
    return self.recv_getBannerDetails()
2346 
 
2347 
  def send_getBannerDetails(self, bannerName):
2348 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2349 
    args = getBannerDetails_args()
2350 
    args.bannerName = bannerName
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_getBannerDetails(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = getBannerDetails_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    if result.success is not None:
2366 
      return result.success
2367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2368 
 
2369 
  def getActiveBanners(self, ):
2370 
    self.send_getActiveBanners()
2371 
    return self.recv_getActiveBanners()
2372 
 
2373 
  def send_getActiveBanners(self, ):
2374 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2375 
    args = getActiveBanners_args()
2376 
    args.write(self._oprot)
2377 
    self._oprot.writeMessageEnd()
2378 
    self._oprot.trans.flush()
2379 
 
2380 
  def recv_getActiveBanners(self, ):
2381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2382 
    if mtype == TMessageType.EXCEPTION:
2383 
      x = TApplicationException()
2384 
      x.read(self._iprot)
2385 
      self._iprot.readMessageEnd()
2386 
      raise x
2387 
    result = getActiveBanners_result()
2388 
    result.read(self._iprot)
2389 
    self._iprot.readMessageEnd()
2390 
    if result.success is not None:
2391 
      return result.success
2392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2393 
 
8579 kshitij.so 2394 
  def addBannerMap(self, bannerMaps):
6849 kshitij.so 2395 
    """
2396 
    Parameters:
8579 kshitij.so 2397 
     - bannerMaps
6849 kshitij.so 2398 
    """
8579 kshitij.so 2399 
    self.send_addBannerMap(bannerMaps)
6849 kshitij.so 2400 
    return self.recv_addBannerMap()
2401 
 
8579 kshitij.so 2402 
  def send_addBannerMap(self, bannerMaps):
6849 kshitij.so 2403 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2404 
    args = addBannerMap_args()
8579 kshitij.so 2405 
    args.bannerMaps = bannerMaps
6849 kshitij.so 2406 
    args.write(self._oprot)
2407 
    self._oprot.writeMessageEnd()
2408 
    self._oprot.trans.flush()
2409 
 
2410 
  def recv_addBannerMap(self, ):
2411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2412 
    if mtype == TMessageType.EXCEPTION:
2413 
      x = TApplicationException()
2414 
      x.read(self._iprot)
2415 
      self._iprot.readMessageEnd()
2416 
      raise x
2417 
    result = addBannerMap_result()
2418 
    result.read(self._iprot)
2419 
    self._iprot.readMessageEnd()
2420 
    if result.success is not None:
2421 
      return result.success
2422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2423 
 
8579 kshitij.so 2424 
  def updateBannerMap(self, bannerMap):
2425 
    """
2426 
    Parameters:
2427 
     - bannerMap
2428 
    """
2429 
    self.send_updateBannerMap(bannerMap)
2430 
    return self.recv_updateBannerMap()
2431 
 
2432 
  def send_updateBannerMap(self, bannerMap):
2433 
    self._oprot.writeMessageBegin('updateBannerMap', TMessageType.CALL, self._seqid)
2434 
    args = updateBannerMap_args()
2435 
    args.bannerMap = bannerMap
2436 
    args.write(self._oprot)
2437 
    self._oprot.writeMessageEnd()
2438 
    self._oprot.trans.flush()
2439 
 
2440 
  def recv_updateBannerMap(self, ):
2441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2442 
    if mtype == TMessageType.EXCEPTION:
2443 
      x = TApplicationException()
2444 
      x.read(self._iprot)
2445 
      self._iprot.readMessageEnd()
2446 
      raise x
2447 
    result = updateBannerMap_result()
2448 
    result.read(self._iprot)
2449 
    self._iprot.readMessageEnd()
2450 
    if result.success is not None:
2451 
      return result.success
2452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateBannerMap failed: unknown result");
2453 
 
6849 kshitij.so 2454 
  def deleteBannerMap(self, bannerName):
2455 
    """
2456 
    Parameters:
2457 
     - bannerName
2458 
    """
2459 
    self.send_deleteBannerMap(bannerName)
2460 
    return self.recv_deleteBannerMap()
2461 
 
2462 
  def send_deleteBannerMap(self, bannerName):
2463 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2464 
    args = deleteBannerMap_args()
2465 
    args.bannerName = bannerName
2466 
    args.write(self._oprot)
2467 
    self._oprot.writeMessageEnd()
2468 
    self._oprot.trans.flush()
2469 
 
2470 
  def recv_deleteBannerMap(self, ):
2471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2472 
    if mtype == TMessageType.EXCEPTION:
2473 
      x = TApplicationException()
2474 
      x.read(self._iprot)
2475 
      self._iprot.readMessageEnd()
2476 
      raise x
2477 
    result = deleteBannerMap_result()
2478 
    result.read(self._iprot)
2479 
    self._iprot.readMessageEnd()
2480 
    if result.success is not None:
2481 
      return result.success
2482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2483 
 
2484 
  def getBannerMapDetails(self, bannerName):
2485 
    """
2486 
    Parameters:
2487 
     - bannerName
2488 
    """
2489 
    self.send_getBannerMapDetails(bannerName)
2490 
    return self.recv_getBannerMapDetails()
2491 
 
2492 
  def send_getBannerMapDetails(self, bannerName):
2493 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2494 
    args = getBannerMapDetails_args()
2495 
    args.bannerName = bannerName
2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
2500 
  def recv_getBannerMapDetails(self, ):
2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
2507 
    result = getBannerMapDetails_result()
2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
2510 
    if result.success is not None:
2511 
      return result.success
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2513 
 
8579 kshitij.so 2514 
  def addBannerUri(self, bannerUriMappings):
2515 
    """
2516 
    Parameters:
2517 
     - bannerUriMappings
2518 
    """
2519 
    self.send_addBannerUri(bannerUriMappings)
2520 
    self.recv_addBannerUri()
2521 
 
2522 
  def send_addBannerUri(self, bannerUriMappings):
2523 
    self._oprot.writeMessageBegin('addBannerUri', TMessageType.CALL, self._seqid)
2524 
    args = addBannerUri_args()
2525 
    args.bannerUriMappings = bannerUriMappings
2526 
    args.write(self._oprot)
2527 
    self._oprot.writeMessageEnd()
2528 
    self._oprot.trans.flush()
2529 
 
2530 
  def recv_addBannerUri(self, ):
2531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2532 
    if mtype == TMessageType.EXCEPTION:
2533 
      x = TApplicationException()
2534 
      x.read(self._iprot)
2535 
      self._iprot.readMessageEnd()
2536 
      raise x
2537 
    result = addBannerUri_result()
2538 
    result.read(self._iprot)
2539 
    self._iprot.readMessageEnd()
2540 
    return
2541 
 
2542 
  def getUriMapping(self, bannerName):
2543 
    """
2544 
    Parameters:
2545 
     - bannerName
2546 
    """
2547 
    self.send_getUriMapping(bannerName)
2548 
    return self.recv_getUriMapping()
2549 
 
2550 
  def send_getUriMapping(self, bannerName):
2551 
    self._oprot.writeMessageBegin('getUriMapping', TMessageType.CALL, self._seqid)
2552 
    args = getUriMapping_args()
2553 
    args.bannerName = bannerName
2554 
    args.write(self._oprot)
2555 
    self._oprot.writeMessageEnd()
2556 
    self._oprot.trans.flush()
2557 
 
2558 
  def recv_getUriMapping(self, ):
2559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2560 
    if mtype == TMessageType.EXCEPTION:
2561 
      x = TApplicationException()
2562 
      x.read(self._iprot)
2563 
      self._iprot.readMessageEnd()
2564 
      raise x
2565 
    result = getUriMapping_result()
2566 
    result.read(self._iprot)
2567 
    self._iprot.readMessageEnd()
2568 
    if result.success is not None:
2569 
      return result.success
2570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUriMapping failed: unknown result");
2571 
 
2572 
  def addCampaign(self, campaign):
2573 
    """
2574 
    Parameters:
2575 
     - campaign
2576 
    """
2577 
    self.send_addCampaign(campaign)
2578 
    self.recv_addCampaign()
2579 
 
2580 
  def send_addCampaign(self, campaign):
2581 
    self._oprot.writeMessageBegin('addCampaign', TMessageType.CALL, self._seqid)
2582 
    args = addCampaign_args()
2583 
    args.campaign = campaign
2584 
    args.write(self._oprot)
2585 
    self._oprot.writeMessageEnd()
2586 
    self._oprot.trans.flush()
2587 
 
2588 
  def recv_addCampaign(self, ):
2589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2590 
    if mtype == TMessageType.EXCEPTION:
2591 
      x = TApplicationException()
2592 
      x.read(self._iprot)
2593 
      self._iprot.readMessageEnd()
2594 
      raise x
2595 
    result = addCampaign_result()
2596 
    result.read(self._iprot)
2597 
    self._iprot.readMessageEnd()
2598 
    return
2599 
 
2600 
  def getCampaigns(self, campaignName):
2601 
    """
2602 
    Parameters:
2603 
     - campaignName
2604 
    """
2605 
    self.send_getCampaigns(campaignName)
2606 
    return self.recv_getCampaigns()
2607 
 
2608 
  def send_getCampaigns(self, campaignName):
2609 
    self._oprot.writeMessageBegin('getCampaigns', TMessageType.CALL, self._seqid)
2610 
    args = getCampaigns_args()
2611 
    args.campaignName = campaignName
2612 
    args.write(self._oprot)
2613 
    self._oprot.writeMessageEnd()
2614 
    self._oprot.trans.flush()
2615 
 
2616 
  def recv_getCampaigns(self, ):
2617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2618 
    if mtype == TMessageType.EXCEPTION:
2619 
      x = TApplicationException()
2620 
      x.read(self._iprot)
2621 
      self._iprot.readMessageEnd()
2622 
      raise x
2623 
    result = getCampaigns_result()
2624 
    result.read(self._iprot)
2625 
    self._iprot.readMessageEnd()
2626 
    if result.success is not None:
2627 
      return result.success
2628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCampaigns failed: unknown result");
2629 
 
2630 
  def deleteCampaign(self, campaignId):
2631 
    """
2632 
    Parameters:
2633 
     - campaignId
2634 
    """
2635 
    self.send_deleteCampaign(campaignId)
2636 
    self.recv_deleteCampaign()
2637 
 
2638 
  def send_deleteCampaign(self, campaignId):
2639 
    self._oprot.writeMessageBegin('deleteCampaign', TMessageType.CALL, self._seqid)
2640 
    args = deleteCampaign_args()
2641 
    args.campaignId = campaignId
2642 
    args.write(self._oprot)
2643 
    self._oprot.writeMessageEnd()
2644 
    self._oprot.trans.flush()
2645 
 
2646 
  def recv_deleteCampaign(self, ):
2647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2648 
    if mtype == TMessageType.EXCEPTION:
2649 
      x = TApplicationException()
2650 
      x.read(self._iprot)
2651 
      self._iprot.readMessageEnd()
2652 
      raise x
2653 
    result = deleteCampaign_result()
2654 
    result.read(self._iprot)
2655 
    self._iprot.readMessageEnd()
2656 
    return
2657 
 
2658 
  def getAllCampaigns(self, ):
2659 
    self.send_getAllCampaigns()
2660 
    return self.recv_getAllCampaigns()
2661 
 
2662 
  def send_getAllCampaigns(self, ):
2663 
    self._oprot.writeMessageBegin('getAllCampaigns', TMessageType.CALL, self._seqid)
2664 
    args = getAllCampaigns_args()
2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
2669 
  def recv_getAllCampaigns(self, ):
2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
2676 
    result = getAllCampaigns_result()
2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
2679 
    if result.success is not None:
2680 
      return result.success
2681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCampaigns failed: unknown result");
2682 
 
5944 mandeep.dh 2683 
  def deleteSimilarItem(self, itemId, catalogItemId):
2684 
    """
2685 
    Delete similar item.
2686 
 
2687 
    Parameters:
2688 
     - itemId
2689 
     - catalogItemId
2690 
    """
2691 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2692 
    return self.recv_deleteSimilarItem()
2693 
 
2694 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2695 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2696 
    args = deleteSimilarItem_args()
2697 
    args.itemId = itemId
2698 
    args.catalogItemId = catalogItemId
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
2703 
  def recv_deleteSimilarItem(self, ):
2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
2710 
    result = deleteSimilarItem_result()
2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
2713 
    if result.success is not None:
2714 
      return result.success
2715 
    if result.cex is not None:
2716 
      raise result.cex
2717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2718 
 
2719 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2720 
    """
2721 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2722 
    If yes, returns the itemId else returns 0
2723 
 
2724 
    Parameters:
2725 
     - brand
2726 
     - modelNumber
2727 
     - modelName
2728 
     - color
2729 
    """
2730 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2731 
    return self.recv_checkSimilarItem()
2732 
 
2733 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2734 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2735 
    args = checkSimilarItem_args()
2736 
    args.brand = brand
2737 
    args.modelNumber = modelNumber
2738 
    args.modelName = modelName
2739 
    args.color = color
2740 
    args.write(self._oprot)
2741 
    self._oprot.writeMessageEnd()
2742 
    self._oprot.trans.flush()
2743 
 
2744 
  def recv_checkSimilarItem(self, ):
2745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2746 
    if mtype == TMessageType.EXCEPTION:
2747 
      x = TApplicationException()
2748 
      x.read(self._iprot)
2749 
      self._iprot.readMessageEnd()
2750 
      raise x
2751 
    result = checkSimilarItem_result()
2752 
    result.read(self._iprot)
2753 
    self._iprot.readMessageEnd()
2754 
    if result.success is not None:
2755 
      return result.success
2756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2757 
 
2758 
  def validateRiskyStatus(self, itemId):
2759 
    """
2760 
    Check wether item is risky and change status if inventory is not available for risky items
2761 
 
2762 
    Parameters:
2763 
     - itemId
2764 
    """
2765 
    self.send_validateRiskyStatus(itemId)
2766 
    self.recv_validateRiskyStatus()
2767 
 
2768 
  def send_validateRiskyStatus(self, itemId):
2769 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2770 
    args = validateRiskyStatus_args()
2771 
    args.itemId = itemId
2772 
    args.write(self._oprot)
2773 
    self._oprot.writeMessageEnd()
2774 
    self._oprot.trans.flush()
2775 
 
2776 
  def recv_validateRiskyStatus(self, ):
2777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2778 
    if mtype == TMessageType.EXCEPTION:
2779 
      x = TApplicationException()
2780 
      x.read(self._iprot)
2781 
      self._iprot.readMessageEnd()
2782 
      raise x
2783 
    result = validateRiskyStatus_result()
2784 
    result.read(self._iprot)
2785 
    self._iprot.readMessageEnd()
2786 
    return
2787 
 
2788 
  def changeItemRiskyFlag(self, itemId, risky):
2789 
    """
2790 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2791 
 
2792 
    Parameters:
2793 
     - itemId
2794 
     - risky
2795 
    """
2796 
    self.send_changeItemRiskyFlag(itemId, risky)
2797 
    self.recv_changeItemRiskyFlag()
2798 
 
2799 
  def send_changeItemRiskyFlag(self, itemId, risky):
2800 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2801 
    args = changeItemRiskyFlag_args()
2802 
    args.itemId = itemId
2803 
    args.risky = risky
2804 
    args.write(self._oprot)
2805 
    self._oprot.writeMessageEnd()
2806 
    self._oprot.trans.flush()
2807 
 
2808 
  def recv_changeItemRiskyFlag(self, ):
2809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2810 
    if mtype == TMessageType.EXCEPTION:
2811 
      x = TApplicationException()
2812 
      x.read(self._iprot)
2813 
      self._iprot.readMessageEnd()
2814 
      raise x
2815 
    result = changeItemRiskyFlag_result()
2816 
    result.read(self._iprot)
2817 
    self._iprot.readMessageEnd()
2818 
    return
2819 
 
2820 
  def getItemsByRiskyFlag(self, ):
2821 
    """
2822 
    Returns list of items marked as risky.
2823 
    """
2824 
    self.send_getItemsByRiskyFlag()
2825 
    return self.recv_getItemsByRiskyFlag()
2826 
 
2827 
  def send_getItemsByRiskyFlag(self, ):
2828 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2829 
    args = getItemsByRiskyFlag_args()
2830 
    args.write(self._oprot)
2831 
    self._oprot.writeMessageEnd()
2832 
    self._oprot.trans.flush()
2833 
 
2834 
  def recv_getItemsByRiskyFlag(self, ):
2835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2836 
    if mtype == TMessageType.EXCEPTION:
2837 
      x = TApplicationException()
2838 
      x.read(self._iprot)
2839 
      self._iprot.readMessageEnd()
2840 
      raise x
2841 
    result = getItemsByRiskyFlag_result()
2842 
    result.read(self._iprot)
2843 
    self._iprot.readMessageEnd()
2844 
    if result.success is not None:
2845 
      return result.success
2846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2847 
 
2848 
  def getItemsForMasterSheet(self, category, brand):
2849 
    """
2850 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2851 
 
2852 
    Parameters:
2853 
     - category
2854 
     - brand
2855 
    """
2856 
    self.send_getItemsForMasterSheet(category, brand)
2857 
    return self.recv_getItemsForMasterSheet()
2858 
 
2859 
  def send_getItemsForMasterSheet(self, category, brand):
2860 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2861 
    args = getItemsForMasterSheet_args()
2862 
    args.category = category
2863 
    args.brand = brand
2864 
    args.write(self._oprot)
2865 
    self._oprot.writeMessageEnd()
2866 
    self._oprot.trans.flush()
2867 
 
2868 
  def recv_getItemsForMasterSheet(self, ):
2869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2870 
    if mtype == TMessageType.EXCEPTION:
2871 
      x = TApplicationException()
2872 
      x.read(self._iprot)
2873 
      self._iprot.readMessageEnd()
2874 
      raise x
2875 
    result = getItemsForMasterSheet_result()
2876 
    result.read(self._iprot)
2877 
    self._iprot.readMessageEnd()
2878 
    if result.success is not None:
2879 
      return result.success
2880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2881 
 
2882 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2883 
    """
2884 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2885 
 
2886 
    Parameters:
2887 
     - beginIndex
2888 
     - totalItems
2889 
     - itemId
2890 
    """
2891 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2892 
    return self.recv_getSimilarItemsCatalogIds()
2893 
 
2894 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2895 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2896 
    args = getSimilarItemsCatalogIds_args()
2897 
    args.beginIndex = beginIndex
2898 
    args.totalItems = totalItems
2899 
    args.itemId = itemId
2900 
    args.write(self._oprot)
2901 
    self._oprot.writeMessageEnd()
2902 
    self._oprot.trans.flush()
2903 
 
2904 
  def recv_getSimilarItemsCatalogIds(self, ):
2905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2906 
    if mtype == TMessageType.EXCEPTION:
2907 
      x = TApplicationException()
2908 
      x.read(self._iprot)
2909 
      self._iprot.readMessageEnd()
2910 
      raise x
2911 
    result = getSimilarItemsCatalogIds_result()
2912 
    result.read(self._iprot)
2913 
    self._iprot.readMessageEnd()
2914 
    if result.success is not None:
2915 
      return result.success
2916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2917 
 
2918 
  def addProductNotification(self, itemId, email):
2919 
    """
2920 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2921 
 
2922 
    Parameters:
2923 
     - itemId
2924 
     - email
2925 
    """
2926 
    self.send_addProductNotification(itemId, email)
2927 
    return self.recv_addProductNotification()
2928 
 
2929 
  def send_addProductNotification(self, itemId, email):
2930 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2931 
    args = addProductNotification_args()
2932 
    args.itemId = itemId
2933 
    args.email = email
2934 
    args.write(self._oprot)
2935 
    self._oprot.writeMessageEnd()
2936 
    self._oprot.trans.flush()
2937 
 
2938 
  def recv_addProductNotification(self, ):
2939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2940 
    if mtype == TMessageType.EXCEPTION:
2941 
      x = TApplicationException()
2942 
      x.read(self._iprot)
2943 
      self._iprot.readMessageEnd()
2944 
      raise x
2945 
    result = addProductNotification_result()
2946 
    result.read(self._iprot)
2947 
    self._iprot.readMessageEnd()
2948 
    if result.success is not None:
2949 
      return result.success
2950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2951 
 
2952 
  def sendProductNotifications(self, ):
2953 
    """
2954 
    Send the product notifications to the users for items which has stock.
2955 
    """
2956 
    self.send_sendProductNotifications()
2957 
    return self.recv_sendProductNotifications()
2958 
 
2959 
  def send_sendProductNotifications(self, ):
2960 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2961 
    args = sendProductNotifications_args()
2962 
    args.write(self._oprot)
2963 
    self._oprot.writeMessageEnd()
2964 
    self._oprot.trans.flush()
2965 
 
2966 
  def recv_sendProductNotifications(self, ):
2967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2968 
    if mtype == TMessageType.EXCEPTION:
2969 
      x = TApplicationException()
2970 
      x.read(self._iprot)
2971 
      self._iprot.readMessageEnd()
2972 
      raise x
2973 
    result = sendProductNotifications_result()
2974 
    result.read(self._iprot)
2975 
    self._iprot.readMessageEnd()
2976 
    if result.success is not None:
2977 
      return result.success
2978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2979 
 
2980 
  def getAllBrandsByCategory(self, categoryId):
2981 
    """
2982 
    Returns list of brand names for a given category Id
2983 
 
2984 
    Parameters:
2985 
     - categoryId
2986 
    """
2987 
    self.send_getAllBrandsByCategory(categoryId)
2988 
    return self.recv_getAllBrandsByCategory()
2989 
 
2990 
  def send_getAllBrandsByCategory(self, categoryId):
2991 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2992 
    args = getAllBrandsByCategory_args()
2993 
    args.categoryId = categoryId
2994 
    args.write(self._oprot)
2995 
    self._oprot.writeMessageEnd()
2996 
    self._oprot.trans.flush()
2997 
 
2998 
  def recv_getAllBrandsByCategory(self, ):
2999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3000 
    if mtype == TMessageType.EXCEPTION:
3001 
      x = TApplicationException()
3002 
      x.read(self._iprot)
3003 
      self._iprot.readMessageEnd()
3004 
      raise x
3005 
    result = getAllBrandsByCategory_result()
3006 
    result.read(self._iprot)
3007 
    self._iprot.readMessageEnd()
3008 
    if result.success is not None:
3009 
      return result.success
3010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
3011 
 
3012 
  def getAllBrands(self, ):
3013 
    """
3014 
    Returns list of brand names
3015 
    """
3016 
    self.send_getAllBrands()
3017 
    return self.recv_getAllBrands()
3018 
 
3019 
  def send_getAllBrands(self, ):
3020 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
3021 
    args = getAllBrands_args()
3022 
    args.write(self._oprot)
3023 
    self._oprot.writeMessageEnd()
3024 
    self._oprot.trans.flush()
3025 
 
3026 
  def recv_getAllBrands(self, ):
3027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3028 
    if mtype == TMessageType.EXCEPTION:
3029 
      x = TApplicationException()
3030 
      x.read(self._iprot)
3031 
      self._iprot.readMessageEnd()
3032 
      raise x
3033 
    result = getAllBrands_result()
3034 
    result.read(self._iprot)
3035 
    self._iprot.readMessageEnd()
3036 
    if result.success is not None:
3037 
      return result.success
3038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
3039 
 
3040 
  def getAllSources(self, ):
3041 
    """
3042 
    Return list of all sources
3043 
    """
3044 
    self.send_getAllSources()
3045 
    return self.recv_getAllSources()
3046 
 
3047 
  def send_getAllSources(self, ):
3048 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
3049 
    args = getAllSources_args()
3050 
    args.write(self._oprot)
3051 
    self._oprot.writeMessageEnd()
3052 
    self._oprot.trans.flush()
3053 
 
3054 
  def recv_getAllSources(self, ):
3055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3056 
    if mtype == TMessageType.EXCEPTION:
3057 
      x = TApplicationException()
3058 
      x.read(self._iprot)
3059 
      self._iprot.readMessageEnd()
3060 
      raise x
3061 
    result = getAllSources_result()
3062 
    result.read(self._iprot)
3063 
    self._iprot.readMessageEnd()
3064 
    if result.success is not None:
3065 
      return result.success
3066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
3067 
 
3068 
  def getItemPricingBySource(self, itemId, sourceId):
3069 
    """
3070 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
3071 
 
3072 
    Parameters:
3073 
     - itemId
3074 
     - sourceId
3075 
    """
3076 
    self.send_getItemPricingBySource(itemId, sourceId)
3077 
    return self.recv_getItemPricingBySource()
3078 
 
3079 
  def send_getItemPricingBySource(self, itemId, sourceId):
3080 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
3081 
    args = getItemPricingBySource_args()
3082 
    args.itemId = itemId
3083 
    args.sourceId = sourceId
3084 
    args.write(self._oprot)
3085 
    self._oprot.writeMessageEnd()
3086 
    self._oprot.trans.flush()
3087 
 
3088 
  def recv_getItemPricingBySource(self, ):
3089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3090 
    if mtype == TMessageType.EXCEPTION:
3091 
      x = TApplicationException()
3092 
      x.read(self._iprot)
3093 
      self._iprot.readMessageEnd()
3094 
      raise x
3095 
    result = getItemPricingBySource_result()
3096 
    result.read(self._iprot)
3097 
    self._iprot.readMessageEnd()
3098 
    if result.success is not None:
3099 
      return result.success
3100 
    if result.cex is not None:
3101 
      raise result.cex
3102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
3103 
 
3104 
  def addSourceItemPricing(self, sourceItemPricing):
3105 
    """
3106 
    Adds prices to be displayed corresponding to the item if user comes from a source.
3107 
    If item is not found or source is not found, it will throw exception.
3108 
 
3109 
    Parameters:
3110 
     - sourceItemPricing
3111 
    """
3112 
    self.send_addSourceItemPricing(sourceItemPricing)
3113 
    self.recv_addSourceItemPricing()
3114 
 
3115 
  def send_addSourceItemPricing(self, sourceItemPricing):
3116 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
3117 
    args = addSourceItemPricing_args()
3118 
    args.sourceItemPricing = sourceItemPricing
3119 
    args.write(self._oprot)
3120 
    self._oprot.writeMessageEnd()
3121 
    self._oprot.trans.flush()
3122 
 
3123 
  def recv_addSourceItemPricing(self, ):
3124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3125 
    if mtype == TMessageType.EXCEPTION:
3126 
      x = TApplicationException()
3127 
      x.read(self._iprot)
3128 
      self._iprot.readMessageEnd()
3129 
      raise x
3130 
    result = addSourceItemPricing_result()
3131 
    result.read(self._iprot)
3132 
    self._iprot.readMessageEnd()
3133 
    if result.cex is not None:
3134 
      raise result.cex
3135 
    return
3136 
 
3137 
  def getAllSourcePricing(self, itemId):
3138 
    """
3139 
    Returns the list of source pricing information of an item.
3140 
    Raises an exception if item not found corresponding to itemId
3141 
 
3142 
    Parameters:
3143 
     - itemId
3144 
    """
3145 
    self.send_getAllSourcePricing(itemId)
3146 
    return self.recv_getAllSourcePricing()
3147 
 
3148 
  def send_getAllSourcePricing(self, itemId):
3149 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
3150 
    args = getAllSourcePricing_args()
3151 
    args.itemId = itemId
3152 
    args.write(self._oprot)
3153 
    self._oprot.writeMessageEnd()
3154 
    self._oprot.trans.flush()
3155 
 
3156 
  def recv_getAllSourcePricing(self, ):
3157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3158 
    if mtype == TMessageType.EXCEPTION:
3159 
      x = TApplicationException()
3160 
      x.read(self._iprot)
3161 
      self._iprot.readMessageEnd()
3162 
      raise x
3163 
    result = getAllSourcePricing_result()
3164 
    result.read(self._iprot)
3165 
    self._iprot.readMessageEnd()
3166 
    if result.success is not None:
3167 
      return result.success
3168 
    if result.cex is not None:
3169 
      raise result.cex
3170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
3171 
 
3172 
  def getItemForSource(self, item_id, sourceId):
3173 
    """
3174 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
3175 
 
3176 
    Parameters:
3177 
     - item_id
3178 
     - sourceId
3179 
    """
3180 
    self.send_getItemForSource(item_id, sourceId)
3181 
    return self.recv_getItemForSource()
3182 
 
3183 
  def send_getItemForSource(self, item_id, sourceId):
3184 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
3185 
    args = getItemForSource_args()
3186 
    args.item_id = item_id
3187 
    args.sourceId = sourceId
3188 
    args.write(self._oprot)
3189 
    self._oprot.writeMessageEnd()
3190 
    self._oprot.trans.flush()
3191 
 
3192 
  def recv_getItemForSource(self, ):
3193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3194 
    if mtype == TMessageType.EXCEPTION:
3195 
      x = TApplicationException()
3196 
      x.read(self._iprot)
3197 
      self._iprot.readMessageEnd()
3198 
      raise x
3199 
    result = getItemForSource_result()
3200 
    result.read(self._iprot)
3201 
    self._iprot.readMessageEnd()
3202 
    if result.success is not None:
3203 
      return result.success
3204 
    if result.cex is not None:
3205 
      raise result.cex
3206 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
3207 
 
3208 
  def searchItemsInRange(self, searchTerms, offset, limit):
3209 
    """
3210 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
3211 
 
3212 
    Parameters:
3213 
     - searchTerms
3214 
     - offset
3215 
     - limit
3216 
    """
3217 
    self.send_searchItemsInRange(searchTerms, offset, limit)
3218 
    return self.recv_searchItemsInRange()
3219 
 
3220 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
3221 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
3222 
    args = searchItemsInRange_args()
3223 
    args.searchTerms = searchTerms
3224 
    args.offset = offset
3225 
    args.limit = limit
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_searchItemsInRange(self, ):
3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3237 
    result = searchItemsInRange_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3240 
    if result.success is not None:
3241 
      return result.success
3242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
3243 
 
3244 
  def getSearchResultCount(self, searchTerms):
3245 
    """
3246 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
3247 
 
3248 
    Parameters:
3249 
     - searchTerms
3250 
    """
3251 
    self.send_getSearchResultCount(searchTerms)
3252 
    return self.recv_getSearchResultCount()
3253 
 
3254 
  def send_getSearchResultCount(self, searchTerms):
3255 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
3256 
    args = getSearchResultCount_args()
3257 
    args.searchTerms = searchTerms
3258 
    args.write(self._oprot)
3259 
    self._oprot.writeMessageEnd()
3260 
    self._oprot.trans.flush()
3261 
 
3262 
  def recv_getSearchResultCount(self, ):
3263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3264 
    if mtype == TMessageType.EXCEPTION:
3265 
      x = TApplicationException()
3266 
      x.read(self._iprot)
3267 
      self._iprot.readMessageEnd()
3268 
      raise x
3269 
    result = getSearchResultCount_result()
3270 
    result.read(self._iprot)
3271 
    self._iprot.readMessageEnd()
3272 
    if result.success is not None:
3273 
      return result.success
3274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
3275 
 
3276 
  def getProductNotifications(self, startDateTime):
3277 
    """
3278 
    Returns a list of product notifications added after a supplied datetime
3279 
 
3280 
    Parameters:
3281 
     - startDateTime
3282 
    """
3283 
    self.send_getProductNotifications(startDateTime)
3284 
    return self.recv_getProductNotifications()
3285 
 
3286 
  def send_getProductNotifications(self, startDateTime):
3287 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
3288 
    args = getProductNotifications_args()
3289 
    args.startDateTime = startDateTime
3290 
    args.write(self._oprot)
3291 
    self._oprot.writeMessageEnd()
3292 
    self._oprot.trans.flush()
3293 
 
3294 
  def recv_getProductNotifications(self, ):
3295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3296 
    if mtype == TMessageType.EXCEPTION:
3297 
      x = TApplicationException()
3298 
      x.read(self._iprot)
3299 
      self._iprot.readMessageEnd()
3300 
      raise x
3301 
    result = getProductNotifications_result()
3302 
    result.read(self._iprot)
3303 
    self._iprot.readMessageEnd()
3304 
    if result.success is not None:
3305 
      return result.success
3306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
3307 
 
7897 amar.kumar 3308 
  def getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3309 
    """
3310 
    Returns a list of count of requests for product notification against each item
3311 
 
3312 
    Parameters:
3313 
     - startDateTime
7897 amar.kumar 3314 
     - categoryId
5944 mandeep.dh 3315 
    """
7897 amar.kumar 3316 
    self.send_getProductNotificationRequestCount(startDateTime, categoryId)
5944 mandeep.dh 3317 
    return self.recv_getProductNotificationRequestCount()
3318 
 
7897 amar.kumar 3319 
  def send_getProductNotificationRequestCount(self, startDateTime, categoryId):
5944 mandeep.dh 3320 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
3321 
    args = getProductNotificationRequestCount_args()
3322 
    args.startDateTime = startDateTime
7897 amar.kumar 3323 
    args.categoryId = categoryId
5944 mandeep.dh 3324 
    args.write(self._oprot)
3325 
    self._oprot.writeMessageEnd()
3326 
    self._oprot.trans.flush()
3327 
 
3328 
  def recv_getProductNotificationRequestCount(self, ):
3329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3330 
    if mtype == TMessageType.EXCEPTION:
3331 
      x = TApplicationException()
3332 
      x.read(self._iprot)
3333 
      self._iprot.readMessageEnd()
3334 
      raise x
3335 
    result = getProductNotificationRequestCount_result()
3336 
    result.read(self._iprot)
3337 
    self._iprot.readMessageEnd()
3338 
    if result.success is not None:
3339 
      return result.success
3340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
3341 
 
3342 
  def addAuthorizationLog(self, itemId, username, reason):
3343 
    """
3344 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
3345 
 
3346 
    Parameters:
3347 
     - itemId
3348 
     - username
3349 
     - reason
3350 
    """
3351 
    self.send_addAuthorizationLog(itemId, username, reason)
3352 
    return self.recv_addAuthorizationLog()
3353 
 
3354 
  def send_addAuthorizationLog(self, itemId, username, reason):
3355 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
3356 
    args = addAuthorizationLog_args()
3357 
    args.itemId = itemId
3358 
    args.username = username
3359 
    args.reason = reason
3360 
    args.write(self._oprot)
3361 
    self._oprot.writeMessageEnd()
3362 
    self._oprot.trans.flush()
3363 
 
3364 
  def recv_addAuthorizationLog(self, ):
3365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3366 
    if mtype == TMessageType.EXCEPTION:
3367 
      x = TApplicationException()
3368 
      x.read(self._iprot)
3369 
      self._iprot.readMessageEnd()
3370 
      raise x
3371 
    result = addAuthorizationLog_result()
3372 
    result.read(self._iprot)
3373 
    self._iprot.readMessageEnd()
3374 
    if result.success is not None:
3375 
      return result.success
3376 
    if result.cex is not None:
3377 
      raise result.cex
3378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3379 
 
3380 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3381 
    """
3382 
    Parameters:
3383 
     - catalog_item_id
3384 
     - voucherType
3385 
     - voucherAmount
3386 
    """
3387 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3388 
    return self.recv_addupdateVoucherForItem()
3389 
 
3390 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3391 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3392 
    args = addupdateVoucherForItem_args()
3393 
    args.catalog_item_id = catalog_item_id
3394 
    args.voucherType = voucherType
3395 
    args.voucherAmount = voucherAmount
3396 
    args.write(self._oprot)
3397 
    self._oprot.writeMessageEnd()
3398 
    self._oprot.trans.flush()
3399 
 
3400 
  def recv_addupdateVoucherForItem(self, ):
3401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3402 
    if mtype == TMessageType.EXCEPTION:
3403 
      x = TApplicationException()
3404 
      x.read(self._iprot)
3405 
      self._iprot.readMessageEnd()
3406 
      raise x
3407 
    result = addupdateVoucherForItem_result()
3408 
    result.read(self._iprot)
3409 
    self._iprot.readMessageEnd()
3410 
    if result.success is not None:
3411 
      return result.success
3412 
    if result.cex is not None:
3413 
      raise result.cex
3414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3415 
 
3416 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3417 
    """
3418 
    Parameters:
3419 
     - catalog_item_id
3420 
     - voucherType
3421 
    """
3422 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3423 
    return self.recv_deleteVoucherForItem()
3424 
 
3425 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3426 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3427 
    args = deleteVoucherForItem_args()
3428 
    args.catalog_item_id = catalog_item_id
3429 
    args.voucherType = voucherType
3430 
    args.write(self._oprot)
3431 
    self._oprot.writeMessageEnd()
3432 
    self._oprot.trans.flush()
3433 
 
3434 
  def recv_deleteVoucherForItem(self, ):
3435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3436 
    if mtype == TMessageType.EXCEPTION:
3437 
      x = TApplicationException()
3438 
      x.read(self._iprot)
3439 
      self._iprot.readMessageEnd()
3440 
      raise x
3441 
    result = deleteVoucherForItem_result()
3442 
    result.read(self._iprot)
3443 
    self._iprot.readMessageEnd()
3444 
    if result.success is not None:
3445 
      return result.success
3446 
    if result.cex is not None:
3447 
      raise result.cex
3448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3449 
 
3450 
  def getVoucherAmount(self, itemId, voucherType):
3451 
    """
3452 
    Parameters:
3453 
     - itemId
3454 
     - voucherType
3455 
    """
3456 
    self.send_getVoucherAmount(itemId, voucherType)
3457 
    return self.recv_getVoucherAmount()
3458 
 
3459 
  def send_getVoucherAmount(self, itemId, voucherType):
3460 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3461 
    args = getVoucherAmount_args()
3462 
    args.itemId = itemId
3463 
    args.voucherType = voucherType
3464 
    args.write(self._oprot)
3465 
    self._oprot.writeMessageEnd()
3466 
    self._oprot.trans.flush()
3467 
 
3468 
  def recv_getVoucherAmount(self, ):
3469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3470 
    if mtype == TMessageType.EXCEPTION:
3471 
      x = TApplicationException()
3472 
      x.read(self._iprot)
3473 
      self._iprot.readMessageEnd()
3474 
      raise x
3475 
    result = getVoucherAmount_result()
3476 
    result.read(self._iprot)
3477 
    self._iprot.readMessageEnd()
3478 
    if result.success is not None:
3479 
      return result.success
3480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3481 
 
3482 
  def getAllItemVouchers(self, itemId):
3483 
    """
3484 
    Parameters:
3485 
     - itemId
3486 
    """
3487 
    self.send_getAllItemVouchers(itemId)
3488 
    return self.recv_getAllItemVouchers()
3489 
 
3490 
  def send_getAllItemVouchers(self, itemId):
3491 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3492 
    args = getAllItemVouchers_args()
3493 
    args.itemId = itemId
3494 
    args.write(self._oprot)
3495 
    self._oprot.writeMessageEnd()
3496 
    self._oprot.trans.flush()
3497 
 
3498 
  def recv_getAllItemVouchers(self, ):
3499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3500 
    if mtype == TMessageType.EXCEPTION:
3501 
      x = TApplicationException()
3502 
      x.read(self._iprot)
3503 
      self._iprot.readMessageEnd()
3504 
      raise x
3505 
    result = getAllItemVouchers_result()
3506 
    result.read(self._iprot)
3507 
    self._iprot.readMessageEnd()
3508 
    if result.success is not None:
3509 
      return result.success
3510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3511 
 
3512 
  def isValidCatalogItemId(self, catalog_item_id):
3513 
    """
3514 
    Parameters:
3515 
     - catalog_item_id
3516 
    """
3517 
    self.send_isValidCatalogItemId(catalog_item_id)
3518 
    return self.recv_isValidCatalogItemId()
3519 
 
3520 
  def send_isValidCatalogItemId(self, catalog_item_id):
3521 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3522 
    args = isValidCatalogItemId_args()
3523 
    args.catalog_item_id = catalog_item_id
3524 
    args.write(self._oprot)
3525 
    self._oprot.writeMessageEnd()
3526 
    self._oprot.trans.flush()
3527 
 
3528 
  def recv_isValidCatalogItemId(self, ):
3529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3530 
    if mtype == TMessageType.EXCEPTION:
3531 
      x = TApplicationException()
3532 
      x.read(self._iprot)
3533 
      self._iprot.readMessageEnd()
3534 
      raise x
3535 
    result = isValidCatalogItemId_result()
3536 
    result.read(self._iprot)
3537 
    self._iprot.readMessageEnd()
3538 
    if result.success is not None:
3539 
      return result.success
3540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3541 
 
7330 amit.gupta 3542 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3543 
    """
3544 
    Parameters:
3545 
     - itemId
7330 amit.gupta 3546 
     - stateId
6039 amit.gupta 3547 
     - price
3548 
    """
7330 amit.gupta 3549 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3550 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3551 
 
7330 amit.gupta 3552 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3553 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3554 
    args = getVatPercentageForItem_args()
3555 
    args.itemId = itemId
7330 amit.gupta 3556 
    args.stateId = stateId
6039 amit.gupta 3557 
    args.price = price
3558 
    args.write(self._oprot)
3559 
    self._oprot.writeMessageEnd()
3560 
    self._oprot.trans.flush()
3561 
 
3562 
  def recv_getVatPercentageForItem(self, ):
3563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3564 
    if mtype == TMessageType.EXCEPTION:
3565 
      x = TApplicationException()
3566 
      x.read(self._iprot)
3567 
      self._iprot.readMessageEnd()
3568 
      raise x
3569 
    result = getVatPercentageForItem_result()
3570 
    result.read(self._iprot)
3571 
    self._iprot.readMessageEnd()
3572 
    if result.success is not None:
3573 
      return result.success
7340 amit.gupta 3574 
    if result.cex is not None:
3575 
      raise result.cex
6039 amit.gupta 3576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3577 
 
3578 
  def getVatAmountForItem(self, itemId, price):
3579 
    """
3580 
    Parameters:
3581 
     - itemId
3582 
     - price
3583 
    """
3584 
    self.send_getVatAmountForItem(itemId, price)
3585 
    return self.recv_getVatAmountForItem()
3586 
 
3587 
  def send_getVatAmountForItem(self, itemId, price):
3588 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3589 
    args = getVatAmountForItem_args()
3590 
    args.itemId = itemId
3591 
    args.price = price
3592 
    args.write(self._oprot)
3593 
    self._oprot.writeMessageEnd()
3594 
    self._oprot.trans.flush()
3595 
 
3596 
  def recv_getVatAmountForItem(self, ):
3597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3598 
    if mtype == TMessageType.EXCEPTION:
3599 
      x = TApplicationException()
3600 
      x.read(self._iprot)
3601 
      self._iprot.readMessageEnd()
3602 
      raise x
3603 
    result = getVatAmountForItem_result()
3604 
    result.read(self._iprot)
3605 
    self._iprot.readMessageEnd()
3606 
    if result.success is not None:
3607 
      return result.success
3608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3609 
 
6531 vikram.rag 3610 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3611 
    """
3612 
    Parameters:
3613 
     - offset
3614 
     - limit
3615 
    """
3616 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3617 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3618 
 
6531 vikram.rag 3619 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3620 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3621 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3622 
    args.offset = offset
3623 
    args.limit = limit
3624 
    args.write(self._oprot)
3625 
    self._oprot.writeMessageEnd()
3626 
    self._oprot.trans.flush()
3627 
 
3628 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3630 
    if mtype == TMessageType.EXCEPTION:
3631 
      x = TApplicationException()
3632 
      x.read(self._iprot)
3633 
      self._iprot.readMessageEnd()
3634 
      raise x
3635 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3636 
    result.read(self._iprot)
3637 
    self._iprot.readMessageEnd()
3638 
    if result.success is not None:
3639 
      return result.success
3640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3641 
 
6821 amar.kumar 3642 
  def getAllAliveItems(self, ):
3643 
    self.send_getAllAliveItems()
3644 
    return self.recv_getAllAliveItems()
3645 
 
3646 
  def send_getAllAliveItems(self, ):
3647 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3648 
    args = getAllAliveItems_args()
3649 
    args.write(self._oprot)
3650 
    self._oprot.writeMessageEnd()
3651 
    self._oprot.trans.flush()
3652 
 
3653 
  def recv_getAllAliveItems(self, ):
3654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3655 
    if mtype == TMessageType.EXCEPTION:
3656 
      x = TApplicationException()
3657 
      x.read(self._iprot)
3658 
      self._iprot.readMessageEnd()
3659 
      raise x
3660 
    result = getAllAliveItems_result()
3661 
    result.read(self._iprot)
3662 
    self._iprot.readMessageEnd()
3663 
    if result.success is not None:
3664 
      return result.success
3665 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3666 
 
6921 anupam.sin 3667 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3668 
    """
3669 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3670 
 
6805 anupam.sin 3671 
    Parameters:
3672 
     - itemId
6921 anupam.sin 3673 
     - price
6805 anupam.sin 3674 
     - insurerId
3675 
     - quantity
3676 
    """
6921 anupam.sin 3677 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3678 
    return self.recv_getInsuranceAmount()
3679 
 
6921 anupam.sin 3680 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3681 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3682 
    args = getInsuranceAmount_args()
3683 
    args.itemId = itemId
6921 anupam.sin 3684 
    args.price = price
6805 anupam.sin 3685 
    args.insurerId = insurerId
3686 
    args.quantity = quantity
3687 
    args.write(self._oprot)
3688 
    self._oprot.writeMessageEnd()
3689 
    self._oprot.trans.flush()
3690 
 
3691 
  def recv_getInsuranceAmount(self, ):
3692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3693 
    if mtype == TMessageType.EXCEPTION:
3694 
      x = TApplicationException()
3695 
      x.read(self._iprot)
3696 
      self._iprot.readMessageEnd()
3697 
      raise x
3698 
    result = getInsuranceAmount_result()
3699 
    result.read(self._iprot)
3700 
    self._iprot.readMessageEnd()
3701 
    if result.success is not None:
3702 
      return result.success
3703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3704 
 
3705 
  def getInsurer(self, insurerId):
3706 
    """
3707 
    Parameters:
3708 
     - insurerId
3709 
    """
3710 
    self.send_getInsurer(insurerId)
3711 
    return self.recv_getInsurer()
3712 
 
3713 
  def send_getInsurer(self, insurerId):
3714 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3715 
    args = getInsurer_args()
3716 
    args.insurerId = insurerId
3717 
    args.write(self._oprot)
3718 
    self._oprot.writeMessageEnd()
3719 
    self._oprot.trans.flush()
3720 
 
3721 
  def recv_getInsurer(self, ):
3722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3723 
    if mtype == TMessageType.EXCEPTION:
3724 
      x = TApplicationException()
3725 
      x.read(self._iprot)
3726 
      self._iprot.readMessageEnd()
3727 
      raise x
3728 
    result = getInsurer_result()
3729 
    result.read(self._iprot)
3730 
    self._iprot.readMessageEnd()
3731 
    if result.success is not None:
3732 
      return result.success
3733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3734 
 
6838 vikram.rag 3735 
  def getAllInsurers(self, ):
3736 
    self.send_getAllInsurers()
3737 
    return self.recv_getAllInsurers()
6805 anupam.sin 3738 
 
6838 vikram.rag 3739 
  def send_getAllInsurers(self, ):
3740 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3741 
    args = getAllInsurers_args()
3742 
    args.write(self._oprot)
3743 
    self._oprot.writeMessageEnd()
3744 
    self._oprot.trans.flush()
3745 
 
3746 
  def recv_getAllInsurers(self, ):
3747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3748 
    if mtype == TMessageType.EXCEPTION:
3749 
      x = TApplicationException()
3750 
      x.read(self._iprot)
3751 
      self._iprot.readMessageEnd()
3752 
      raise x
3753 
    result = getAllInsurers_result()
3754 
    result.read(self._iprot)
3755 
    self._iprot.readMessageEnd()
3756 
    if result.success is not None:
3757 
      return result.success
3758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3759 
 
6962 rajveer 3760 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3761 
    """
3762 
    Parameters:
3763 
     - insurerId
3764 
     - amount
3765 
    """
3766 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3767 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3768 
 
6962 rajveer 3769 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3770 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3771 
    args = updateInsuranceDeclaredAmount_args()
3772 
    args.insurerId = insurerId
3773 
    args.amount = amount
3774 
    args.write(self._oprot)
3775 
    self._oprot.writeMessageEnd()
3776 
    self._oprot.trans.flush()
3777 
 
3778 
  def recv_updateInsuranceDeclaredAmount(self, ):
3779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3780 
    if mtype == TMessageType.EXCEPTION:
3781 
      x = TApplicationException()
3782 
      x.read(self._iprot)
3783 
      self._iprot.readMessageEnd()
3784 
      raise x
3785 
    result = updateInsuranceDeclaredAmount_result()
3786 
    result.read(self._iprot)
3787 
    self._iprot.readMessageEnd()
3788 
    return
3789 
 
7190 amar.kumar 3790 
  def getFreebieForItem(self, itemId):
3791 
    """
3792 
    Parameters:
3793 
     - itemId
3794 
    """
3795 
    self.send_getFreebieForItem(itemId)
3796 
    return self.recv_getFreebieForItem()
6962 rajveer 3797 
 
7190 amar.kumar 3798 
  def send_getFreebieForItem(self, itemId):
3799 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3800 
    args = getFreebieForItem_args()
3801 
    args.itemId = itemId
3802 
    args.write(self._oprot)
3803 
    self._oprot.writeMessageEnd()
3804 
    self._oprot.trans.flush()
3805 
 
3806 
  def recv_getFreebieForItem(self, ):
3807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3808 
    if mtype == TMessageType.EXCEPTION:
3809 
      x = TApplicationException()
3810 
      x.read(self._iprot)
3811 
      self._iprot.readMessageEnd()
3812 
      raise x
3813 
    result = getFreebieForItem_result()
3814 
    result.read(self._iprot)
3815 
    self._iprot.readMessageEnd()
3816 
    if result.success is not None:
3817 
      return result.success
3818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3819 
 
3820 
  def addOrUpdateFreebieForItem(self, freebieItem):
3821 
    """
3822 
    Parameters:
3823 
     - freebieItem
3824 
    """
3825 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3826 
    self.recv_addOrUpdateFreebieForItem()
3827 
 
3828 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3829 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3830 
    args = addOrUpdateFreebieForItem_args()
3831 
    args.freebieItem = freebieItem
3832 
    args.write(self._oprot)
3833 
    self._oprot.writeMessageEnd()
3834 
    self._oprot.trans.flush()
3835 
 
3836 
  def recv_addOrUpdateFreebieForItem(self, ):
3837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3838 
    if mtype == TMessageType.EXCEPTION:
3839 
      x = TApplicationException()
3840 
      x.read(self._iprot)
3841 
      self._iprot.readMessageEnd()
3842 
      raise x
3843 
    result = addOrUpdateFreebieForItem_result()
3844 
    result.read(self._iprot)
3845 
    self._iprot.readMessageEnd()
3846 
    return
3847 
 
7272 amit.gupta 3848 
  def addOrUpdateBrandInfo(self, brandInfo):
3849 
    """
3850 
    Parameters:
3851 
     - brandInfo
3852 
    """
3853 
    self.send_addOrUpdateBrandInfo(brandInfo)
3854 
    self.recv_addOrUpdateBrandInfo()
3855 
 
3856 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3857 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3858 
    args = addOrUpdateBrandInfo_args()
3859 
    args.brandInfo = brandInfo
3860 
    args.write(self._oprot)
3861 
    self._oprot.writeMessageEnd()
3862 
    self._oprot.trans.flush()
3863 
 
3864 
  def recv_addOrUpdateBrandInfo(self, ):
3865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3866 
    if mtype == TMessageType.EXCEPTION:
3867 
      x = TApplicationException()
3868 
      x.read(self._iprot)
3869 
      self._iprot.readMessageEnd()
3870 
      raise x
3871 
    result = addOrUpdateBrandInfo_result()
3872 
    result.read(self._iprot)
3873 
    self._iprot.readMessageEnd()
3874 
    return
3875 
 
3876 
  def getBrandInfo(self, ):
3877 
    self.send_getBrandInfo()
3878 
    return self.recv_getBrandInfo()
3879 
 
3880 
  def send_getBrandInfo(self, ):
3881 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3882 
    args = getBrandInfo_args()
3883 
    args.write(self._oprot)
3884 
    self._oprot.writeMessageEnd()
3885 
    self._oprot.trans.flush()
3886 
 
3887 
  def recv_getBrandInfo(self, ):
3888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3889 
    if mtype == TMessageType.EXCEPTION:
3890 
      x = TApplicationException()
3891 
      x.read(self._iprot)
3892 
      self._iprot.readMessageEnd()
3893 
      raise x
3894 
    result = getBrandInfo_result()
3895 
    result.read(self._iprot)
3896 
    self._iprot.readMessageEnd()
3897 
    if result.success is not None:
3898 
      return result.success
3899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3900 
 
7256 rajveer 3901 
  def getStorePricing(self, itemId):
3902 
    """
3903 
    Parameters:
3904 
     - itemId
3905 
    """
3906 
    self.send_getStorePricing(itemId)
3907 
    return self.recv_getStorePricing()
7190 amar.kumar 3908 
 
7256 rajveer 3909 
  def send_getStorePricing(self, itemId):
3910 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3911 
    args = getStorePricing_args()
3912 
    args.itemId = itemId
3913 
    args.write(self._oprot)
3914 
    self._oprot.writeMessageEnd()
3915 
    self._oprot.trans.flush()
3916 
 
3917 
  def recv_getStorePricing(self, ):
3918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3919 
    if mtype == TMessageType.EXCEPTION:
3920 
      x = TApplicationException()
3921 
      x.read(self._iprot)
3922 
      self._iprot.readMessageEnd()
3923 
      raise x
3924 
    result = getStorePricing_result()
3925 
    result.read(self._iprot)
3926 
    self._iprot.readMessageEnd()
3927 
    if result.success is not None:
3928 
      return result.success
3929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3930 
 
7306 rajveer 3931 
  def getStorePricings(self, itemIds):
3932 
    """
3933 
    Parameters:
3934 
     - itemIds
3935 
    """
3936 
    self.send_getStorePricings(itemIds)
3937 
    return self.recv_getStorePricings()
3938 
 
3939 
  def send_getStorePricings(self, itemIds):
3940 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3941 
    args = getStorePricings_args()
3942 
    args.itemIds = itemIds
3943 
    args.write(self._oprot)
3944 
    self._oprot.writeMessageEnd()
3945 
    self._oprot.trans.flush()
3946 
 
3947 
  def recv_getStorePricings(self, ):
3948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3949 
    if mtype == TMessageType.EXCEPTION:
3950 
      x = TApplicationException()
3951 
      x.read(self._iprot)
3952 
      self._iprot.readMessageEnd()
3953 
      raise x
3954 
    result = getStorePricings_result()
3955 
    result.read(self._iprot)
3956 
    self._iprot.readMessageEnd()
3957 
    if result.success is not None:
3958 
      return result.success
3959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3960 
 
7382 rajveer 3961 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3962 
    """
3963 
    Parameters:
3964 
     - sp
7382 rajveer 3965 
     - allColors
7265 rajveer 3966 
    """
7382 rajveer 3967 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3968 
    self.recv_updateStorePricing()
7256 rajveer 3969 
 
7382 rajveer 3970 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3971 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3972 
    args = updateStorePricing_args()
3973 
    args.sp = sp
7382 rajveer 3974 
    args.allColors = allColors
7265 rajveer 3975 
    args.write(self._oprot)
3976 
    self._oprot.writeMessageEnd()
3977 
    self._oprot.trans.flush()
3978 
 
3979 
  def recv_updateStorePricing(self, ):
3980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3981 
    if mtype == TMessageType.EXCEPTION:
3982 
      x = TApplicationException()
3983 
      x.read(self._iprot)
3984 
      self._iprot.readMessageEnd()
3985 
      raise x
3986 
    result = updateStorePricing_result()
3987 
    result.read(self._iprot)
3988 
    self._iprot.readMessageEnd()
3989 
    return
3990 
 
7281 kshitij.so 3991 
  def getAllAmazonListedItems(self, ):
3992 
    self.send_getAllAmazonListedItems()
3993 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3994 
 
7281 kshitij.so 3995 
  def send_getAllAmazonListedItems(self, ):
3996 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3997 
    args = getAllAmazonListedItems_args()
3998 
    args.write(self._oprot)
3999 
    self._oprot.writeMessageEnd()
4000 
    self._oprot.trans.flush()
4001 
 
4002 
  def recv_getAllAmazonListedItems(self, ):
4003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4004 
    if mtype == TMessageType.EXCEPTION:
4005 
      x = TApplicationException()
4006 
      x.read(self._iprot)
4007 
      self._iprot.readMessageEnd()
4008 
      raise x
4009 
    result = getAllAmazonListedItems_result()
4010 
    result.read(self._iprot)
4011 
    self._iprot.readMessageEnd()
4012 
    if result.success is not None:
4013 
      return result.success
4014 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
4015 
 
8619 kshitij.so 4016 
  def searchAmazonItems(self, searchTerm, offset, limit):
4017 
    """
4018 
    Parameters:
4019 
     - searchTerm
4020 
     - offset
4021 
     - limit
4022 
    """
4023 
    self.send_searchAmazonItems(searchTerm, offset, limit)
4024 
    return self.recv_searchAmazonItems()
4025 
 
4026 
  def send_searchAmazonItems(self, searchTerm, offset, limit):
4027 
    self._oprot.writeMessageBegin('searchAmazonItems', TMessageType.CALL, self._seqid)
4028 
    args = searchAmazonItems_args()
4029 
    args.searchTerm = searchTerm
4030 
    args.offset = offset
4031 
    args.limit = limit
4032 
    args.write(self._oprot)
4033 
    self._oprot.writeMessageEnd()
4034 
    self._oprot.trans.flush()
4035 
 
4036 
  def recv_searchAmazonItems(self, ):
4037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4038 
    if mtype == TMessageType.EXCEPTION:
4039 
      x = TApplicationException()
4040 
      x.read(self._iprot)
4041 
      self._iprot.readMessageEnd()
4042 
      raise x
4043 
    result = searchAmazonItems_result()
4044 
    result.read(self._iprot)
4045 
    self._iprot.readMessageEnd()
4046 
    if result.success is not None:
4047 
      return result.success
4048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchAmazonItems failed: unknown result");
4049 
 
4050 
  def getAmazonSearchResultCount(self, searchTerm):
4051 
    """
4052 
    Parameters:
4053 
     - searchTerm
4054 
    """
4055 
    self.send_getAmazonSearchResultCount(searchTerm)
4056 
    return self.recv_getAmazonSearchResultCount()
4057 
 
4058 
  def send_getAmazonSearchResultCount(self, searchTerm):
4059 
    self._oprot.writeMessageBegin('getAmazonSearchResultCount', TMessageType.CALL, self._seqid)
4060 
    args = getAmazonSearchResultCount_args()
4061 
    args.searchTerm = searchTerm
4062 
    args.write(self._oprot)
4063 
    self._oprot.writeMessageEnd()
4064 
    self._oprot.trans.flush()
4065 
 
4066 
  def recv_getAmazonSearchResultCount(self, ):
4067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4068 
    if mtype == TMessageType.EXCEPTION:
4069 
      x = TApplicationException()
4070 
      x.read(self._iprot)
4071 
      self._iprot.readMessageEnd()
4072 
      raise x
4073 
    result = getAmazonSearchResultCount_result()
4074 
    result.read(self._iprot)
4075 
    self._iprot.readMessageEnd()
4076 
    if result.success is not None:
4077 
      return result.success
4078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonSearchResultCount failed: unknown result");
4079 
 
4080 
  def getCountForAmazonlistedItems(self, ):
4081 
    self.send_getCountForAmazonlistedItems()
4082 
    return self.recv_getCountForAmazonlistedItems()
4083 
 
4084 
  def send_getCountForAmazonlistedItems(self, ):
4085 
    self._oprot.writeMessageBegin('getCountForAmazonlistedItems', TMessageType.CALL, self._seqid)
4086 
    args = getCountForAmazonlistedItems_args()
4087 
    args.write(self._oprot)
4088 
    self._oprot.writeMessageEnd()
4089 
    self._oprot.trans.flush()
4090 
 
4091 
  def recv_getCountForAmazonlistedItems(self, ):
4092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4093 
    if mtype == TMessageType.EXCEPTION:
4094 
      x = TApplicationException()
4095 
      x.read(self._iprot)
4096 
      self._iprot.readMessageEnd()
4097 
      raise x
4098 
    result = getCountForAmazonlistedItems_result()
4099 
    result.read(self._iprot)
4100 
    self._iprot.readMessageEnd()
4101 
    if result.success is not None:
4102 
      return result.success
4103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCountForAmazonlistedItems failed: unknown result");
4104 
 
7281 kshitij.so 4105 
  def getAmazonItemDetails(self, itemId):
4106 
    """
4107 
    Parameters:
4108 
     - itemId
4109 
    """
4110 
    self.send_getAmazonItemDetails(itemId)
4111 
    return self.recv_getAmazonItemDetails()
4112 
 
4113 
  def send_getAmazonItemDetails(self, itemId):
4114 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
4115 
    args = getAmazonItemDetails_args()
4116 
    args.itemId = itemId
4117 
    args.write(self._oprot)
4118 
    self._oprot.writeMessageEnd()
4119 
    self._oprot.trans.flush()
4120 
 
4121 
  def recv_getAmazonItemDetails(self, ):
4122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4123 
    if mtype == TMessageType.EXCEPTION:
4124 
      x = TApplicationException()
4125 
      x.read(self._iprot)
4126 
      self._iprot.readMessageEnd()
4127 
      raise x
4128 
    result = getAmazonItemDetails_result()
4129 
    result.read(self._iprot)
4130 
    self._iprot.readMessageEnd()
4131 
    if result.success is not None:
4132 
      return result.success
4133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
4134 
 
8168 kshitij.so 4135 
  def updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4136 
    """
4137 
    Parameters:
8168 kshitij.so 4138 
     - amazonlisted
7281 kshitij.so 4139 
    """
8168 kshitij.so 4140 
    self.send_updateAmazonItemDetails(amazonlisted)
7281 kshitij.so 4141 
    self.recv_updateAmazonItemDetails()
4142 
 
8168 kshitij.so 4143 
  def send_updateAmazonItemDetails(self, amazonlisted):
7281 kshitij.so 4144 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
4145 
    args = updateAmazonItemDetails_args()
8168 kshitij.so 4146 
    args.amazonlisted = amazonlisted
7281 kshitij.so 4147 
    args.write(self._oprot)
4148 
    self._oprot.writeMessageEnd()
4149 
    self._oprot.trans.flush()
4150 
 
4151 
  def recv_updateAmazonItemDetails(self, ):
4152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4153 
    if mtype == TMessageType.EXCEPTION:
4154 
      x = TApplicationException()
4155 
      x.read(self._iprot)
4156 
      self._iprot.readMessageEnd()
4157 
      raise x
4158 
    result = updateAmazonItemDetails_result()
4159 
    result.read(self._iprot)
4160 
    self._iprot.readMessageEnd()
4161 
    return
4162 
 
4163 
  def addAmazonItem(self, amazonlisted):
4164 
    """
4165 
    Parameters:
4166 
     - amazonlisted
4167 
    """
4168 
    self.send_addAmazonItem(amazonlisted)
4169 
    self.recv_addAmazonItem()
4170 
 
4171 
  def send_addAmazonItem(self, amazonlisted):
4172 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
4173 
    args = addAmazonItem_args()
4174 
    args.amazonlisted = amazonlisted
4175 
    args.write(self._oprot)
4176 
    self._oprot.writeMessageEnd()
4177 
    self._oprot.trans.flush()
4178 
 
4179 
  def recv_addAmazonItem(self, ):
4180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4181 
    if mtype == TMessageType.EXCEPTION:
4182 
      x = TApplicationException()
4183 
      x.read(self._iprot)
4184 
      self._iprot.readMessageEnd()
4185 
      raise x
4186 
    result = addAmazonItem_result()
4187 
    result.read(self._iprot)
4188 
    self._iprot.readMessageEnd()
4189 
    return
4190 
 
7291 vikram.rag 4191 
  def getAsinItems(self, ):
4192 
    self.send_getAsinItems()
4193 
    return self.recv_getAsinItems()
7281 kshitij.so 4194 
 
7291 vikram.rag 4195 
  def send_getAsinItems(self, ):
4196 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
4197 
    args = getAsinItems_args()
4198 
    args.write(self._oprot)
4199 
    self._oprot.writeMessageEnd()
4200 
    self._oprot.trans.flush()
4201 
 
4202 
  def recv_getAsinItems(self, ):
4203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4204 
    if mtype == TMessageType.EXCEPTION:
4205 
      x = TApplicationException()
4206 
      x.read(self._iprot)
4207 
      self._iprot.readMessageEnd()
4208 
      raise x
4209 
    result = getAsinItems_result()
4210 
    result.read(self._iprot)
4211 
    self._iprot.readMessageEnd()
4212 
    if result.success is not None:
4213 
      return result.success
4214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
4215 
 
4216 
  def getAllFbaListedItems(self, ):
4217 
    self.send_getAllFbaListedItems()
4218 
    return self.recv_getAllFbaListedItems()
4219 
 
4220 
  def send_getAllFbaListedItems(self, ):
4221 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
4222 
    args = getAllFbaListedItems_args()
4223 
    args.write(self._oprot)
4224 
    self._oprot.writeMessageEnd()
4225 
    self._oprot.trans.flush()
4226 
 
4227 
  def recv_getAllFbaListedItems(self, ):
4228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4229 
    if mtype == TMessageType.EXCEPTION:
4230 
      x = TApplicationException()
4231 
      x.read(self._iprot)
4232 
      self._iprot.readMessageEnd()
4233 
      raise x
4234 
    result = getAllFbaListedItems_result()
4235 
    result.read(self._iprot)
4236 
    self._iprot.readMessageEnd()
4237 
    if result.success is not None:
4238 
      return result.success
4239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
4240 
 
4241 
  def getAllNonFbaListedItems(self, ):
4242 
    self.send_getAllNonFbaListedItems()
4243 
    return self.recv_getAllNonFbaListedItems()
4244 
 
4245 
  def send_getAllNonFbaListedItems(self, ):
4246 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
4247 
    args = getAllNonFbaListedItems_args()
4248 
    args.write(self._oprot)
4249 
    self._oprot.writeMessageEnd()
4250 
    self._oprot.trans.flush()
4251 
 
4252 
  def recv_getAllNonFbaListedItems(self, ):
4253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4254 
    if mtype == TMessageType.EXCEPTION:
4255 
      x = TApplicationException()
4256 
      x.read(self._iprot)
4257 
      self._iprot.readMessageEnd()
4258 
      raise x
4259 
    result = getAllNonFbaListedItems_result()
4260 
    result.read(self._iprot)
4261 
    self._iprot.readMessageEnd()
4262 
    if result.success is not None:
4263 
      return result.success
4264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
4265 
 
7460 kshitij.so 4266 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
4267 
    """
4268 
    Parameters:
4269 
     - itemId
4270 
     - holdInventory
4271 
     - defaultInventory
4272 
    """
4273 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
4274 
    return self.recv_updateItemInventory()
7291 vikram.rag 4275 
 
7460 kshitij.so 4276 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
4277 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
4278 
    args = updateItemInventory_args()
4279 
    args.itemId = itemId
4280 
    args.holdInventory = holdInventory
4281 
    args.defaultInventory = defaultInventory
4282 
    args.write(self._oprot)
4283 
    self._oprot.writeMessageEnd()
4284 
    self._oprot.trans.flush()
4285 
 
4286 
  def recv_updateItemInventory(self, ):
4287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4288 
    if mtype == TMessageType.EXCEPTION:
4289 
      x = TApplicationException()
4290 
      x.read(self._iprot)
4291 
      self._iprot.readMessageEnd()
4292 
      raise x
4293 
    result = updateItemInventory_result()
4294 
    result.read(self._iprot)
4295 
    self._iprot.readMessageEnd()
4296 
    if result.success is not None:
4297 
      return result.success
4298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
4299 
 
7770 kshitij.so 4300 
  def updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4301 
    """
4302 
    Parameters:
4303 
     - type
4304 
     - sku
4305 
     - timestamp
4306 
    """
4307 
    self.send_updateTimestampForAmazonFeeds(type, sku, timestamp)
4308 
    return self.recv_updateTimestampForAmazonFeeds()
7460 kshitij.so 4309 
 
7770 kshitij.so 4310 
  def send_updateTimestampForAmazonFeeds(self, type, sku, timestamp):
4311 
    self._oprot.writeMessageBegin('updateTimestampForAmazonFeeds', TMessageType.CALL, self._seqid)
4312 
    args = updateTimestampForAmazonFeeds_args()
4313 
    args.type = type
4314 
    args.sku = sku
4315 
    args.timestamp = timestamp
4316 
    args.write(self._oprot)
4317 
    self._oprot.writeMessageEnd()
4318 
    self._oprot.trans.flush()
4319 
 
4320 
  def recv_updateTimestampForAmazonFeeds(self, ):
4321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4322 
    if mtype == TMessageType.EXCEPTION:
4323 
      x = TApplicationException()
4324 
      x.read(self._iprot)
4325 
      self._iprot.readMessageEnd()
4326 
      raise x
4327 
    result = updateTimestampForAmazonFeeds_result()
4328 
    result.read(self._iprot)
4329 
    self._iprot.readMessageEnd()
4330 
    if result.success is not None:
4331 
      return result.success
4332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTimestampForAmazonFeeds failed: unknown result");
4333 
 
7897 amar.kumar 4334 
  def getAllParentCategories(self, ):
4335 
    self.send_getAllParentCategories()
4336 
    return self.recv_getAllParentCategories()
7770 kshitij.so 4337 
 
7897 amar.kumar 4338 
  def send_getAllParentCategories(self, ):
4339 
    self._oprot.writeMessageBegin('getAllParentCategories', TMessageType.CALL, self._seqid)
4340 
    args = getAllParentCategories_args()
4341 
    args.write(self._oprot)
4342 
    self._oprot.writeMessageEnd()
4343 
    self._oprot.trans.flush()
4344 
 
4345 
  def recv_getAllParentCategories(self, ):
4346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4347 
    if mtype == TMessageType.EXCEPTION:
4348 
      x = TApplicationException()
4349 
      x.read(self._iprot)
4350 
      self._iprot.readMessageEnd()
4351 
      raise x
4352 
    result = getAllParentCategories_result()
4353 
    result.read(self._iprot)
4354 
    self._iprot.readMessageEnd()
4355 
    if result.success is not None:
4356 
      return result.success
4357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllParentCategories failed: unknown result");
4358 
 
7977 kshitij.so 4359 
  def addPageViewEvent(self, pageViewEvents):
4360 
    """
4361 
    Parameters:
4362 
     - pageViewEvents
4363 
    """
4364 
    self.send_addPageViewEvent(pageViewEvents)
4365 
    self.recv_addPageViewEvent()
7897 amar.kumar 4366 
 
7977 kshitij.so 4367 
  def send_addPageViewEvent(self, pageViewEvents):
4368 
    self._oprot.writeMessageBegin('addPageViewEvent', TMessageType.CALL, self._seqid)
4369 
    args = addPageViewEvent_args()
4370 
    args.pageViewEvents = pageViewEvents
4371 
    args.write(self._oprot)
4372 
    self._oprot.writeMessageEnd()
4373 
    self._oprot.trans.flush()
4374 
 
4375 
  def recv_addPageViewEvent(self, ):
4376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4377 
    if mtype == TMessageType.EXCEPTION:
4378 
      x = TApplicationException()
4379 
      x.read(self._iprot)
4380 
      self._iprot.readMessageEnd()
4381 
      raise x
4382 
    result = addPageViewEvent_result()
4383 
    result.read(self._iprot)
4384 
    self._iprot.readMessageEnd()
4385 
    return
4386 
 
4387 
  def addCartEvent(self, cartEvents):
4388 
    """
4389 
    Parameters:
4390 
     - cartEvents
4391 
    """
4392 
    self.send_addCartEvent(cartEvents)
4393 
    self.recv_addCartEvent()
4394 
 
4395 
  def send_addCartEvent(self, cartEvents):
4396 
    self._oprot.writeMessageBegin('addCartEvent', TMessageType.CALL, self._seqid)
4397 
    args = addCartEvent_args()
4398 
    args.cartEvents = cartEvents
4399 
    args.write(self._oprot)
4400 
    self._oprot.writeMessageEnd()
4401 
    self._oprot.trans.flush()
4402 
 
4403 
  def recv_addCartEvent(self, ):
4404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4405 
    if mtype == TMessageType.EXCEPTION:
4406 
      x = TApplicationException()
4407 
      x.read(self._iprot)
4408 
      self._iprot.readMessageEnd()
4409 
      raise x
4410 
    result = addCartEvent_result()
4411 
    result.read(self._iprot)
4412 
    self._iprot.readMessageEnd()
4413 
    return
4414 
 
8182 amar.kumar 4415 
  def addEbayItem(self, ebayItem):
4416 
    """
4417 
    Parameters:
4418 
     - ebayItem
4419 
    """
4420 
    self.send_addEbayItem(ebayItem)
4421 
    self.recv_addEbayItem()
4422 
 
4423 
  def send_addEbayItem(self, ebayItem):
4424 
    self._oprot.writeMessageBegin('addEbayItem', TMessageType.CALL, self._seqid)
4425 
    args = addEbayItem_args()
4426 
    args.ebayItem = ebayItem
4427 
    args.write(self._oprot)
4428 
    self._oprot.writeMessageEnd()
4429 
    self._oprot.trans.flush()
4430 
 
4431 
  def recv_addEbayItem(self, ):
4432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4433 
    if mtype == TMessageType.EXCEPTION:
4434 
      x = TApplicationException()
4435 
      x.read(self._iprot)
4436 
      self._iprot.readMessageEnd()
4437 
      raise x
4438 
    result = addEbayItem_result()
4439 
    result.read(self._iprot)
4440 
    self._iprot.readMessageEnd()
4441 
    return
4442 
 
4443 
  def getEbayItem(self, listingId):
4444 
    """
4445 
    Parameters:
4446 
     - listingId
4447 
    """
4448 
    self.send_getEbayItem(listingId)
4449 
    return self.recv_getEbayItem()
4450 
 
4451 
  def send_getEbayItem(self, listingId):
4452 
    self._oprot.writeMessageBegin('getEbayItem', TMessageType.CALL, self._seqid)
4453 
    args = getEbayItem_args()
4454 
    args.listingId = listingId
4455 
    args.write(self._oprot)
4456 
    self._oprot.writeMessageEnd()
4457 
    self._oprot.trans.flush()
4458 
 
4459 
  def recv_getEbayItem(self, ):
4460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4461 
    if mtype == TMessageType.EXCEPTION:
4462 
      x = TApplicationException()
4463 
      x.read(self._iprot)
4464 
      self._iprot.readMessageEnd()
4465 
      raise x
4466 
    result = getEbayItem_result()
4467 
    result.read(self._iprot)
4468 
    self._iprot.readMessageEnd()
4469 
    if result.success is not None:
4470 
      return result.success
4471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayItem failed: unknown result");
4472 
 
4473 
  def updateEbayItem(self, ebayItem):
4474 
    """
4475 
    Parameters:
4476 
     - ebayItem
4477 
    """
4478 
    self.send_updateEbayItem(ebayItem)
4479 
    self.recv_updateEbayItem()
4480 
 
4481 
  def send_updateEbayItem(self, ebayItem):
4482 
    self._oprot.writeMessageBegin('updateEbayItem', TMessageType.CALL, self._seqid)
4483 
    args = updateEbayItem_args()
4484 
    args.ebayItem = ebayItem
4485 
    args.write(self._oprot)
4486 
    self._oprot.writeMessageEnd()
4487 
    self._oprot.trans.flush()
4488 
 
4489 
  def recv_updateEbayItem(self, ):
4490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4491 
    if mtype == TMessageType.EXCEPTION:
4492 
      x = TApplicationException()
4493 
      x.read(self._iprot)
4494 
      self._iprot.readMessageEnd()
4495 
      raise x
4496 
    result = updateEbayItem_result()
4497 
    result.read(self._iprot)
4498 
    self._iprot.readMessageEnd()
4499 
    return
4500 
 
8139 kshitij.so 4501 
  def getAmazonListedItems(self, offset, limit):
4502 
    """
4503 
    Parameters:
4504 
     - offset
4505 
     - limit
4506 
    """
4507 
    self.send_getAmazonListedItems(offset, limit)
4508 
    return self.recv_getAmazonListedItems()
7977 kshitij.so 4509 
 
8139 kshitij.so 4510 
  def send_getAmazonListedItems(self, offset, limit):
4511 
    self._oprot.writeMessageBegin('getAmazonListedItems', TMessageType.CALL, self._seqid)
4512 
    args = getAmazonListedItems_args()
4513 
    args.offset = offset
4514 
    args.limit = limit
4515 
    args.write(self._oprot)
4516 
    self._oprot.writeMessageEnd()
4517 
    self._oprot.trans.flush()
4518 
 
4519 
  def recv_getAmazonListedItems(self, ):
4520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4521 
    if mtype == TMessageType.EXCEPTION:
4522 
      x = TApplicationException()
4523 
      x.read(self._iprot)
4524 
      self._iprot.readMessageEnd()
4525 
      raise x
4526 
    result = getAmazonListedItems_result()
4527 
    result.read(self._iprot)
4528 
    self._iprot.readMessageEnd()
4529 
    if result.success is not None:
4530 
      return result.success
4531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonListedItems failed: unknown result");
4532 
 
8168 kshitij.so 4533 
  def updateAmazonAttributesInBulk(self, amazonlisted):
4534 
    """
4535 
    Parameters:
4536 
     - amazonlisted
4537 
    """
4538 
    self.send_updateAmazonAttributesInBulk(amazonlisted)
4539 
    return self.recv_updateAmazonAttributesInBulk()
8139 kshitij.so 4540 
 
8168 kshitij.so 4541 
  def send_updateAmazonAttributesInBulk(self, amazonlisted):
4542 
    self._oprot.writeMessageBegin('updateAmazonAttributesInBulk', TMessageType.CALL, self._seqid)
4543 
    args = updateAmazonAttributesInBulk_args()
4544 
    args.amazonlisted = amazonlisted
4545 
    args.write(self._oprot)
4546 
    self._oprot.writeMessageEnd()
4547 
    self._oprot.trans.flush()
4548 
 
4549 
  def recv_updateAmazonAttributesInBulk(self, ):
4550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4551 
    if mtype == TMessageType.EXCEPTION:
4552 
      x = TApplicationException()
4553 
      x.read(self._iprot)
4554 
      self._iprot.readMessageEnd()
4555 
      raise x
4556 
    result = updateAmazonAttributesInBulk_result()
4557 
    result.read(self._iprot)
4558 
    self._iprot.readMessageEnd()
4559 
    if result.success is not None:
4560 
      return result.success
4561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateAmazonAttributesInBulk failed: unknown result");
4562 
 
8379 vikram.rag 4563 
  def getAllItemstoListOnFba(self, ):
4564 
    self.send_getAllItemstoListOnFba()
4565 
    return self.recv_getAllItemstoListOnFba()
8168 kshitij.so 4566 
 
8379 vikram.rag 4567 
  def send_getAllItemstoListOnFba(self, ):
4568 
    self._oprot.writeMessageBegin('getAllItemstoListOnFba', TMessageType.CALL, self._seqid)
4569 
    args = getAllItemstoListOnFba_args()
4570 
    args.write(self._oprot)
4571 
    self._oprot.writeMessageEnd()
4572 
    self._oprot.trans.flush()
4573 
 
4574 
  def recv_getAllItemstoListOnFba(self, ):
4575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4576 
    if mtype == TMessageType.EXCEPTION:
4577 
      x = TApplicationException()
4578 
      x.read(self._iprot)
4579 
      self._iprot.readMessageEnd()
4580 
      raise x
4581 
    result = getAllItemstoListOnFba_result()
4582 
    result.read(self._iprot)
4583 
    self._iprot.readMessageEnd()
4584 
    if result.success is not None:
4585 
      return result.success
4586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnFba failed: unknown result");
4587 
 
4588 
  def getAllItemstoListOnNonFba(self, ):
4589 
    self.send_getAllItemstoListOnNonFba()
4590 
    return self.recv_getAllItemstoListOnNonFba()
4591 
 
4592 
  def send_getAllItemstoListOnNonFba(self, ):
4593 
    self._oprot.writeMessageBegin('getAllItemstoListOnNonFba', TMessageType.CALL, self._seqid)
4594 
    args = getAllItemstoListOnNonFba_args()
4595 
    args.write(self._oprot)
4596 
    self._oprot.writeMessageEnd()
4597 
    self._oprot.trans.flush()
4598 
 
4599 
  def recv_getAllItemstoListOnNonFba(self, ):
4600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4601 
    if mtype == TMessageType.EXCEPTION:
4602 
      x = TApplicationException()
4603 
      x.read(self._iprot)
4604 
      self._iprot.readMessageEnd()
4605 
      raise x
4606 
    result = getAllItemstoListOnNonFba_result()
4607 
    result.read(self._iprot)
4608 
    self._iprot.readMessageEnd()
4609 
    if result.success is not None:
4610 
      return result.success
4611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemstoListOnNonFba failed: unknown result");
4612 
 
8616 vikram.rag 4613 
  def getAllSnapdealListedActiveItems(self, ):
4614 
    self.send_getAllSnapdealListedActiveItems()
4615 
    return self.recv_getAllSnapdealListedActiveItems()
8379 vikram.rag 4616 
 
8616 vikram.rag 4617 
  def send_getAllSnapdealListedActiveItems(self, ):
4618 
    self._oprot.writeMessageBegin('getAllSnapdealListedActiveItems', TMessageType.CALL, self._seqid)
4619 
    args = getAllSnapdealListedActiveItems_args()
4620 
    args.write(self._oprot)
4621 
    self._oprot.writeMessageEnd()
4622 
    self._oprot.trans.flush()
4623 
 
4624 
  def recv_getAllSnapdealListedActiveItems(self, ):
4625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4626 
    if mtype == TMessageType.EXCEPTION:
4627 
      x = TApplicationException()
4628 
      x.read(self._iprot)
4629 
      self._iprot.readMessageEnd()
4630 
      raise x
4631 
    result = getAllSnapdealListedActiveItems_result()
4632 
    result.read(self._iprot)
4633 
    self._iprot.readMessageEnd()
4634 
    if result.success is not None:
4635 
      return result.success
4636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealListedActiveItems failed: unknown result");
4637 
 
8619 kshitij.so 4638 
  def updateAsin(self, item):
4639 
    """
4640 
    Parameters:
4641 
     - item
4642 
    """
4643 
    self.send_updateAsin(item)
4644 
    self.recv_updateAsin()
8616 vikram.rag 4645 
 
8619 kshitij.so 4646 
  def send_updateAsin(self, item):
4647 
    self._oprot.writeMessageBegin('updateAsin', TMessageType.CALL, self._seqid)
4648 
    args = updateAsin_args()
4649 
    args.item = item
4650 
    args.write(self._oprot)
4651 
    self._oprot.writeMessageEnd()
4652 
    self._oprot.trans.flush()
4653 
 
4654 
  def recv_updateAsin(self, ):
4655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4656 
    if mtype == TMessageType.EXCEPTION:
4657 
      x = TApplicationException()
4658 
      x.read(self._iprot)
4659 
      self._iprot.readMessageEnd()
4660 
      raise x
4661 
    result = updateAsin_result()
4662 
    result.read(self._iprot)
4663 
    self._iprot.readMessageEnd()
4664 
    return
4665 
 
8739 vikram.rag 4666 
  def addOrUpdateSnapdealItem(self, snapdealitem):
4667 
    """
4668 
    Parameters:
4669 
     - snapdealitem
4670 
    """
4671 
    self.send_addOrUpdateSnapdealItem(snapdealitem)
4672 
    return self.recv_addOrUpdateSnapdealItem()
8619 kshitij.so 4673 
 
8739 vikram.rag 4674 
  def send_addOrUpdateSnapdealItem(self, snapdealitem):
4675 
    self._oprot.writeMessageBegin('addOrUpdateSnapdealItem', TMessageType.CALL, self._seqid)
4676 
    args = addOrUpdateSnapdealItem_args()
4677 
    args.snapdealitem = snapdealitem
4678 
    args.write(self._oprot)
4679 
    self._oprot.writeMessageEnd()
4680 
    self._oprot.trans.flush()
4681 
 
4682 
  def recv_addOrUpdateSnapdealItem(self, ):
4683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4684 
    if mtype == TMessageType.EXCEPTION:
4685 
      x = TApplicationException()
4686 
      x.read(self._iprot)
4687 
      self._iprot.readMessageEnd()
4688 
      raise x
4689 
    result = addOrUpdateSnapdealItem_result()
4690 
    result.read(self._iprot)
4691 
    self._iprot.readMessageEnd()
4692 
    if result.success is not None:
4693 
      return result.success
4694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addOrUpdateSnapdealItem failed: unknown result");
4695 
 
4696 
  def getSnapdealItem(self, item_id):
4697 
    """
4698 
    Parameters:
4699 
     - item_id
4700 
    """
4701 
    self.send_getSnapdealItem(item_id)
4702 
    return self.recv_getSnapdealItem()
4703 
 
4704 
  def send_getSnapdealItem(self, item_id):
4705 
    self._oprot.writeMessageBegin('getSnapdealItem', TMessageType.CALL, self._seqid)
4706 
    args = getSnapdealItem_args()
4707 
    args.item_id = item_id
4708 
    args.write(self._oprot)
4709 
    self._oprot.writeMessageEnd()
4710 
    self._oprot.trans.flush()
4711 
 
4712 
  def recv_getSnapdealItem(self, ):
4713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4714 
    if mtype == TMessageType.EXCEPTION:
4715 
      x = TApplicationException()
4716 
      x.read(self._iprot)
4717 
      self._iprot.readMessageEnd()
4718 
      raise x
4719 
    result = getSnapdealItem_result()
4720 
    result.read(self._iprot)
4721 
    self._iprot.readMessageEnd()
4722 
    if result.success is not None:
4723 
      return result.success
4724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSnapdealItem failed: unknown result");
4725 
 
4726 
  def getAllSnapdealItems(self, ):
4727 
    self.send_getAllSnapdealItems()
4728 
    return self.recv_getAllSnapdealItems()
4729 
 
4730 
  def send_getAllSnapdealItems(self, ):
4731 
    self._oprot.writeMessageBegin('getAllSnapdealItems', TMessageType.CALL, self._seqid)
4732 
    args = getAllSnapdealItems_args()
4733 
    args.write(self._oprot)
4734 
    self._oprot.writeMessageEnd()
4735 
    self._oprot.trans.flush()
4736 
 
4737 
  def recv_getAllSnapdealItems(self, ):
4738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4739 
    if mtype == TMessageType.EXCEPTION:
4740 
      x = TApplicationException()
4741 
      x.read(self._iprot)
4742 
      self._iprot.readMessageEnd()
4743 
      raise x
4744 
    result = getAllSnapdealItems_result()
4745 
    result.read(self._iprot)
4746 
    self._iprot.readMessageEnd()
4747 
    if result.success is not None:
4748 
      return result.success
4749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSnapdealItems failed: unknown result");
4750 
 
4751 
 
5944 mandeep.dh 4752 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
4753 
  def __init__(self, handler):
4754 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4755 
    self._processMap["addItem"] = Processor.process_addItem
4756 
    self._processMap["updateItem"] = Processor.process_updateItem
4757 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 4758 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 4759 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
4760 
    self._processMap["startItemOn"] = Processor.process_startItemOn
4761 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
4762 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
4763 
    self._processMap["getItem"] = Processor.process_getItem
4764 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
4765 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
4766 
    self._processMap["getAllItems"] = Processor.process_getAllItems
4767 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
4768 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
4769 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
4770 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
4771 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
4772 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
4773 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
4774 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
4775 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
4776 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
4777 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
4778 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
4779 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
4780 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
4781 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
4782 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
4783 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
4784 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
4785 
    self._processMap["addCategory"] = Processor.process_addCategory
4786 
    self._processMap["getCategory"] = Processor.process_getCategory
4787 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
4788 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
4789 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 4790 
    self._processMap["addTag"] = Processor.process_addTag
4791 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
4792 
    self._processMap["deleteTag"] = Processor.process_deleteTag
4793 
    self._processMap["getAllTags"] = Processor.process_getAllTags
4794 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 4795 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 4796 
    self._processMap["addBanner"] = Processor.process_addBanner
8579 kshitij.so 4797 
    self._processMap["updateBanner"] = Processor.process_updateBanner
6850 kshitij.so 4798 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
4799 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
4800 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
4801 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 4802 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
8579 kshitij.so 4803 
    self._processMap["updateBannerMap"] = Processor.process_updateBannerMap
6849 kshitij.so 4804 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
4805 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
8579 kshitij.so 4806 
    self._processMap["addBannerUri"] = Processor.process_addBannerUri
4807 
    self._processMap["getUriMapping"] = Processor.process_getUriMapping
4808 
    self._processMap["addCampaign"] = Processor.process_addCampaign
4809 
    self._processMap["getCampaigns"] = Processor.process_getCampaigns
4810 
    self._processMap["deleteCampaign"] = Processor.process_deleteCampaign
4811 
    self._processMap["getAllCampaigns"] = Processor.process_getAllCampaigns
5944 mandeep.dh 4812 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
4813 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
4814 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
4815 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
4816 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
4817 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
4818 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
4819 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
4820 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
4821 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
4822 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
4823 
    self._processMap["getAllSources"] = Processor.process_getAllSources
4824 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
4825 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
4826 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
4827 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
4828 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
4829 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
4830 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
4831 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
4832 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
4833 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
4834 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
4835 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
4836 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
4837 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 4838 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
4839 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 4840 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 4841 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 4842 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
4843 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 4844 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 4845 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 4846 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
4847 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 4848 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
4849 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 4850 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 4851 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 4852 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 4853 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
8619 kshitij.so 4854 
    self._processMap["searchAmazonItems"] = Processor.process_searchAmazonItems
4855 
    self._processMap["getAmazonSearchResultCount"] = Processor.process_getAmazonSearchResultCount
4856 
    self._processMap["getCountForAmazonlistedItems"] = Processor.process_getCountForAmazonlistedItems
7281 kshitij.so 4857 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
4858 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
4859 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 4860 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
4861 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
4862 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 4863 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
7770 kshitij.so 4864 
    self._processMap["updateTimestampForAmazonFeeds"] = Processor.process_updateTimestampForAmazonFeeds
7897 amar.kumar 4865 
    self._processMap["getAllParentCategories"] = Processor.process_getAllParentCategories
7977 kshitij.so 4866 
    self._processMap["addPageViewEvent"] = Processor.process_addPageViewEvent
4867 
    self._processMap["addCartEvent"] = Processor.process_addCartEvent
8182 amar.kumar 4868 
    self._processMap["addEbayItem"] = Processor.process_addEbayItem
4869 
    self._processMap["getEbayItem"] = Processor.process_getEbayItem
4870 
    self._processMap["updateEbayItem"] = Processor.process_updateEbayItem
8139 kshitij.so 4871 
    self._processMap["getAmazonListedItems"] = Processor.process_getAmazonListedItems
8168 kshitij.so 4872 
    self._processMap["updateAmazonAttributesInBulk"] = Processor.process_updateAmazonAttributesInBulk
8379 vikram.rag 4873 
    self._processMap["getAllItemstoListOnFba"] = Processor.process_getAllItemstoListOnFba
4874 
    self._processMap["getAllItemstoListOnNonFba"] = Processor.process_getAllItemstoListOnNonFba
8616 vikram.rag 4875 
    self._processMap["getAllSnapdealListedActiveItems"] = Processor.process_getAllSnapdealListedActiveItems
8619 kshitij.so 4876 
    self._processMap["updateAsin"] = Processor.process_updateAsin
8739 vikram.rag 4877 
    self._processMap["addOrUpdateSnapdealItem"] = Processor.process_addOrUpdateSnapdealItem
4878 
    self._processMap["getSnapdealItem"] = Processor.process_getSnapdealItem
4879 
    self._processMap["getAllSnapdealItems"] = Processor.process_getAllSnapdealItems
5944 mandeep.dh 4880 
 
4881 
  def process(self, iprot, oprot):
4882 
    (name, type, seqid) = iprot.readMessageBegin()
4883 
    if name not in self._processMap:
4884 
      iprot.skip(TType.STRUCT)
4885 
      iprot.readMessageEnd()
4886 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
4887 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
4888 
      x.write(oprot)
4889 
      oprot.writeMessageEnd()
4890 
      oprot.trans.flush()
4891 
      return
4892 
    else:
4893 
      self._processMap[name](self, seqid, iprot, oprot)
4894 
    return True
4895 
 
4896 
  def process_addItem(self, seqid, iprot, oprot):
4897 
    args = addItem_args()
4898 
    args.read(iprot)
4899 
    iprot.readMessageEnd()
4900 
    result = addItem_result()
4901 
    try:
4902 
      result.success = self._handler.addItem(args.item)
4903 
    except CatalogServiceException, cex:
4904 
      result.cex = cex
4905 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
4906 
    result.write(oprot)
4907 
    oprot.writeMessageEnd()
4908 
    oprot.trans.flush()
4909 
 
4910 
  def process_updateItem(self, seqid, iprot, oprot):
4911 
    args = updateItem_args()
4912 
    args.read(iprot)
4913 
    iprot.readMessageEnd()
4914 
    result = updateItem_result()
4915 
    try:
4916 
      result.success = self._handler.updateItem(args.item)
4917 
    except CatalogServiceException, cex:
4918 
      result.cex = cex
4919 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
4920 
    result.write(oprot)
4921 
    oprot.writeMessageEnd()
4922 
    oprot.trans.flush()
4923 
 
4924 
  def process_isActive(self, seqid, iprot, oprot):
4925 
    args = isActive_args()
4926 
    args.read(iprot)
4927 
    iprot.readMessageEnd()
4928 
    result = isActive_result()
4929 
    try:
4930 
      result.success = self._handler.isActive(args.itemId)
4931 
    except CatalogServiceException, isex:
4932 
      result.isex = isex
4933 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4934 
    result.write(oprot)
4935 
    oprot.writeMessageEnd()
4936 
    oprot.trans.flush()
4937 
 
7438 amit.gupta 4938 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4939 
    args = getItemsStatus_args()
4940 
    args.read(iprot)
4941 
    iprot.readMessageEnd()
4942 
    result = getItemsStatus_result()
4943 
    try:
4944 
      result.success = self._handler.getItemsStatus(args.itemIds)
4945 
    except CatalogServiceException, isex:
4946 
      result.isex = isex
4947 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4948 
    result.write(oprot)
4949 
    oprot.writeMessageEnd()
4950 
    oprot.trans.flush()
4951 
 
5944 mandeep.dh 4952 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4953 
    args = getItemStatusDescription_args()
4954 
    args.read(iprot)
4955 
    iprot.readMessageEnd()
4956 
    result = getItemStatusDescription_result()
4957 
    try:
4958 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4959 
    except CatalogServiceException, isex:
4960 
      result.isex = isex
4961 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4962 
    result.write(oprot)
4963 
    oprot.writeMessageEnd()
4964 
    oprot.trans.flush()
4965 
 
4966 
  def process_startItemOn(self, seqid, iprot, oprot):
4967 
    args = startItemOn_args()
4968 
    args.read(iprot)
4969 
    iprot.readMessageEnd()
4970 
    result = startItemOn_result()
4971 
    try:
4972 
      self._handler.startItemOn(args.item_id, args.timestamp)
4973 
    except CatalogServiceException, cex:
4974 
      result.cex = cex
4975 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4976 
    result.write(oprot)
4977 
    oprot.writeMessageEnd()
4978 
    oprot.trans.flush()
4979 
 
4980 
  def process_retireItemOn(self, seqid, iprot, oprot):
4981 
    args = retireItemOn_args()
4982 
    args.read(iprot)
4983 
    iprot.readMessageEnd()
4984 
    result = retireItemOn_result()
4985 
    try:
4986 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4987 
    except CatalogServiceException, cex:
4988 
      result.cex = cex
4989 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4990 
    result.write(oprot)
4991 
    oprot.writeMessageEnd()
4992 
    oprot.trans.flush()
4993 
 
4994 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4995 
    args = changeItemStatus_args()
4996 
    args.read(iprot)
4997 
    iprot.readMessageEnd()
4998 
    result = changeItemStatus_result()
4999 
    try:
5000 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
5001 
    except CatalogServiceException, cex:
5002 
      result.cex = cex
5003 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
5004 
    result.write(oprot)
5005 
    oprot.writeMessageEnd()
5006 
    oprot.trans.flush()
5007 
 
5008 
  def process_getItem(self, seqid, iprot, oprot):
5009 
    args = getItem_args()
5010 
    args.read(iprot)
5011 
    iprot.readMessageEnd()
5012 
    result = getItem_result()
5013 
    try:
5014 
      result.success = self._handler.getItem(args.item_id)
5015 
    except CatalogServiceException, cex:
5016 
      result.cex = cex
5017 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
5018 
    result.write(oprot)
5019 
    oprot.writeMessageEnd()
5020 
    oprot.trans.flush()
5021 
 
5022 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
5023 
    args = getItemsByCatalogId_args()
5024 
    args.read(iprot)
5025 
    iprot.readMessageEnd()
5026 
    result = getItemsByCatalogId_result()
5027 
    try:
5028 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
5029 
    except CatalogServiceException, cex:
5030 
      result.cex = cex
5031 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
5032 
    result.write(oprot)
5033 
    oprot.writeMessageEnd()
5034 
    oprot.trans.flush()
5035 
 
5036 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
5037 
    args = getValidItemsByCatalogId_args()
5038 
    args.read(iprot)
5039 
    iprot.readMessageEnd()
5040 
    result = getValidItemsByCatalogId_result()
5041 
    try:
5042 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
5043 
    except CatalogServiceException, cex:
5044 
      result.cex = cex
5045 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
5046 
    result.write(oprot)
5047 
    oprot.writeMessageEnd()
5048 
    oprot.trans.flush()
5049 
 
5050 
  def process_getAllItems(self, seqid, iprot, oprot):
5051 
    args = getAllItems_args()
5052 
    args.read(iprot)
5053 
    iprot.readMessageEnd()
5054 
    result = getAllItems_result()
5055 
    try:
5056 
      result.success = self._handler.getAllItems(args.isActive)
5057 
    except CatalogServiceException, cex:
5058 
      result.cex = cex
5059 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
5060 
    result.write(oprot)
5061 
    oprot.writeMessageEnd()
5062 
    oprot.trans.flush()
5063 
 
5064 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
5065 
    args = getAllItemsByStatus_args()
5066 
    args.read(iprot)
5067 
    iprot.readMessageEnd()
5068 
    result = getAllItemsByStatus_result()
5069 
    try:
5070 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
5071 
    except CatalogServiceException, cex:
5072 
      result.cex = cex
5073 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
5074 
    result.write(oprot)
5075 
    oprot.writeMessageEnd()
5076 
    oprot.trans.flush()
5077 
 
5078 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
5079 
    args = markItemAsContentComplete_args()
5080 
    args.read(iprot)
5081 
    iprot.readMessageEnd()
5082 
    result = markItemAsContentComplete_result()
5083 
    try:
5084 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
5085 
    except CatalogServiceException, cex:
5086 
      result.cex = cex
5087 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
5088 
    result.write(oprot)
5089 
    oprot.writeMessageEnd()
5090 
    oprot.trans.flush()
5091 
 
5092 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
5093 
    args = getAllItemsInRange_args()
5094 
    args.read(iprot)
5095 
    iprot.readMessageEnd()
5096 
    result = getAllItemsInRange_result()
5097 
    try:
5098 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
5099 
    except CatalogServiceException, cex:
5100 
      result.cex = cex
5101 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
5102 
    result.write(oprot)
5103 
    oprot.writeMessageEnd()
5104 
    oprot.trans.flush()
5105 
 
5106 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
5107 
    args = getAllItemsByStatusInRange_args()
5108 
    args.read(iprot)
5109 
    iprot.readMessageEnd()
5110 
    result = getAllItemsByStatusInRange_result()
5111 
    try:
5112 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
5113 
    except CatalogServiceException, cex:
5114 
      result.cex = cex
5115 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
5116 
    result.write(oprot)
5117 
    oprot.writeMessageEnd()
5118 
    oprot.trans.flush()
5119 
 
5120 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
5121 
    args = getItemCountByStatus_args()
5122 
    args.read(iprot)
5123 
    iprot.readMessageEnd()
5124 
    result = getItemCountByStatus_result()
5125 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
5126 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
5127 
    result.write(oprot)
5128 
    oprot.writeMessageEnd()
5129 
    oprot.trans.flush()
5130 
 
5131 
  def process_getBestSellers(self, seqid, iprot, oprot):
5132 
    args = getBestSellers_args()
5133 
    args.read(iprot)
5134 
    iprot.readMessageEnd()
5135 
    result = getBestSellers_result()
5136 
    try:
5137 
      result.success = self._handler.getBestSellers()
5138 
    except CatalogServiceException, isex:
5139 
      result.isex = isex
5140 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
5141 
    result.write(oprot)
5142 
    oprot.writeMessageEnd()
5143 
    oprot.trans.flush()
5144 
 
5145 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
5146 
    args = getBestSellersCatalogIds_args()
5147 
    args.read(iprot)
5148 
    iprot.readMessageEnd()
5149 
    result = getBestSellersCatalogIds_result()
5150 
    try:
5151 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5152 
    except CatalogServiceException, cex:
5153 
      result.cex = cex
5154 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
5155 
    result.write(oprot)
5156 
    oprot.writeMessageEnd()
5157 
    oprot.trans.flush()
5158 
 
5159 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
5160 
    args = getBestSellersCount_args()
5161 
    args.read(iprot)
5162 
    iprot.readMessageEnd()
5163 
    result = getBestSellersCount_result()
5164 
    try:
5165 
      result.success = self._handler.getBestSellersCount()
5166 
    except CatalogServiceException, cex:
5167 
      result.cex = cex
5168 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
5169 
    result.write(oprot)
5170 
    oprot.writeMessageEnd()
5171 
    oprot.trans.flush()
5172 
 
5173 
  def process_getBestDeals(self, seqid, iprot, oprot):
5174 
    args = getBestDeals_args()
5175 
    args.read(iprot)
5176 
    iprot.readMessageEnd()
5177 
    result = getBestDeals_result()
5178 
    try:
5179 
      result.success = self._handler.getBestDeals()
5180 
    except CatalogServiceException, isex:
5181 
      result.isex = isex
5182 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
5183 
    result.write(oprot)
5184 
    oprot.writeMessageEnd()
5185 
    oprot.trans.flush()
5186 
 
5187 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
5188 
    args = getBestDealsCatalogIds_args()
5189 
    args.read(iprot)
5190 
    iprot.readMessageEnd()
5191 
    result = getBestDealsCatalogIds_result()
5192 
    try:
5193 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5194 
    except CatalogServiceException, cex:
5195 
      result.cex = cex
5196 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
5197 
    result.write(oprot)
5198 
    oprot.writeMessageEnd()
5199 
    oprot.trans.flush()
5200 
 
5201 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
5202 
    args = getBestDealsCount_args()
5203 
    args.read(iprot)
5204 
    iprot.readMessageEnd()
5205 
    result = getBestDealsCount_result()
5206 
    try:
5207 
      result.success = self._handler.getBestDealsCount()
5208 
    except CatalogServiceException, cex:
5209 
      result.cex = cex
5210 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
5211 
    result.write(oprot)
5212 
    oprot.writeMessageEnd()
5213 
    oprot.trans.flush()
5214 
 
5215 
  def process_getComingSoon(self, seqid, iprot, oprot):
5216 
    args = getComingSoon_args()
5217 
    args.read(iprot)
5218 
    iprot.readMessageEnd()
5219 
    result = getComingSoon_result()
5220 
    try:
5221 
      result.success = self._handler.getComingSoon()
5222 
    except CatalogServiceException, isex:
5223 
      result.isex = isex
5224 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
5225 
    result.write(oprot)
5226 
    oprot.writeMessageEnd()
5227 
    oprot.trans.flush()
5228 
 
5229 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
5230 
    args = getComingSoonCatalogIds_args()
5231 
    args.read(iprot)
5232 
    iprot.readMessageEnd()
5233 
    result = getComingSoonCatalogIds_result()
5234 
    try:
5235 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
5236 
    except CatalogServiceException, cex:
5237 
      result.cex = cex
5238 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
5239 
    result.write(oprot)
5240 
    oprot.writeMessageEnd()
5241 
    oprot.trans.flush()
5242 
 
5243 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
5244 
    args = getComingSoonCount_args()
5245 
    args.read(iprot)
5246 
    iprot.readMessageEnd()
5247 
    result = getComingSoonCount_result()
5248 
    try:
5249 
      result.success = self._handler.getComingSoonCount()
5250 
    except CatalogServiceException, cex:
5251 
      result.cex = cex
5252 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
5253 
    result.write(oprot)
5254 
    oprot.writeMessageEnd()
5255 
    oprot.trans.flush()
5256 
 
5257 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
5258 
    args = getLatestArrivals_args()
5259 
    args.read(iprot)
5260 
    iprot.readMessageEnd()
5261 
    result = getLatestArrivals_result()
5262 
    try:
5263 
      result.success = self._handler.getLatestArrivals()
5264 
    except CatalogServiceException, isex:
5265 
      result.isex = isex
5266 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
5267 
    result.write(oprot)
5268 
    oprot.writeMessageEnd()
5269 
    oprot.trans.flush()
5270 
 
5271 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
5272 
    args = getLatestArrivalsCatalogIds_args()
5273 
    args.read(iprot)
5274 
    iprot.readMessageEnd()
5275 
    result = getLatestArrivalsCatalogIds_result()
5276 
    try:
5277 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
5278 
    except CatalogServiceException, cex:
5279 
      result.cex = cex
5280 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
5281 
    result.write(oprot)
5282 
    oprot.writeMessageEnd()
5283 
    oprot.trans.flush()
5284 
 
5285 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
5286 
    args = getLatestArrivalsCount_args()
5287 
    args.read(iprot)
5288 
    iprot.readMessageEnd()
5289 
    result = getLatestArrivalsCount_result()
5290 
    try:
5291 
      result.success = self._handler.getLatestArrivalsCount()
5292 
    except CatalogServiceException, cex:
5293 
      result.cex = cex
5294 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
5295 
    result.write(oprot)
5296 
    oprot.writeMessageEnd()
5297 
    oprot.trans.flush()
5298 
 
5299 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
5300 
    args = generateNewEntityID_args()
5301 
    args.read(iprot)
5302 
    iprot.readMessageEnd()
5303 
    result = generateNewEntityID_result()
5304 
    result.success = self._handler.generateNewEntityID()
5305 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
5306 
    result.write(oprot)
5307 
    oprot.writeMessageEnd()
5308 
    oprot.trans.flush()
5309 
 
5310 
  def process_addCategory(self, seqid, iprot, oprot):
5311 
    args = addCategory_args()
5312 
    args.read(iprot)
5313 
    iprot.readMessageEnd()
5314 
    result = addCategory_result()
5315 
    result.success = self._handler.addCategory(args.category)
5316 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
5317 
    result.write(oprot)
5318 
    oprot.writeMessageEnd()
5319 
    oprot.trans.flush()
5320 
 
5321 
  def process_getCategory(self, seqid, iprot, oprot):
5322 
    args = getCategory_args()
5323 
    args.read(iprot)
5324 
    iprot.readMessageEnd()
5325 
    result = getCategory_result()
5326 
    result.success = self._handler.getCategory(args.id)
5327 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
5328 
    result.write(oprot)
5329 
    oprot.writeMessageEnd()
5330 
    oprot.trans.flush()
5331 
 
5332 
  def process_getAllCategories(self, seqid, iprot, oprot):
5333 
    args = getAllCategories_args()
5334 
    args.read(iprot)
5335 
    iprot.readMessageEnd()
5336 
    result = getAllCategories_result()
5337 
    result.success = self._handler.getAllCategories()
5338 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
5339 
    result.write(oprot)
5340 
    oprot.writeMessageEnd()
5341 
    oprot.trans.flush()
5342 
 
5343 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
5344 
    args = getAllSimilarItems_args()
5345 
    args.read(iprot)
5346 
    iprot.readMessageEnd()
5347 
    result = getAllSimilarItems_result()
5348 
    result.success = self._handler.getAllSimilarItems(args.itemId)
5349 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
5350 
    result.write(oprot)
5351 
    oprot.writeMessageEnd()
5352 
    oprot.trans.flush()
5353 
 
5354 
  def process_addSimilarItem(self, seqid, iprot, oprot):
5355 
    args = addSimilarItem_args()
5356 
    args.read(iprot)
5357 
    iprot.readMessageEnd()
5358 
    result = addSimilarItem_result()
5359 
    try:
5360 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
5361 
    except CatalogServiceException, cex:
5362 
      result.cex = cex
5363 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
5364 
    result.write(oprot)
5365 
    oprot.writeMessageEnd()
5366 
    oprot.trans.flush()
5367 
 
6512 kshitij.so 5368 
  def process_addTag(self, seqid, iprot, oprot):
5369 
    args = addTag_args()
5370 
    args.read(iprot)
5371 
    iprot.readMessageEnd()
5372 
    result = addTag_result()
5373 
    result.success = self._handler.addTag(args.displayName, args.itemId)
5374 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
5375 
    result.write(oprot)
5376 
    oprot.writeMessageEnd()
5377 
    oprot.trans.flush()
5378 
 
5379 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
5380 
    args = deleteEntityTag_args()
5381 
    args.read(iprot)
5382 
    iprot.readMessageEnd()
5383 
    result = deleteEntityTag_result()
5384 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
5385 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
5386 
    result.write(oprot)
5387 
    oprot.writeMessageEnd()
5388 
    oprot.trans.flush()
5389 
 
5390 
  def process_deleteTag(self, seqid, iprot, oprot):
5391 
    args = deleteTag_args()
5392 
    args.read(iprot)
5393 
    iprot.readMessageEnd()
5394 
    result = deleteTag_result()
5395 
    result.success = self._handler.deleteTag(args.displayName)
5396 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
5397 
    result.write(oprot)
5398 
    oprot.writeMessageEnd()
5399 
    oprot.trans.flush()
5400 
 
5401 
  def process_getAllTags(self, seqid, iprot, oprot):
5402 
    args = getAllTags_args()
5403 
    args.read(iprot)
5404 
    iprot.readMessageEnd()
5405 
    result = getAllTags_result()
5406 
    result.success = self._handler.getAllTags()
5407 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
5408 
    result.write(oprot)
5409 
    oprot.writeMessageEnd()
5410 
    oprot.trans.flush()
5411 
 
5412 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
5413 
    args = getAllEntitiesByTagName_args()
5414 
    args.read(iprot)
5415 
    iprot.readMessageEnd()
5416 
    result = getAllEntitiesByTagName_result()
5417 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
5418 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
5419 
    result.write(oprot)
5420 
    oprot.writeMessageEnd()
5421 
    oprot.trans.flush()
5422 
 
6845 amit.gupta 5423 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
5424 
    args = getAllEntityTags_args()
5425 
    args.read(iprot)
5426 
    iprot.readMessageEnd()
5427 
    result = getAllEntityTags_result()
5428 
    result.success = self._handler.getAllEntityTags()
5429 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
5430 
    result.write(oprot)
5431 
    oprot.writeMessageEnd()
5432 
    oprot.trans.flush()
5433 
 
6850 kshitij.so 5434 
  def process_addBanner(self, seqid, iprot, oprot):
5435 
    args = addBanner_args()
5436 
    args.read(iprot)
5437 
    iprot.readMessageEnd()
5438 
    result = addBanner_result()
8590 kshitij.so 5439 
    self._handler.addBanner(args.bannerCongregate)
6850 kshitij.so 5440 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
5441 
    result.write(oprot)
5442 
    oprot.writeMessageEnd()
5443 
    oprot.trans.flush()
5444 
 
8579 kshitij.so 5445 
  def process_updateBanner(self, seqid, iprot, oprot):
5446 
    args = updateBanner_args()
5447 
    args.read(iprot)
5448 
    iprot.readMessageEnd()
5449 
    result = updateBanner_result()
5450 
    result.success = self._handler.updateBanner(args.banner)
5451 
    oprot.writeMessageBegin("updateBanner", TMessageType.REPLY, seqid)
5452 
    result.write(oprot)
5453 
    oprot.writeMessageEnd()
5454 
    oprot.trans.flush()
5455 
 
6850 kshitij.so 5456 
  def process_getAllBanners(self, seqid, iprot, oprot):
5457 
    args = getAllBanners_args()
5458 
    args.read(iprot)
5459 
    iprot.readMessageEnd()
5460 
    result = getAllBanners_result()
5461 
    result.success = self._handler.getAllBanners()
5462 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
5463 
    result.write(oprot)
5464 
    oprot.writeMessageEnd()
5465 
    oprot.trans.flush()
5466 
 
5467 
  def process_deleteBanner(self, seqid, iprot, oprot):
5468 
    args = deleteBanner_args()
5469 
    args.read(iprot)
5470 
    iprot.readMessageEnd()
5471 
    result = deleteBanner_result()
5472 
    result.success = self._handler.deleteBanner(args.bannerName)
5473 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
5474 
    result.write(oprot)
5475 
    oprot.writeMessageEnd()
5476 
    oprot.trans.flush()
5477 
 
5478 
  def process_getBannerDetails(self, seqid, iprot, oprot):
5479 
    args = getBannerDetails_args()
5480 
    args.read(iprot)
5481 
    iprot.readMessageEnd()
5482 
    result = getBannerDetails_result()
5483 
    result.success = self._handler.getBannerDetails(args.bannerName)
5484 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
5485 
    result.write(oprot)
5486 
    oprot.writeMessageEnd()
5487 
    oprot.trans.flush()
5488 
 
5489 
  def process_getActiveBanners(self, seqid, iprot, oprot):
5490 
    args = getActiveBanners_args()
5491 
    args.read(iprot)
5492 
    iprot.readMessageEnd()
5493 
    result = getActiveBanners_result()
5494 
    result.success = self._handler.getActiveBanners()
5495 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
5496 
    result.write(oprot)
5497 
    oprot.writeMessageEnd()
5498 
    oprot.trans.flush()
5499 
 
6849 kshitij.so 5500 
  def process_addBannerMap(self, seqid, iprot, oprot):
5501 
    args = addBannerMap_args()
5502 
    args.read(iprot)
5503 
    iprot.readMessageEnd()
5504 
    result = addBannerMap_result()
8579 kshitij.so 5505 
    result.success = self._handler.addBannerMap(args.bannerMaps)
6849 kshitij.so 5506 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
5507 
    result.write(oprot)
5508 
    oprot.writeMessageEnd()
5509 
    oprot.trans.flush()
5510 
 
8579 kshitij.so 5511 
  def process_updateBannerMap(self, seqid, iprot, oprot):
5512 
    args = updateBannerMap_args()
5513 
    args.read(iprot)
5514 
    iprot.readMessageEnd()
5515 
    result = updateBannerMap_result()
5516 
    result.success = self._handler.updateBannerMap(args.bannerMap)
5517 
    oprot.writeMessageBegin("updateBannerMap", TMessageType.REPLY, seqid)
5518 
    result.write(oprot)
5519 
    oprot.writeMessageEnd()
5520 
    oprot.trans.flush()
5521 
 
6849 kshitij.so 5522 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
5523 
    args = deleteBannerMap_args()
5524 
    args.read(iprot)
5525 
    iprot.readMessageEnd()
5526 
    result = deleteBannerMap_result()
5527 
    result.success = self._handler.deleteBannerMap(args.bannerName)
5528 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
5529 
    result.write(oprot)
5530 
    oprot.writeMessageEnd()
5531 
    oprot.trans.flush()
5532 
 
5533 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
5534 
    args = getBannerMapDetails_args()
5535 
    args.read(iprot)
5536 
    iprot.readMessageEnd()
5537 
    result = getBannerMapDetails_result()
5538 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
5539 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
5540 
    result.write(oprot)
5541 
    oprot.writeMessageEnd()
5542 
    oprot.trans.flush()
5543 
 
8579 kshitij.so 5544 
  def process_addBannerUri(self, seqid, iprot, oprot):
5545 
    args = addBannerUri_args()
5546 
    args.read(iprot)
5547 
    iprot.readMessageEnd()
5548 
    result = addBannerUri_result()
5549 
    self._handler.addBannerUri(args.bannerUriMappings)
5550 
    oprot.writeMessageBegin("addBannerUri", TMessageType.REPLY, seqid)
5551 
    result.write(oprot)
5552 
    oprot.writeMessageEnd()
5553 
    oprot.trans.flush()
5554 
 
5555 
  def process_getUriMapping(self, seqid, iprot, oprot):
5556 
    args = getUriMapping_args()
5557 
    args.read(iprot)
5558 
    iprot.readMessageEnd()
5559 
    result = getUriMapping_result()
5560 
    result.success = self._handler.getUriMapping(args.bannerName)
5561 
    oprot.writeMessageBegin("getUriMapping", TMessageType.REPLY, seqid)
5562 
    result.write(oprot)
5563 
    oprot.writeMessageEnd()
5564 
    oprot.trans.flush()
5565 
 
5566 
  def process_addCampaign(self, seqid, iprot, oprot):
5567 
    args = addCampaign_args()
5568 
    args.read(iprot)
5569 
    iprot.readMessageEnd()
5570 
    result = addCampaign_result()
5571 
    self._handler.addCampaign(args.campaign)
5572 
    oprot.writeMessageBegin("addCampaign", TMessageType.REPLY, seqid)
5573 
    result.write(oprot)
5574 
    oprot.writeMessageEnd()
5575 
    oprot.trans.flush()
5576 
 
5577 
  def process_getCampaigns(self, seqid, iprot, oprot):
5578 
    args = getCampaigns_args()
5579 
    args.read(iprot)
5580 
    iprot.readMessageEnd()
5581 
    result = getCampaigns_result()
5582 
    result.success = self._handler.getCampaigns(args.campaignName)
5583 
    oprot.writeMessageBegin("getCampaigns", TMessageType.REPLY, seqid)
5584 
    result.write(oprot)
5585 
    oprot.writeMessageEnd()
5586 
    oprot.trans.flush()
5587 
 
5588 
  def process_deleteCampaign(self, seqid, iprot, oprot):
5589 
    args = deleteCampaign_args()
5590 
    args.read(iprot)
5591 
    iprot.readMessageEnd()
5592 
    result = deleteCampaign_result()
5593 
    self._handler.deleteCampaign(args.campaignId)
5594 
    oprot.writeMessageBegin("deleteCampaign", TMessageType.REPLY, seqid)
5595 
    result.write(oprot)
5596 
    oprot.writeMessageEnd()
5597 
    oprot.trans.flush()
5598 
 
5599 
  def process_getAllCampaigns(self, seqid, iprot, oprot):
5600 
    args = getAllCampaigns_args()
5601 
    args.read(iprot)
5602 
    iprot.readMessageEnd()
5603 
    result = getAllCampaigns_result()
5604 
    result.success = self._handler.getAllCampaigns()
5605 
    oprot.writeMessageBegin("getAllCampaigns", TMessageType.REPLY, seqid)
5606 
    result.write(oprot)
5607 
    oprot.writeMessageEnd()
5608 
    oprot.trans.flush()
5609 
 
5944 mandeep.dh 5610 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
5611 
    args = deleteSimilarItem_args()
5612 
    args.read(iprot)
5613 
    iprot.readMessageEnd()
5614 
    result = deleteSimilarItem_result()
5615 
    try:
5616 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
5617 
    except CatalogServiceException, cex:
5618 
      result.cex = cex
5619 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
5620 
    result.write(oprot)
5621 
    oprot.writeMessageEnd()
5622 
    oprot.trans.flush()
5623 
 
5624 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
5625 
    args = checkSimilarItem_args()
5626 
    args.read(iprot)
5627 
    iprot.readMessageEnd()
5628 
    result = checkSimilarItem_result()
5629 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
5630 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
5631 
    result.write(oprot)
5632 
    oprot.writeMessageEnd()
5633 
    oprot.trans.flush()
5634 
 
5635 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
5636 
    args = validateRiskyStatus_args()
5637 
    args.read(iprot)
5638 
    iprot.readMessageEnd()
5639 
    result = validateRiskyStatus_result()
5640 
    self._handler.validateRiskyStatus(args.itemId)
5641 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
5642 
    result.write(oprot)
5643 
    oprot.writeMessageEnd()
5644 
    oprot.trans.flush()
5645 
 
5646 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
5647 
    args = changeItemRiskyFlag_args()
5648 
    args.read(iprot)
5649 
    iprot.readMessageEnd()
5650 
    result = changeItemRiskyFlag_result()
5651 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
5652 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
5653 
    result.write(oprot)
5654 
    oprot.writeMessageEnd()
5655 
    oprot.trans.flush()
5656 
 
5657 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
5658 
    args = getItemsByRiskyFlag_args()
5659 
    args.read(iprot)
5660 
    iprot.readMessageEnd()
5661 
    result = getItemsByRiskyFlag_result()
5662 
    result.success = self._handler.getItemsByRiskyFlag()
5663 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
5664 
    result.write(oprot)
5665 
    oprot.writeMessageEnd()
5666 
    oprot.trans.flush()
5667 
 
5668 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
5669 
    args = getItemsForMasterSheet_args()
5670 
    args.read(iprot)
5671 
    iprot.readMessageEnd()
5672 
    result = getItemsForMasterSheet_result()
5673 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
5674 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
5675 
    result.write(oprot)
5676 
    oprot.writeMessageEnd()
5677 
    oprot.trans.flush()
5678 
 
5679 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
5680 
    args = getSimilarItemsCatalogIds_args()
5681 
    args.read(iprot)
5682 
    iprot.readMessageEnd()
5683 
    result = getSimilarItemsCatalogIds_result()
5684 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
5685 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
5686 
    result.write(oprot)
5687 
    oprot.writeMessageEnd()
5688 
    oprot.trans.flush()
5689 
 
5690 
  def process_addProductNotification(self, seqid, iprot, oprot):
5691 
    args = addProductNotification_args()
5692 
    args.read(iprot)
5693 
    iprot.readMessageEnd()
5694 
    result = addProductNotification_result()
5695 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
5696 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
5697 
    result.write(oprot)
5698 
    oprot.writeMessageEnd()
5699 
    oprot.trans.flush()
5700 
 
5701 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
5702 
    args = sendProductNotifications_args()
5703 
    args.read(iprot)
5704 
    iprot.readMessageEnd()
5705 
    result = sendProductNotifications_result()
5706 
    result.success = self._handler.sendProductNotifications()
5707 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
5708 
    result.write(oprot)
5709 
    oprot.writeMessageEnd()
5710 
    oprot.trans.flush()
5711 
 
5712 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
5713 
    args = getAllBrandsByCategory_args()
5714 
    args.read(iprot)
5715 
    iprot.readMessageEnd()
5716 
    result = getAllBrandsByCategory_result()
5717 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
5718 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
5719 
    result.write(oprot)
5720 
    oprot.writeMessageEnd()
5721 
    oprot.trans.flush()
5722 
 
5723 
  def process_getAllBrands(self, seqid, iprot, oprot):
5724 
    args = getAllBrands_args()
5725 
    args.read(iprot)
5726 
    iprot.readMessageEnd()
5727 
    result = getAllBrands_result()
5728 
    result.success = self._handler.getAllBrands()
5729 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
5730 
    result.write(oprot)
5731 
    oprot.writeMessageEnd()
5732 
    oprot.trans.flush()
5733 
 
5734 
  def process_getAllSources(self, seqid, iprot, oprot):
5735 
    args = getAllSources_args()
5736 
    args.read(iprot)
5737 
    iprot.readMessageEnd()
5738 
    result = getAllSources_result()
5739 
    result.success = self._handler.getAllSources()
5740 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
5741 
    result.write(oprot)
5742 
    oprot.writeMessageEnd()
5743 
    oprot.trans.flush()
5744 
 
5745 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
5746 
    args = getItemPricingBySource_args()
5747 
    args.read(iprot)
5748 
    iprot.readMessageEnd()
5749 
    result = getItemPricingBySource_result()
5750 
    try:
5751 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
5752 
    except CatalogServiceException, cex:
5753 
      result.cex = cex
5754 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
5755 
    result.write(oprot)
5756 
    oprot.writeMessageEnd()
5757 
    oprot.trans.flush()
5758 
 
5759 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
5760 
    args = addSourceItemPricing_args()
5761 
    args.read(iprot)
5762 
    iprot.readMessageEnd()
5763 
    result = addSourceItemPricing_result()
5764 
    try:
5765 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
5766 
    except CatalogServiceException, cex:
5767 
      result.cex = cex
5768 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
5769 
    result.write(oprot)
5770 
    oprot.writeMessageEnd()
5771 
    oprot.trans.flush()
5772 
 
5773 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
5774 
    args = getAllSourcePricing_args()
5775 
    args.read(iprot)
5776 
    iprot.readMessageEnd()
5777 
    result = getAllSourcePricing_result()
5778 
    try:
5779 
      result.success = self._handler.getAllSourcePricing(args.itemId)
5780 
    except CatalogServiceException, cex:
5781 
      result.cex = cex
5782 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
5783 
    result.write(oprot)
5784 
    oprot.writeMessageEnd()
5785 
    oprot.trans.flush()
5786 
 
5787 
  def process_getItemForSource(self, seqid, iprot, oprot):
5788 
    args = getItemForSource_args()
5789 
    args.read(iprot)
5790 
    iprot.readMessageEnd()
5791 
    result = getItemForSource_result()
5792 
    try:
5793 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
5794 
    except CatalogServiceException, cex:
5795 
      result.cex = cex
5796 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
5797 
    result.write(oprot)
5798 
    oprot.writeMessageEnd()
5799 
    oprot.trans.flush()
5800 
 
5801 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
5802 
    args = searchItemsInRange_args()
5803 
    args.read(iprot)
5804 
    iprot.readMessageEnd()
5805 
    result = searchItemsInRange_result()
5806 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
5807 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
5808 
    result.write(oprot)
5809 
    oprot.writeMessageEnd()
5810 
    oprot.trans.flush()
5811 
 
5812 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
5813 
    args = getSearchResultCount_args()
5814 
    args.read(iprot)
5815 
    iprot.readMessageEnd()
5816 
    result = getSearchResultCount_result()
5817 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
5818 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
5819 
    result.write(oprot)
5820 
    oprot.writeMessageEnd()
5821 
    oprot.trans.flush()
5822 
 
5823 
  def process_getProductNotifications(self, seqid, iprot, oprot):
5824 
    args = getProductNotifications_args()
5825 
    args.read(iprot)
5826 
    iprot.readMessageEnd()
5827 
    result = getProductNotifications_result()
5828 
    result.success = self._handler.getProductNotifications(args.startDateTime)
5829 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
5830 
    result.write(oprot)
5831 
    oprot.writeMessageEnd()
5832 
    oprot.trans.flush()
5833 
 
5834 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
5835 
    args = getProductNotificationRequestCount_args()
5836 
    args.read(iprot)
5837 
    iprot.readMessageEnd()
5838 
    result = getProductNotificationRequestCount_result()
7897 amar.kumar 5839 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime, args.categoryId)
5944 mandeep.dh 5840 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
5841 
    result.write(oprot)
5842 
    oprot.writeMessageEnd()
5843 
    oprot.trans.flush()
5844 
 
5845 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
5846 
    args = addAuthorizationLog_args()
5847 
    args.read(iprot)
5848 
    iprot.readMessageEnd()
5849 
    result = addAuthorizationLog_result()
5850 
    try:
5851 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
5852 
    except CatalogServiceException, cex:
5853 
      result.cex = cex
5854 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
5855 
    result.write(oprot)
5856 
    oprot.writeMessageEnd()
5857 
    oprot.trans.flush()
5858 
 
5859 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
5860 
    args = addupdateVoucherForItem_args()
5861 
    args.read(iprot)
5862 
    iprot.readMessageEnd()
5863 
    result = addupdateVoucherForItem_result()
5864 
    try:
5865 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
5866 
    except CatalogServiceException, cex:
5867 
      result.cex = cex
5868 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
5869 
    result.write(oprot)
5870 
    oprot.writeMessageEnd()
5871 
    oprot.trans.flush()
5872 
 
5873 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
5874 
    args = deleteVoucherForItem_args()
5875 
    args.read(iprot)
5876 
    iprot.readMessageEnd()
5877 
    result = deleteVoucherForItem_result()
5878 
    try:
5879 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
5880 
    except CatalogServiceException, cex:
5881 
      result.cex = cex
5882 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
5883 
    result.write(oprot)
5884 
    oprot.writeMessageEnd()
5885 
    oprot.trans.flush()
5886 
 
5887 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
5888 
    args = getVoucherAmount_args()
5889 
    args.read(iprot)
5890 
    iprot.readMessageEnd()
5891 
    result = getVoucherAmount_result()
5892 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
5893 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
5894 
    result.write(oprot)
5895 
    oprot.writeMessageEnd()
5896 
    oprot.trans.flush()
5897 
 
5898 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
5899 
    args = getAllItemVouchers_args()
5900 
    args.read(iprot)
5901 
    iprot.readMessageEnd()
5902 
    result = getAllItemVouchers_result()
5903 
    result.success = self._handler.getAllItemVouchers(args.itemId)
5904 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
5905 
    result.write(oprot)
5906 
    oprot.writeMessageEnd()
5907 
    oprot.trans.flush()
5908 
 
5909 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
5910 
    args = isValidCatalogItemId_args()
5911 
    args.read(iprot)
5912 
    iprot.readMessageEnd()
5913 
    result = isValidCatalogItemId_result()
5914 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
5915 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
5916 
    result.write(oprot)
5917 
    oprot.writeMessageEnd()
5918 
    oprot.trans.flush()
5919 
 
6039 amit.gupta 5920 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
5921 
    args = getVatPercentageForItem_args()
5922 
    args.read(iprot)
5923 
    iprot.readMessageEnd()
5924 
    result = getVatPercentageForItem_result()
7340 amit.gupta 5925 
    try:
5926 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
5927 
    except CatalogServiceException, cex:
5928 
      result.cex = cex
6039 amit.gupta 5929 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
5930 
    result.write(oprot)
5931 
    oprot.writeMessageEnd()
5932 
    oprot.trans.flush()
5944 mandeep.dh 5933 
 
6039 amit.gupta 5934 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
5935 
    args = getVatAmountForItem_args()
5936 
    args.read(iprot)
5937 
    iprot.readMessageEnd()
5938 
    result = getVatAmountForItem_result()
5939 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
5940 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
5941 
    result.write(oprot)
5942 
    oprot.writeMessageEnd()
5943 
    oprot.trans.flush()
5944 
 
6531 vikram.rag 5945 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
5946 
    args = getAllIgnoredInventoryUpdateItemsList_args()
5947 
    args.read(iprot)
5948 
    iprot.readMessageEnd()
5949 
    result = getAllIgnoredInventoryUpdateItemsList_result()
5950 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
5951 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
5952 
    result.write(oprot)
5953 
    oprot.writeMessageEnd()
5954 
    oprot.trans.flush()
6039 amit.gupta 5955 
 
6821 amar.kumar 5956 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
5957 
    args = getAllAliveItems_args()
5958 
    args.read(iprot)
5959 
    iprot.readMessageEnd()
5960 
    result = getAllAliveItems_result()
5961 
    result.success = self._handler.getAllAliveItems()
5962 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
5963 
    result.write(oprot)
5964 
    oprot.writeMessageEnd()
5965 
    oprot.trans.flush()
5966 
 
6805 anupam.sin 5967 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
5968 
    args = getInsuranceAmount_args()
5969 
    args.read(iprot)
5970 
    iprot.readMessageEnd()
5971 
    result = getInsuranceAmount_result()
6921 anupam.sin 5972 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 5973 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
5974 
    result.write(oprot)
5975 
    oprot.writeMessageEnd()
5976 
    oprot.trans.flush()
6531 vikram.rag 5977 
 
6805 anupam.sin 5978 
  def process_getInsurer(self, seqid, iprot, oprot):
5979 
    args = getInsurer_args()
5980 
    args.read(iprot)
5981 
    iprot.readMessageEnd()
5982 
    result = getInsurer_result()
5983 
    result.success = self._handler.getInsurer(args.insurerId)
5984 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
5985 
    result.write(oprot)
5986 
    oprot.writeMessageEnd()
5987 
    oprot.trans.flush()
5988 
 
6838 vikram.rag 5989 
  def process_getAllInsurers(self, seqid, iprot, oprot):
5990 
    args = getAllInsurers_args()
5991 
    args.read(iprot)
5992 
    iprot.readMessageEnd()
5993 
    result = getAllInsurers_result()
5994 
    result.success = self._handler.getAllInsurers()
5995 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
5996 
    result.write(oprot)
5997 
    oprot.writeMessageEnd()
5998 
    oprot.trans.flush()
6805 anupam.sin 5999 
 
6962 rajveer 6000 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
6001 
    args = updateInsuranceDeclaredAmount_args()
6002 
    args.read(iprot)
6003 
    iprot.readMessageEnd()
6004 
    result = updateInsuranceDeclaredAmount_result()
6005 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
6006 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
6007 
    result.write(oprot)
6008 
    oprot.writeMessageEnd()
6009 
    oprot.trans.flush()
6838 vikram.rag 6010 
 
7190 amar.kumar 6011 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
6012 
    args = getFreebieForItem_args()
6013 
    args.read(iprot)
6014 
    iprot.readMessageEnd()
6015 
    result = getFreebieForItem_result()
6016 
    result.success = self._handler.getFreebieForItem(args.itemId)
6017 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
6018 
    result.write(oprot)
6019 
    oprot.writeMessageEnd()
6020 
    oprot.trans.flush()
6962 rajveer 6021 
 
7190 amar.kumar 6022 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
6023 
    args = addOrUpdateFreebieForItem_args()
6024 
    args.read(iprot)
6025 
    iprot.readMessageEnd()
6026 
    result = addOrUpdateFreebieForItem_result()
6027 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
6028 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
6029 
    result.write(oprot)
6030 
    oprot.writeMessageEnd()
6031 
    oprot.trans.flush()
6032 
 
7272 amit.gupta 6033 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
6034 
    args = addOrUpdateBrandInfo_args()
6035 
    args.read(iprot)
6036 
    iprot.readMessageEnd()
6037 
    result = addOrUpdateBrandInfo_result()
6038 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
6039 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
6040 
    result.write(oprot)
6041 
    oprot.writeMessageEnd()
6042 
    oprot.trans.flush()
6043 
 
6044 
  def process_getBrandInfo(self, seqid, iprot, oprot):
6045 
    args = getBrandInfo_args()
6046 
    args.read(iprot)
6047 
    iprot.readMessageEnd()
6048 
    result = getBrandInfo_result()
6049 
    result.success = self._handler.getBrandInfo()
6050 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
6051 
    result.write(oprot)
6052 
    oprot.writeMessageEnd()
6053 
    oprot.trans.flush()
6054 
 
7256 rajveer 6055 
  def process_getStorePricing(self, seqid, iprot, oprot):
6056 
    args = getStorePricing_args()
6057 
    args.read(iprot)
6058 
    iprot.readMessageEnd()
6059 
    result = getStorePricing_result()
6060 
    result.success = self._handler.getStorePricing(args.itemId)
6061 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
6062 
    result.write(oprot)
6063 
    oprot.writeMessageEnd()
6064 
    oprot.trans.flush()
7190 amar.kumar 6065 
 
7306 rajveer 6066 
  def process_getStorePricings(self, seqid, iprot, oprot):
6067 
    args = getStorePricings_args()
6068 
    args.read(iprot)
6069 
    iprot.readMessageEnd()
6070 
    result = getStorePricings_result()
6071 
    result.success = self._handler.getStorePricings(args.itemIds)
6072 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
6073 
    result.write(oprot)
6074 
    oprot.writeMessageEnd()
6075 
    oprot.trans.flush()
6076 
 
7265 rajveer 6077 
  def process_updateStorePricing(self, seqid, iprot, oprot):
6078 
    args = updateStorePricing_args()
6079 
    args.read(iprot)
6080 
    iprot.readMessageEnd()
6081 
    result = updateStorePricing_result()
7382 rajveer 6082 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 6083 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
6084 
    result.write(oprot)
6085 
    oprot.writeMessageEnd()
6086 
    oprot.trans.flush()
7256 rajveer 6087 
 
7281 kshitij.so 6088 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
6089 
    args = getAllAmazonListedItems_args()
6090 
    args.read(iprot)
6091 
    iprot.readMessageEnd()
6092 
    result = getAllAmazonListedItems_result()
6093 
    result.success = self._handler.getAllAmazonListedItems()
6094 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
6095 
    result.write(oprot)
6096 
    oprot.writeMessageEnd()
6097 
    oprot.trans.flush()
7265 rajveer 6098 
 
8619 kshitij.so 6099 
  def process_searchAmazonItems(self, seqid, iprot, oprot):
6100 
    args = searchAmazonItems_args()
6101 
    args.read(iprot)
6102 
    iprot.readMessageEnd()
6103 
    result = searchAmazonItems_result()
6104 
    result.success = self._handler.searchAmazonItems(args.searchTerm, args.offset, args.limit)
6105 
    oprot.writeMessageBegin("searchAmazonItems", TMessageType.REPLY, seqid)
6106 
    result.write(oprot)
6107 
    oprot.writeMessageEnd()
6108 
    oprot.trans.flush()
6109 
 
6110 
  def process_getAmazonSearchResultCount(self, seqid, iprot, oprot):
6111 
    args = getAmazonSearchResultCount_args()
6112 
    args.read(iprot)
6113 
    iprot.readMessageEnd()
6114 
    result = getAmazonSearchResultCount_result()
6115 
    result.success = self._handler.getAmazonSearchResultCount(args.searchTerm)
6116 
    oprot.writeMessageBegin("getAmazonSearchResultCount", TMessageType.REPLY, seqid)
6117 
    result.write(oprot)
6118 
    oprot.writeMessageEnd()
6119 
    oprot.trans.flush()
6120 
 
6121 
  def process_getCountForAmazonlistedItems(self, seqid, iprot, oprot):
6122 
    args = getCountForAmazonlistedItems_args()
6123 
    args.read(iprot)
6124 
    iprot.readMessageEnd()
6125 
    result = getCountForAmazonlistedItems_result()
6126 
    result.success = self._handler.getCountForAmazonlistedItems()
6127 
    oprot.writeMessageBegin("getCountForAmazonlistedItems", TMessageType.REPLY, seqid)
6128 
    result.write(oprot)
6129 
    oprot.writeMessageEnd()
6130 
    oprot.trans.flush()
6131 
 
7281 kshitij.so 6132 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
6133 
    args = getAmazonItemDetails_args()
6134 
    args.read(iprot)
6135 
    iprot.readMessageEnd()
6136 
    result = getAmazonItemDetails_result()
6137 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
6138 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
6139 
    result.write(oprot)
6140 
    oprot.writeMessageEnd()
6141 
    oprot.trans.flush()
6142 
 
6143 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
6144 
    args = updateAmazonItemDetails_args()
6145 
    args.read(iprot)
6146 
    iprot.readMessageEnd()
6147 
    result = updateAmazonItemDetails_result()
8168 kshitij.so 6148 
    self._handler.updateAmazonItemDetails(args.amazonlisted)
7281 kshitij.so 6149 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
6150 
    result.write(oprot)
6151 
    oprot.writeMessageEnd()
6152 
    oprot.trans.flush()
6153 
 
6154 
  def process_addAmazonItem(self, seqid, iprot, oprot):
6155 
    args = addAmazonItem_args()
6156 
    args.read(iprot)
6157 
    iprot.readMessageEnd()
6158 
    result = addAmazonItem_result()
6159 
    self._handler.addAmazonItem(args.amazonlisted)
6160 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
6161 
    result.write(oprot)
6162 
    oprot.writeMessageEnd()
6163 
    oprot.trans.flush()
6164 
 
7291 vikram.rag 6165 
  def process_getAsinItems(self, seqid, iprot, oprot):
6166 
    args = getAsinItems_args()
6167 
    args.read(iprot)
6168 
    iprot.readMessageEnd()
6169 
    result = getAsinItems_result()
6170 
    result.success = self._handler.getAsinItems()
6171 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
6172 
    result.write(oprot)
6173 
    oprot.writeMessageEnd()
6174 
    oprot.trans.flush()
7281 kshitij.so 6175 
 
7291 vikram.rag 6176 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
6177 
    args = getAllFbaListedItems_args()
6178 
    args.read(iprot)
6179 
    iprot.readMessageEnd()
6180 
    result = getAllFbaListedItems_result()
6181 
    result.success = self._handler.getAllFbaListedItems()
6182 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
6183 
    result.write(oprot)
6184 
    oprot.writeMessageEnd()
6185 
    oprot.trans.flush()
6186 
 
6187 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
6188 
    args = getAllNonFbaListedItems_args()
6189 
    args.read(iprot)
6190 
    iprot.readMessageEnd()
6191 
    result = getAllNonFbaListedItems_result()
6192 
    result.success = self._handler.getAllNonFbaListedItems()
6193 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
6194 
    result.write(oprot)
6195 
    oprot.writeMessageEnd()
6196 
    oprot.trans.flush()
6197 
 
7460 kshitij.so 6198 
  def process_updateItemInventory(self, seqid, iprot, oprot):
6199 
    args = updateItemInventory_args()
6200 
    args.read(iprot)
6201 
    iprot.readMessageEnd()
6202 
    result = updateItemInventory_result()
6203 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
6204 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
6205 
    result.write(oprot)
6206 
    oprot.writeMessageEnd()
6207 
    oprot.trans.flush()
7291 vikram.rag 6208 
 
7770 kshitij.so 6209 
  def process_updateTimestampForAmazonFeeds(self, seqid, iprot, oprot):
6210 
    args = updateTimestampForAmazonFeeds_args()
6211 
    args.read(iprot)
6212 
    iprot.readMessageEnd()
6213 
    result = updateTimestampForAmazonFeeds_result()
6214 
    result.success = self._handler.updateTimestampForAmazonFeeds(args.type, args.sku, args.timestamp)
6215 
    oprot.writeMessageBegin("updateTimestampForAmazonFeeds", TMessageType.REPLY, seqid)
6216 
    result.write(oprot)
6217 
    oprot.writeMessageEnd()
6218 
    oprot.trans.flush()
7460 kshitij.so 6219 
 
7897 amar.kumar 6220 
  def process_getAllParentCategories(self, seqid, iprot, oprot):
6221 
    args = getAllParentCategories_args()
6222 
    args.read(iprot)
6223 
    iprot.readMessageEnd()
6224 
    result = getAllParentCategories_result()
6225 
    result.success = self._handler.getAllParentCategories()
6226 
    oprot.writeMessageBegin("getAllParentCategories", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
7770 kshitij.so 6230 
 
7977 kshitij.so 6231 
  def process_addPageViewEvent(self, seqid, iprot, oprot):
6232 
    args = addPageViewEvent_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = addPageViewEvent_result()
6236 
    self._handler.addPageViewEvent(args.pageViewEvents)
6237 
    oprot.writeMessageBegin("addPageViewEvent", TMessageType.REPLY, seqid)
6238 
    result.write(oprot)
6239 
    oprot.writeMessageEnd()
6240 
    oprot.trans.flush()
7897 amar.kumar 6241 
 
7977 kshitij.so 6242 
  def process_addCartEvent(self, seqid, iprot, oprot):
6243 
    args = addCartEvent_args()
6244 
    args.read(iprot)
6245 
    iprot.readMessageEnd()
6246 
    result = addCartEvent_result()
6247 
    self._handler.addCartEvent(args.cartEvents)
6248 
    oprot.writeMessageBegin("addCartEvent", TMessageType.REPLY, seqid)
6249 
    result.write(oprot)
6250 
    oprot.writeMessageEnd()
6251 
    oprot.trans.flush()
6252 
 
8182 amar.kumar 6253 
  def process_addEbayItem(self, seqid, iprot, oprot):
6254 
    args = addEbayItem_args()
6255 
    args.read(iprot)
6256 
    iprot.readMessageEnd()
6257 
    result = addEbayItem_result()
6258 
    self._handler.addEbayItem(args.ebayItem)
6259 
    oprot.writeMessageBegin("addEbayItem", TMessageType.REPLY, seqid)
6260 
    result.write(oprot)
6261 
    oprot.writeMessageEnd()
6262 
    oprot.trans.flush()
6263 
 
6264 
  def process_getEbayItem(self, seqid, iprot, oprot):
6265 
    args = getEbayItem_args()
6266 
    args.read(iprot)
6267 
    iprot.readMessageEnd()
6268 
    result = getEbayItem_result()
6269 
    result.success = self._handler.getEbayItem(args.listingId)
6270 
    oprot.writeMessageBegin("getEbayItem", TMessageType.REPLY, seqid)
6271 
    result.write(oprot)
6272 
    oprot.writeMessageEnd()
6273 
    oprot.trans.flush()
6274 
 
6275 
  def process_updateEbayItem(self, seqid, iprot, oprot):
6276 
    args = updateEbayItem_args()
6277 
    args.read(iprot)
6278 
    iprot.readMessageEnd()
6279 
    result = updateEbayItem_result()
6280 
    self._handler.updateEbayItem(args.ebayItem)
6281 
    oprot.writeMessageBegin("updateEbayItem", TMessageType.REPLY, seqid)
6282 
    result.write(oprot)
6283 
    oprot.writeMessageEnd()
6284 
    oprot.trans.flush()
6285 
 
8139 kshitij.so 6286 
  def process_getAmazonListedItems(self, seqid, iprot, oprot):
6287 
    args = getAmazonListedItems_args()
6288 
    args.read(iprot)
6289 
    iprot.readMessageEnd()
6290 
    result = getAmazonListedItems_result()
6291 
    result.success = self._handler.getAmazonListedItems(args.offset, args.limit)
6292 
    oprot.writeMessageBegin("getAmazonListedItems", TMessageType.REPLY, seqid)
6293 
    result.write(oprot)
6294 
    oprot.writeMessageEnd()
6295 
    oprot.trans.flush()
7977 kshitij.so 6296 
 
8168 kshitij.so 6297 
  def process_updateAmazonAttributesInBulk(self, seqid, iprot, oprot):
6298 
    args = updateAmazonAttributesInBulk_args()
6299 
    args.read(iprot)
6300 
    iprot.readMessageEnd()
6301 
    result = updateAmazonAttributesInBulk_result()
6302 
    result.success = self._handler.updateAmazonAttributesInBulk(args.amazonlisted)
6303 
    oprot.writeMessageBegin("updateAmazonAttributesInBulk", TMessageType.REPLY, seqid)
6304 
    result.write(oprot)
6305 
    oprot.writeMessageEnd()
6306 
    oprot.trans.flush()
8139 kshitij.so 6307 
 
8379 vikram.rag 6308 
  def process_getAllItemstoListOnFba(self, seqid, iprot, oprot):
6309 
    args = getAllItemstoListOnFba_args()
6310 
    args.read(iprot)
6311 
    iprot.readMessageEnd()
6312 
    result = getAllItemstoListOnFba_result()
6313 
    result.success = self._handler.getAllItemstoListOnFba()
6314 
    oprot.writeMessageBegin("getAllItemstoListOnFba", TMessageType.REPLY, seqid)
6315 
    result.write(oprot)
6316 
    oprot.writeMessageEnd()
6317 
    oprot.trans.flush()
8168 kshitij.so 6318 
 
8379 vikram.rag 6319 
  def process_getAllItemstoListOnNonFba(self, seqid, iprot, oprot):
6320 
    args = getAllItemstoListOnNonFba_args()
6321 
    args.read(iprot)
6322 
    iprot.readMessageEnd()
6323 
    result = getAllItemstoListOnNonFba_result()
6324 
    result.success = self._handler.getAllItemstoListOnNonFba()
6325 
    oprot.writeMessageBegin("getAllItemstoListOnNonFba", TMessageType.REPLY, seqid)
6326 
    result.write(oprot)
6327 
    oprot.writeMessageEnd()
6328 
    oprot.trans.flush()
6329 
 
8616 vikram.rag 6330 
  def process_getAllSnapdealListedActiveItems(self, seqid, iprot, oprot):
6331 
    args = getAllSnapdealListedActiveItems_args()
6332 
    args.read(iprot)
6333 
    iprot.readMessageEnd()
6334 
    result = getAllSnapdealListedActiveItems_result()
6335 
    result.success = self._handler.getAllSnapdealListedActiveItems()
6336 
    oprot.writeMessageBegin("getAllSnapdealListedActiveItems", TMessageType.REPLY, seqid)
6337 
    result.write(oprot)
6338 
    oprot.writeMessageEnd()
6339 
    oprot.trans.flush()
8379 vikram.rag 6340 
 
8619 kshitij.so 6341 
  def process_updateAsin(self, seqid, iprot, oprot):
6342 
    args = updateAsin_args()
6343 
    args.read(iprot)
6344 
    iprot.readMessageEnd()
6345 
    result = updateAsin_result()
6346 
    self._handler.updateAsin(args.item)
6347 
    oprot.writeMessageBegin("updateAsin", TMessageType.REPLY, seqid)
6348 
    result.write(oprot)
6349 
    oprot.writeMessageEnd()
6350 
    oprot.trans.flush()
8616 vikram.rag 6351 
 
8739 vikram.rag 6352 
  def process_addOrUpdateSnapdealItem(self, seqid, iprot, oprot):
6353 
    args = addOrUpdateSnapdealItem_args()
6354 
    args.read(iprot)
6355 
    iprot.readMessageEnd()
6356 
    result = addOrUpdateSnapdealItem_result()
6357 
    result.success = self._handler.addOrUpdateSnapdealItem(args.snapdealitem)
6358 
    oprot.writeMessageBegin("addOrUpdateSnapdealItem", TMessageType.REPLY, seqid)
6359 
    result.write(oprot)
6360 
    oprot.writeMessageEnd()
6361 
    oprot.trans.flush()
8619 kshitij.so 6362 
 
8739 vikram.rag 6363 
  def process_getSnapdealItem(self, seqid, iprot, oprot):
6364 
    args = getSnapdealItem_args()
6365 
    args.read(iprot)
6366 
    iprot.readMessageEnd()
6367 
    result = getSnapdealItem_result()
6368 
    result.success = self._handler.getSnapdealItem(args.item_id)
6369 
    oprot.writeMessageBegin("getSnapdealItem", TMessageType.REPLY, seqid)
6370 
    result.write(oprot)
6371 
    oprot.writeMessageEnd()
6372 
    oprot.trans.flush()
6373 
 
6374 
  def process_getAllSnapdealItems(self, seqid, iprot, oprot):
6375 
    args = getAllSnapdealItems_args()
6376 
    args.read(iprot)
6377 
    iprot.readMessageEnd()
6378 
    result = getAllSnapdealItems_result()
6379 
    result.success = self._handler.getAllSnapdealItems()
6380 
    oprot.writeMessageBegin("getAllSnapdealItems", TMessageType.REPLY, seqid)
6381 
    result.write(oprot)
6382 
    oprot.writeMessageEnd()
6383 
    oprot.trans.flush()
6384 
 
6385 
 
5944 mandeep.dh 6386 
# HELPER FUNCTIONS AND STRUCTURES
6387 
 
6388 
class addItem_args:
6389 
  """
6390 
  Attributes:
6391 
   - item
6392 
  """
6393 
 
6394 
  thrift_spec = (
6395 
    None, # 0
6396 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6397 
  )
6398 
 
6399 
  def __init__(self, item=None,):
6400 
    self.item = item
6401 
 
6402 
  def read(self, iprot):
6403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6405 
      return
6406 
    iprot.readStructBegin()
6407 
    while True:
6408 
      (fname, ftype, fid) = iprot.readFieldBegin()
6409 
      if ftype == TType.STOP:
6410 
        break
6411 
      if fid == 1:
6412 
        if ftype == TType.STRUCT:
6413 
          self.item = Item()
6414 
          self.item.read(iprot)
6415 
        else:
6416 
          iprot.skip(ftype)
6417 
      else:
6418 
        iprot.skip(ftype)
6419 
      iprot.readFieldEnd()
6420 
    iprot.readStructEnd()
6421 
 
6422 
  def write(self, oprot):
6423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6425 
      return
6426 
    oprot.writeStructBegin('addItem_args')
6427 
    if self.item is not None:
6428 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6429 
      self.item.write(oprot)
6430 
      oprot.writeFieldEnd()
6431 
    oprot.writeFieldStop()
6432 
    oprot.writeStructEnd()
6433 
 
6434 
  def validate(self):
6435 
    return
6436 
 
6437 
 
6438 
  def __repr__(self):
6439 
    L = ['%s=%r' % (key, value)
6440 
      for key, value in self.__dict__.iteritems()]
6441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6442 
 
6443 
  def __eq__(self, other):
6444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6445 
 
6446 
  def __ne__(self, other):
6447 
    return not (self == other)
6448 
 
6449 
class addItem_result:
6450 
  """
6451 
  Attributes:
6452 
   - success
6453 
   - cex
6454 
  """
6455 
 
6456 
  thrift_spec = (
6457 
    (0, TType.I64, 'success', None, None, ), # 0
6458 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6459 
  )
6460 
 
6461 
  def __init__(self, success=None, cex=None,):
6462 
    self.success = success
6463 
    self.cex = cex
6464 
 
6465 
  def read(self, iprot):
6466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6468 
      return
6469 
    iprot.readStructBegin()
6470 
    while True:
6471 
      (fname, ftype, fid) = iprot.readFieldBegin()
6472 
      if ftype == TType.STOP:
6473 
        break
6474 
      if fid == 0:
6475 
        if ftype == TType.I64:
6476 
          self.success = iprot.readI64();
6477 
        else:
6478 
          iprot.skip(ftype)
6479 
      elif fid == 1:
6480 
        if ftype == TType.STRUCT:
6481 
          self.cex = CatalogServiceException()
6482 
          self.cex.read(iprot)
6483 
        else:
6484 
          iprot.skip(ftype)
6485 
      else:
6486 
        iprot.skip(ftype)
6487 
      iprot.readFieldEnd()
6488 
    iprot.readStructEnd()
6489 
 
6490 
  def write(self, oprot):
6491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6493 
      return
6494 
    oprot.writeStructBegin('addItem_result')
6495 
    if self.success is not None:
6496 
      oprot.writeFieldBegin('success', TType.I64, 0)
6497 
      oprot.writeI64(self.success)
6498 
      oprot.writeFieldEnd()
6499 
    if self.cex is not None:
6500 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6501 
      self.cex.write(oprot)
6502 
      oprot.writeFieldEnd()
6503 
    oprot.writeFieldStop()
6504 
    oprot.writeStructEnd()
6505 
 
6506 
  def validate(self):
6507 
    return
6508 
 
6509 
 
6510 
  def __repr__(self):
6511 
    L = ['%s=%r' % (key, value)
6512 
      for key, value in self.__dict__.iteritems()]
6513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6514 
 
6515 
  def __eq__(self, other):
6516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6517 
 
6518 
  def __ne__(self, other):
6519 
    return not (self == other)
6520 
 
6521 
class updateItem_args:
6522 
  """
6523 
  Attributes:
6524 
   - item
6525 
  """
6526 
 
6527 
  thrift_spec = (
6528 
    None, # 0
6529 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
6530 
  )
6531 
 
6532 
  def __init__(self, item=None,):
6533 
    self.item = item
6534 
 
6535 
  def read(self, iprot):
6536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6538 
      return
6539 
    iprot.readStructBegin()
6540 
    while True:
6541 
      (fname, ftype, fid) = iprot.readFieldBegin()
6542 
      if ftype == TType.STOP:
6543 
        break
6544 
      if fid == 1:
6545 
        if ftype == TType.STRUCT:
6546 
          self.item = Item()
6547 
          self.item.read(iprot)
6548 
        else:
6549 
          iprot.skip(ftype)
6550 
      else:
6551 
        iprot.skip(ftype)
6552 
      iprot.readFieldEnd()
6553 
    iprot.readStructEnd()
6554 
 
6555 
  def write(self, oprot):
6556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6558 
      return
6559 
    oprot.writeStructBegin('updateItem_args')
6560 
    if self.item is not None:
6561 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
6562 
      self.item.write(oprot)
6563 
      oprot.writeFieldEnd()
6564 
    oprot.writeFieldStop()
6565 
    oprot.writeStructEnd()
6566 
 
6567 
  def validate(self):
6568 
    return
6569 
 
6570 
 
6571 
  def __repr__(self):
6572 
    L = ['%s=%r' % (key, value)
6573 
      for key, value in self.__dict__.iteritems()]
6574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6575 
 
6576 
  def __eq__(self, other):
6577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6578 
 
6579 
  def __ne__(self, other):
6580 
    return not (self == other)
6581 
 
6582 
class updateItem_result:
6583 
  """
6584 
  Attributes:
6585 
   - success
6586 
   - cex
6587 
  """
6588 
 
6589 
  thrift_spec = (
6590 
    (0, TType.I64, 'success', None, None, ), # 0
6591 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6592 
  )
6593 
 
6594 
  def __init__(self, success=None, cex=None,):
6595 
    self.success = success
6596 
    self.cex = cex
6597 
 
6598 
  def read(self, iprot):
6599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6601 
      return
6602 
    iprot.readStructBegin()
6603 
    while True:
6604 
      (fname, ftype, fid) = iprot.readFieldBegin()
6605 
      if ftype == TType.STOP:
6606 
        break
6607 
      if fid == 0:
6608 
        if ftype == TType.I64:
6609 
          self.success = iprot.readI64();
6610 
        else:
6611 
          iprot.skip(ftype)
6612 
      elif fid == 1:
6613 
        if ftype == TType.STRUCT:
6614 
          self.cex = CatalogServiceException()
6615 
          self.cex.read(iprot)
6616 
        else:
6617 
          iprot.skip(ftype)
6618 
      else:
6619 
        iprot.skip(ftype)
6620 
      iprot.readFieldEnd()
6621 
    iprot.readStructEnd()
6622 
 
6623 
  def write(self, oprot):
6624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6626 
      return
6627 
    oprot.writeStructBegin('updateItem_result')
6628 
    if self.success is not None:
6629 
      oprot.writeFieldBegin('success', TType.I64, 0)
6630 
      oprot.writeI64(self.success)
6631 
      oprot.writeFieldEnd()
6632 
    if self.cex is not None:
6633 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6634 
      self.cex.write(oprot)
6635 
      oprot.writeFieldEnd()
6636 
    oprot.writeFieldStop()
6637 
    oprot.writeStructEnd()
6638 
 
6639 
  def validate(self):
6640 
    return
6641 
 
6642 
 
6643 
  def __repr__(self):
6644 
    L = ['%s=%r' % (key, value)
6645 
      for key, value in self.__dict__.iteritems()]
6646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6647 
 
6648 
  def __eq__(self, other):
6649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6650 
 
6651 
  def __ne__(self, other):
6652 
    return not (self == other)
6653 
 
6654 
class isActive_args:
6655 
  """
6656 
  Attributes:
6657 
   - itemId
6658 
  """
6659 
 
6660 
  thrift_spec = (
6661 
    None, # 0
6662 
    (1, TType.I64, 'itemId', None, None, ), # 1
6663 
  )
6664 
 
6665 
  def __init__(self, itemId=None,):
6666 
    self.itemId = itemId
6667 
 
6668 
  def read(self, iprot):
6669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6671 
      return
6672 
    iprot.readStructBegin()
6673 
    while True:
6674 
      (fname, ftype, fid) = iprot.readFieldBegin()
6675 
      if ftype == TType.STOP:
6676 
        break
6677 
      if fid == 1:
6678 
        if ftype == TType.I64:
6679 
          self.itemId = iprot.readI64();
6680 
        else:
6681 
          iprot.skip(ftype)
6682 
      else:
6683 
        iprot.skip(ftype)
6684 
      iprot.readFieldEnd()
6685 
    iprot.readStructEnd()
6686 
 
6687 
  def write(self, oprot):
6688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6690 
      return
6691 
    oprot.writeStructBegin('isActive_args')
6692 
    if self.itemId is not None:
6693 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6694 
      oprot.writeI64(self.itemId)
6695 
      oprot.writeFieldEnd()
6696 
    oprot.writeFieldStop()
6697 
    oprot.writeStructEnd()
6698 
 
6699 
  def validate(self):
6700 
    return
6701 
 
6702 
 
6703 
  def __repr__(self):
6704 
    L = ['%s=%r' % (key, value)
6705 
      for key, value in self.__dict__.iteritems()]
6706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6707 
 
6708 
  def __eq__(self, other):
6709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6710 
 
6711 
  def __ne__(self, other):
6712 
    return not (self == other)
6713 
 
6714 
class isActive_result:
6715 
  """
6716 
  Attributes:
6717 
   - success
6718 
   - isex
6719 
  """
6720 
 
6721 
  thrift_spec = (
6722 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
6723 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6724 
  )
6725 
 
6726 
  def __init__(self, success=None, isex=None,):
6727 
    self.success = success
6728 
    self.isex = isex
6729 
 
6730 
  def read(self, iprot):
6731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6733 
      return
6734 
    iprot.readStructBegin()
6735 
    while True:
6736 
      (fname, ftype, fid) = iprot.readFieldBegin()
6737 
      if ftype == TType.STOP:
6738 
        break
6739 
      if fid == 0:
6740 
        if ftype == TType.STRUCT:
6741 
          self.success = ItemShippingInfo()
6742 
          self.success.read(iprot)
6743 
        else:
6744 
          iprot.skip(ftype)
6745 
      elif fid == 1:
6746 
        if ftype == TType.STRUCT:
6747 
          self.isex = CatalogServiceException()
6748 
          self.isex.read(iprot)
6749 
        else:
6750 
          iprot.skip(ftype)
6751 
      else:
6752 
        iprot.skip(ftype)
6753 
      iprot.readFieldEnd()
6754 
    iprot.readStructEnd()
6755 
 
6756 
  def write(self, oprot):
6757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6759 
      return
6760 
    oprot.writeStructBegin('isActive_result')
6761 
    if self.success is not None:
6762 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6763 
      self.success.write(oprot)
6764 
      oprot.writeFieldEnd()
6765 
    if self.isex is not None:
6766 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6767 
      self.isex.write(oprot)
6768 
      oprot.writeFieldEnd()
6769 
    oprot.writeFieldStop()
6770 
    oprot.writeStructEnd()
6771 
 
6772 
  def validate(self):
6773 
    return
6774 
 
6775 
 
6776 
  def __repr__(self):
6777 
    L = ['%s=%r' % (key, value)
6778 
      for key, value in self.__dict__.iteritems()]
6779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6780 
 
6781 
  def __eq__(self, other):
6782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6783 
 
6784 
  def __ne__(self, other):
6785 
    return not (self == other)
6786 
 
7438 amit.gupta 6787 
class getItemsStatus_args:
6788 
  """
6789 
  Attributes:
6790 
   - itemIds
6791 
  """
6792 
 
6793 
  thrift_spec = (
6794 
    None, # 0
6795 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
6796 
  )
6797 
 
6798 
  def __init__(self, itemIds=None,):
6799 
    self.itemIds = itemIds
6800 
 
6801 
  def read(self, iprot):
6802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6804 
      return
6805 
    iprot.readStructBegin()
6806 
    while True:
6807 
      (fname, ftype, fid) = iprot.readFieldBegin()
6808 
      if ftype == TType.STOP:
6809 
        break
6810 
      if fid == 1:
6811 
        if ftype == TType.LIST:
6812 
          self.itemIds = []
8590 kshitij.so 6813 
          (_etype33, _size30) = iprot.readListBegin()
6814 
          for _i34 in xrange(_size30):
6815 
            _elem35 = iprot.readI64();
6816 
            self.itemIds.append(_elem35)
7438 amit.gupta 6817 
          iprot.readListEnd()
6818 
        else:
6819 
          iprot.skip(ftype)
6820 
      else:
6821 
        iprot.skip(ftype)
6822 
      iprot.readFieldEnd()
6823 
    iprot.readStructEnd()
6824 
 
6825 
  def write(self, oprot):
6826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6828 
      return
6829 
    oprot.writeStructBegin('getItemsStatus_args')
6830 
    if self.itemIds is not None:
6831 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
6832 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 6833 
      for iter36 in self.itemIds:
6834 
        oprot.writeI64(iter36)
7438 amit.gupta 6835 
      oprot.writeListEnd()
6836 
      oprot.writeFieldEnd()
6837 
    oprot.writeFieldStop()
6838 
    oprot.writeStructEnd()
6839 
 
6840 
  def validate(self):
6841 
    return
6842 
 
6843 
 
6844 
  def __repr__(self):
6845 
    L = ['%s=%r' % (key, value)
6846 
      for key, value in self.__dict__.iteritems()]
6847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6848 
 
6849 
  def __eq__(self, other):
6850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6851 
 
6852 
  def __ne__(self, other):
6853 
    return not (self == other)
6854 
 
6855 
class getItemsStatus_result:
6856 
  """
6857 
  Attributes:
6858 
   - success
6859 
   - isex
6860 
  """
6861 
 
6862 
  thrift_spec = (
6863 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
6864 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6865 
  )
6866 
 
6867 
  def __init__(self, success=None, isex=None,):
6868 
    self.success = success
6869 
    self.isex = isex
6870 
 
6871 
  def read(self, iprot):
6872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6874 
      return
6875 
    iprot.readStructBegin()
6876 
    while True:
6877 
      (fname, ftype, fid) = iprot.readFieldBegin()
6878 
      if ftype == TType.STOP:
6879 
        break
6880 
      if fid == 0:
6881 
        if ftype == TType.MAP:
6882 
          self.success = {}
8590 kshitij.so 6883 
          (_ktype38, _vtype39, _size37 ) = iprot.readMapBegin()
6884 
          for _i41 in xrange(_size37):
6885 
            _key42 = iprot.readI64();
6886 
            _val43 = iprot.readBool();
6887 
            self.success[_key42] = _val43
7438 amit.gupta 6888 
          iprot.readMapEnd()
6889 
        else:
6890 
          iprot.skip(ftype)
6891 
      elif fid == 1:
6892 
        if ftype == TType.STRUCT:
6893 
          self.isex = CatalogServiceException()
6894 
          self.isex.read(iprot)
6895 
        else:
6896 
          iprot.skip(ftype)
6897 
      else:
6898 
        iprot.skip(ftype)
6899 
      iprot.readFieldEnd()
6900 
    iprot.readStructEnd()
6901 
 
6902 
  def write(self, oprot):
6903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6905 
      return
6906 
    oprot.writeStructBegin('getItemsStatus_result')
6907 
    if self.success is not None:
6908 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6909 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
8590 kshitij.so 6910 
      for kiter44,viter45 in self.success.items():
6911 
        oprot.writeI64(kiter44)
6912 
        oprot.writeBool(viter45)
7438 amit.gupta 6913 
      oprot.writeMapEnd()
6914 
      oprot.writeFieldEnd()
6915 
    if self.isex is not None:
6916 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
6917 
      self.isex.write(oprot)
6918 
      oprot.writeFieldEnd()
6919 
    oprot.writeFieldStop()
6920 
    oprot.writeStructEnd()
6921 
 
6922 
  def validate(self):
6923 
    return
6924 
 
6925 
 
6926 
  def __repr__(self):
6927 
    L = ['%s=%r' % (key, value)
6928 
      for key, value in self.__dict__.iteritems()]
6929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6930 
 
6931 
  def __eq__(self, other):
6932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6933 
 
6934 
  def __ne__(self, other):
6935 
    return not (self == other)
6936 
 
5944 mandeep.dh 6937 
class getItemStatusDescription_args:
6938 
  """
6939 
  Attributes:
6940 
   - itemId
6941 
  """
6942 
 
6943 
  thrift_spec = (
6944 
    None, # 0
6945 
    (1, TType.I64, 'itemId', None, None, ), # 1
6946 
  )
6947 
 
6948 
  def __init__(self, itemId=None,):
6949 
    self.itemId = itemId
6950 
 
6951 
  def read(self, iprot):
6952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6954 
      return
6955 
    iprot.readStructBegin()
6956 
    while True:
6957 
      (fname, ftype, fid) = iprot.readFieldBegin()
6958 
      if ftype == TType.STOP:
6959 
        break
6960 
      if fid == 1:
6961 
        if ftype == TType.I64:
6962 
          self.itemId = iprot.readI64();
6963 
        else:
6964 
          iprot.skip(ftype)
6965 
      else:
6966 
        iprot.skip(ftype)
6967 
      iprot.readFieldEnd()
6968 
    iprot.readStructEnd()
6969 
 
6970 
  def write(self, oprot):
6971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6973 
      return
6974 
    oprot.writeStructBegin('getItemStatusDescription_args')
6975 
    if self.itemId is not None:
6976 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6977 
      oprot.writeI64(self.itemId)
6978 
      oprot.writeFieldEnd()
6979 
    oprot.writeFieldStop()
6980 
    oprot.writeStructEnd()
6981 
 
6982 
  def validate(self):
6983 
    return
6984 
 
6985 
 
6986 
  def __repr__(self):
6987 
    L = ['%s=%r' % (key, value)
6988 
      for key, value in self.__dict__.iteritems()]
6989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6990 
 
6991 
  def __eq__(self, other):
6992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6993 
 
6994 
  def __ne__(self, other):
6995 
    return not (self == other)
6996 
 
6997 
class getItemStatusDescription_result:
6998 
  """
6999 
  Attributes:
7000 
   - success
7001 
   - isex
7002 
  """
7003 
 
7004 
  thrift_spec = (
7005 
    (0, TType.STRING, 'success', None, None, ), # 0
7006 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7007 
  )
7008 
 
7009 
  def __init__(self, success=None, isex=None,):
7010 
    self.success = success
7011 
    self.isex = isex
7012 
 
7013 
  def read(self, iprot):
7014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7016 
      return
7017 
    iprot.readStructBegin()
7018 
    while True:
7019 
      (fname, ftype, fid) = iprot.readFieldBegin()
7020 
      if ftype == TType.STOP:
7021 
        break
7022 
      if fid == 0:
7023 
        if ftype == TType.STRING:
7024 
          self.success = iprot.readString();
7025 
        else:
7026 
          iprot.skip(ftype)
7027 
      elif fid == 1:
7028 
        if ftype == TType.STRUCT:
7029 
          self.isex = CatalogServiceException()
7030 
          self.isex.read(iprot)
7031 
        else:
7032 
          iprot.skip(ftype)
7033 
      else:
7034 
        iprot.skip(ftype)
7035 
      iprot.readFieldEnd()
7036 
    iprot.readStructEnd()
7037 
 
7038 
  def write(self, oprot):
7039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7041 
      return
7042 
    oprot.writeStructBegin('getItemStatusDescription_result')
7043 
    if self.success is not None:
7044 
      oprot.writeFieldBegin('success', TType.STRING, 0)
7045 
      oprot.writeString(self.success)
7046 
      oprot.writeFieldEnd()
7047 
    if self.isex is not None:
7048 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7049 
      self.isex.write(oprot)
7050 
      oprot.writeFieldEnd()
7051 
    oprot.writeFieldStop()
7052 
    oprot.writeStructEnd()
7053 
 
7054 
  def validate(self):
7055 
    return
7056 
 
7057 
 
7058 
  def __repr__(self):
7059 
    L = ['%s=%r' % (key, value)
7060 
      for key, value in self.__dict__.iteritems()]
7061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7062 
 
7063 
  def __eq__(self, other):
7064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7065 
 
7066 
  def __ne__(self, other):
7067 
    return not (self == other)
7068 
 
7069 
class startItemOn_args:
7070 
  """
7071 
  Attributes:
7072 
   - item_id
7073 
   - timestamp
7074 
  """
7075 
 
7076 
  thrift_spec = (
7077 
    None, # 0
7078 
    (1, TType.I64, 'item_id', None, None, ), # 1
7079 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7080 
  )
7081 
 
7082 
  def __init__(self, item_id=None, timestamp=None,):
7083 
    self.item_id = item_id
7084 
    self.timestamp = timestamp
7085 
 
7086 
  def read(self, iprot):
7087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7089 
      return
7090 
    iprot.readStructBegin()
7091 
    while True:
7092 
      (fname, ftype, fid) = iprot.readFieldBegin()
7093 
      if ftype == TType.STOP:
7094 
        break
7095 
      if fid == 1:
7096 
        if ftype == TType.I64:
7097 
          self.item_id = iprot.readI64();
7098 
        else:
7099 
          iprot.skip(ftype)
7100 
      elif fid == 2:
7101 
        if ftype == TType.I64:
7102 
          self.timestamp = iprot.readI64();
7103 
        else:
7104 
          iprot.skip(ftype)
7105 
      else:
7106 
        iprot.skip(ftype)
7107 
      iprot.readFieldEnd()
7108 
    iprot.readStructEnd()
7109 
 
7110 
  def write(self, oprot):
7111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7113 
      return
7114 
    oprot.writeStructBegin('startItemOn_args')
7115 
    if self.item_id is not None:
7116 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7117 
      oprot.writeI64(self.item_id)
7118 
      oprot.writeFieldEnd()
7119 
    if self.timestamp is not None:
7120 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7121 
      oprot.writeI64(self.timestamp)
7122 
      oprot.writeFieldEnd()
7123 
    oprot.writeFieldStop()
7124 
    oprot.writeStructEnd()
7125 
 
7126 
  def validate(self):
7127 
    return
7128 
 
7129 
 
7130 
  def __repr__(self):
7131 
    L = ['%s=%r' % (key, value)
7132 
      for key, value in self.__dict__.iteritems()]
7133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7134 
 
7135 
  def __eq__(self, other):
7136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7137 
 
7138 
  def __ne__(self, other):
7139 
    return not (self == other)
7140 
 
7141 
class startItemOn_result:
7142 
  """
7143 
  Attributes:
7144 
   - cex
7145 
  """
7146 
 
7147 
  thrift_spec = (
7148 
    None, # 0
7149 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7150 
  )
7151 
 
7152 
  def __init__(self, cex=None,):
7153 
    self.cex = cex
7154 
 
7155 
  def read(self, iprot):
7156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7158 
      return
7159 
    iprot.readStructBegin()
7160 
    while True:
7161 
      (fname, ftype, fid) = iprot.readFieldBegin()
7162 
      if ftype == TType.STOP:
7163 
        break
7164 
      if fid == 1:
7165 
        if ftype == TType.STRUCT:
7166 
          self.cex = CatalogServiceException()
7167 
          self.cex.read(iprot)
7168 
        else:
7169 
          iprot.skip(ftype)
7170 
      else:
7171 
        iprot.skip(ftype)
7172 
      iprot.readFieldEnd()
7173 
    iprot.readStructEnd()
7174 
 
7175 
  def write(self, oprot):
7176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7178 
      return
7179 
    oprot.writeStructBegin('startItemOn_result')
7180 
    if self.cex is not None:
7181 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7182 
      self.cex.write(oprot)
7183 
      oprot.writeFieldEnd()
7184 
    oprot.writeFieldStop()
7185 
    oprot.writeStructEnd()
7186 
 
7187 
  def validate(self):
7188 
    return
7189 
 
7190 
 
7191 
  def __repr__(self):
7192 
    L = ['%s=%r' % (key, value)
7193 
      for key, value in self.__dict__.iteritems()]
7194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7195 
 
7196 
  def __eq__(self, other):
7197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7198 
 
7199 
  def __ne__(self, other):
7200 
    return not (self == other)
7201 
 
7202 
class retireItemOn_args:
7203 
  """
7204 
  Attributes:
7205 
   - item_id
7206 
   - timestamp
7207 
  """
7208 
 
7209 
  thrift_spec = (
7210 
    None, # 0
7211 
    (1, TType.I64, 'item_id', None, None, ), # 1
7212 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7213 
  )
7214 
 
7215 
  def __init__(self, item_id=None, timestamp=None,):
7216 
    self.item_id = item_id
7217 
    self.timestamp = timestamp
7218 
 
7219 
  def read(self, iprot):
7220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7222 
      return
7223 
    iprot.readStructBegin()
7224 
    while True:
7225 
      (fname, ftype, fid) = iprot.readFieldBegin()
7226 
      if ftype == TType.STOP:
7227 
        break
7228 
      if fid == 1:
7229 
        if ftype == TType.I64:
7230 
          self.item_id = iprot.readI64();
7231 
        else:
7232 
          iprot.skip(ftype)
7233 
      elif fid == 2:
7234 
        if ftype == TType.I64:
7235 
          self.timestamp = iprot.readI64();
7236 
        else:
7237 
          iprot.skip(ftype)
7238 
      else:
7239 
        iprot.skip(ftype)
7240 
      iprot.readFieldEnd()
7241 
    iprot.readStructEnd()
7242 
 
7243 
  def write(self, oprot):
7244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7246 
      return
7247 
    oprot.writeStructBegin('retireItemOn_args')
7248 
    if self.item_id is not None:
7249 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7250 
      oprot.writeI64(self.item_id)
7251 
      oprot.writeFieldEnd()
7252 
    if self.timestamp is not None:
7253 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7254 
      oprot.writeI64(self.timestamp)
7255 
      oprot.writeFieldEnd()
7256 
    oprot.writeFieldStop()
7257 
    oprot.writeStructEnd()
7258 
 
7259 
  def validate(self):
7260 
    return
7261 
 
7262 
 
7263 
  def __repr__(self):
7264 
    L = ['%s=%r' % (key, value)
7265 
      for key, value in self.__dict__.iteritems()]
7266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7267 
 
7268 
  def __eq__(self, other):
7269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7270 
 
7271 
  def __ne__(self, other):
7272 
    return not (self == other)
7273 
 
7274 
class retireItemOn_result:
7275 
  """
7276 
  Attributes:
7277 
   - cex
7278 
  """
7279 
 
7280 
  thrift_spec = (
7281 
    None, # 0
7282 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7283 
  )
7284 
 
7285 
  def __init__(self, cex=None,):
7286 
    self.cex = cex
7287 
 
7288 
  def read(self, iprot):
7289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7291 
      return
7292 
    iprot.readStructBegin()
7293 
    while True:
7294 
      (fname, ftype, fid) = iprot.readFieldBegin()
7295 
      if ftype == TType.STOP:
7296 
        break
7297 
      if fid == 1:
7298 
        if ftype == TType.STRUCT:
7299 
          self.cex = CatalogServiceException()
7300 
          self.cex.read(iprot)
7301 
        else:
7302 
          iprot.skip(ftype)
7303 
      else:
7304 
        iprot.skip(ftype)
7305 
      iprot.readFieldEnd()
7306 
    iprot.readStructEnd()
7307 
 
7308 
  def write(self, oprot):
7309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7311 
      return
7312 
    oprot.writeStructBegin('retireItemOn_result')
7313 
    if self.cex is not None:
7314 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7315 
      self.cex.write(oprot)
7316 
      oprot.writeFieldEnd()
7317 
    oprot.writeFieldStop()
7318 
    oprot.writeStructEnd()
7319 
 
7320 
  def validate(self):
7321 
    return
7322 
 
7323 
 
7324 
  def __repr__(self):
7325 
    L = ['%s=%r' % (key, value)
7326 
      for key, value in self.__dict__.iteritems()]
7327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7328 
 
7329 
  def __eq__(self, other):
7330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7331 
 
7332 
  def __ne__(self, other):
7333 
    return not (self == other)
7334 
 
7335 
class changeItemStatus_args:
7336 
  """
7337 
  Attributes:
7338 
   - item_id
7339 
   - timestamp
7340 
   - newstatus
7341 
  """
7342 
 
7343 
  thrift_spec = (
7344 
    None, # 0
7345 
    (1, TType.I64, 'item_id', None, None, ), # 1
7346 
    (2, TType.I64, 'timestamp', None, None, ), # 2
7347 
    (3, TType.I32, 'newstatus', None, None, ), # 3
7348 
  )
7349 
 
7350 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
7351 
    self.item_id = item_id
7352 
    self.timestamp = timestamp
7353 
    self.newstatus = newstatus
7354 
 
7355 
  def read(self, iprot):
7356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7358 
      return
7359 
    iprot.readStructBegin()
7360 
    while True:
7361 
      (fname, ftype, fid) = iprot.readFieldBegin()
7362 
      if ftype == TType.STOP:
7363 
        break
7364 
      if fid == 1:
7365 
        if ftype == TType.I64:
7366 
          self.item_id = iprot.readI64();
7367 
        else:
7368 
          iprot.skip(ftype)
7369 
      elif fid == 2:
7370 
        if ftype == TType.I64:
7371 
          self.timestamp = iprot.readI64();
7372 
        else:
7373 
          iprot.skip(ftype)
7374 
      elif fid == 3:
7375 
        if ftype == TType.I32:
7376 
          self.newstatus = iprot.readI32();
7377 
        else:
7378 
          iprot.skip(ftype)
7379 
      else:
7380 
        iprot.skip(ftype)
7381 
      iprot.readFieldEnd()
7382 
    iprot.readStructEnd()
7383 
 
7384 
  def write(self, oprot):
7385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7387 
      return
7388 
    oprot.writeStructBegin('changeItemStatus_args')
7389 
    if self.item_id is not None:
7390 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7391 
      oprot.writeI64(self.item_id)
7392 
      oprot.writeFieldEnd()
7393 
    if self.timestamp is not None:
7394 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
7395 
      oprot.writeI64(self.timestamp)
7396 
      oprot.writeFieldEnd()
7397 
    if self.newstatus is not None:
7398 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
7399 
      oprot.writeI32(self.newstatus)
7400 
      oprot.writeFieldEnd()
7401 
    oprot.writeFieldStop()
7402 
    oprot.writeStructEnd()
7403 
 
7404 
  def validate(self):
7405 
    return
7406 
 
7407 
 
7408 
  def __repr__(self):
7409 
    L = ['%s=%r' % (key, value)
7410 
      for key, value in self.__dict__.iteritems()]
7411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7412 
 
7413 
  def __eq__(self, other):
7414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7415 
 
7416 
  def __ne__(self, other):
7417 
    return not (self == other)
7418 
 
7419 
class changeItemStatus_result:
7420 
  """
7421 
  Attributes:
7422 
   - cex
7423 
  """
7424 
 
7425 
  thrift_spec = (
7426 
    None, # 0
7427 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7428 
  )
7429 
 
7430 
  def __init__(self, cex=None,):
7431 
    self.cex = cex
7432 
 
7433 
  def read(self, iprot):
7434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7436 
      return
7437 
    iprot.readStructBegin()
7438 
    while True:
7439 
      (fname, ftype, fid) = iprot.readFieldBegin()
7440 
      if ftype == TType.STOP:
7441 
        break
7442 
      if fid == 1:
7443 
        if ftype == TType.STRUCT:
7444 
          self.cex = CatalogServiceException()
7445 
          self.cex.read(iprot)
7446 
        else:
7447 
          iprot.skip(ftype)
7448 
      else:
7449 
        iprot.skip(ftype)
7450 
      iprot.readFieldEnd()
7451 
    iprot.readStructEnd()
7452 
 
7453 
  def write(self, oprot):
7454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7456 
      return
7457 
    oprot.writeStructBegin('changeItemStatus_result')
7458 
    if self.cex is not None:
7459 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7460 
      self.cex.write(oprot)
7461 
      oprot.writeFieldEnd()
7462 
    oprot.writeFieldStop()
7463 
    oprot.writeStructEnd()
7464 
 
7465 
  def validate(self):
7466 
    return
7467 
 
7468 
 
7469 
  def __repr__(self):
7470 
    L = ['%s=%r' % (key, value)
7471 
      for key, value in self.__dict__.iteritems()]
7472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7473 
 
7474 
  def __eq__(self, other):
7475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7476 
 
7477 
  def __ne__(self, other):
7478 
    return not (self == other)
7479 
 
7480 
class getItem_args:
7481 
  """
7482 
  Attributes:
7483 
   - item_id
7484 
  """
7485 
 
7486 
  thrift_spec = (
7487 
    None, # 0
7488 
    (1, TType.I64, 'item_id', None, None, ), # 1
7489 
  )
7490 
 
7491 
  def __init__(self, item_id=None,):
7492 
    self.item_id = item_id
7493 
 
7494 
  def read(self, iprot):
7495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7497 
      return
7498 
    iprot.readStructBegin()
7499 
    while True:
7500 
      (fname, ftype, fid) = iprot.readFieldBegin()
7501 
      if ftype == TType.STOP:
7502 
        break
7503 
      if fid == 1:
7504 
        if ftype == TType.I64:
7505 
          self.item_id = iprot.readI64();
7506 
        else:
7507 
          iprot.skip(ftype)
7508 
      else:
7509 
        iprot.skip(ftype)
7510 
      iprot.readFieldEnd()
7511 
    iprot.readStructEnd()
7512 
 
7513 
  def write(self, oprot):
7514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7516 
      return
7517 
    oprot.writeStructBegin('getItem_args')
7518 
    if self.item_id is not None:
7519 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7520 
      oprot.writeI64(self.item_id)
7521 
      oprot.writeFieldEnd()
7522 
    oprot.writeFieldStop()
7523 
    oprot.writeStructEnd()
7524 
 
7525 
  def validate(self):
7526 
    return
7527 
 
7528 
 
7529 
  def __repr__(self):
7530 
    L = ['%s=%r' % (key, value)
7531 
      for key, value in self.__dict__.iteritems()]
7532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7533 
 
7534 
  def __eq__(self, other):
7535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7536 
 
7537 
  def __ne__(self, other):
7538 
    return not (self == other)
7539 
 
7540 
class getItem_result:
7541 
  """
7542 
  Attributes:
7543 
   - success
7544 
   - cex
7545 
  """
7546 
 
7547 
  thrift_spec = (
7548 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
7549 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7550 
  )
7551 
 
7552 
  def __init__(self, success=None, cex=None,):
7553 
    self.success = success
7554 
    self.cex = cex
7555 
 
7556 
  def read(self, iprot):
7557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7559 
      return
7560 
    iprot.readStructBegin()
7561 
    while True:
7562 
      (fname, ftype, fid) = iprot.readFieldBegin()
7563 
      if ftype == TType.STOP:
7564 
        break
7565 
      if fid == 0:
7566 
        if ftype == TType.STRUCT:
7567 
          self.success = Item()
7568 
          self.success.read(iprot)
7569 
        else:
7570 
          iprot.skip(ftype)
7571 
      elif fid == 1:
7572 
        if ftype == TType.STRUCT:
7573 
          self.cex = CatalogServiceException()
7574 
          self.cex.read(iprot)
7575 
        else:
7576 
          iprot.skip(ftype)
7577 
      else:
7578 
        iprot.skip(ftype)
7579 
      iprot.readFieldEnd()
7580 
    iprot.readStructEnd()
7581 
 
7582 
  def write(self, oprot):
7583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7585 
      return
7586 
    oprot.writeStructBegin('getItem_result')
7587 
    if self.success is not None:
7588 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7589 
      self.success.write(oprot)
7590 
      oprot.writeFieldEnd()
7591 
    if self.cex is not None:
7592 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7593 
      self.cex.write(oprot)
7594 
      oprot.writeFieldEnd()
7595 
    oprot.writeFieldStop()
7596 
    oprot.writeStructEnd()
7597 
 
7598 
  def validate(self):
7599 
    return
7600 
 
7601 
 
7602 
  def __repr__(self):
7603 
    L = ['%s=%r' % (key, value)
7604 
      for key, value in self.__dict__.iteritems()]
7605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7606 
 
7607 
  def __eq__(self, other):
7608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7609 
 
7610 
  def __ne__(self, other):
7611 
    return not (self == other)
7612 
 
7613 
class getItemsByCatalogId_args:
7614 
  """
7615 
  Attributes:
7616 
   - catalog_item_id
7617 
  """
7618 
 
7619 
  thrift_spec = (
7620 
    None, # 0
7621 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7622 
  )
7623 
 
7624 
  def __init__(self, catalog_item_id=None,):
7625 
    self.catalog_item_id = catalog_item_id
7626 
 
7627 
  def read(self, iprot):
7628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7630 
      return
7631 
    iprot.readStructBegin()
7632 
    while True:
7633 
      (fname, ftype, fid) = iprot.readFieldBegin()
7634 
      if ftype == TType.STOP:
7635 
        break
7636 
      if fid == 1:
7637 
        if ftype == TType.I64:
7638 
          self.catalog_item_id = iprot.readI64();
7639 
        else:
7640 
          iprot.skip(ftype)
7641 
      else:
7642 
        iprot.skip(ftype)
7643 
      iprot.readFieldEnd()
7644 
    iprot.readStructEnd()
7645 
 
7646 
  def write(self, oprot):
7647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7649 
      return
7650 
    oprot.writeStructBegin('getItemsByCatalogId_args')
7651 
    if self.catalog_item_id is not None:
7652 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7653 
      oprot.writeI64(self.catalog_item_id)
7654 
      oprot.writeFieldEnd()
7655 
    oprot.writeFieldStop()
7656 
    oprot.writeStructEnd()
7657 
 
7658 
  def validate(self):
7659 
    return
7660 
 
7661 
 
7662 
  def __repr__(self):
7663 
    L = ['%s=%r' % (key, value)
7664 
      for key, value in self.__dict__.iteritems()]
7665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7666 
 
7667 
  def __eq__(self, other):
7668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7669 
 
7670 
  def __ne__(self, other):
7671 
    return not (self == other)
7672 
 
7673 
class getItemsByCatalogId_result:
7674 
  """
7675 
  Attributes:
7676 
   - success
7677 
   - cex
7678 
  """
7679 
 
7680 
  thrift_spec = (
7681 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7682 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7683 
  )
7684 
 
7685 
  def __init__(self, success=None, cex=None,):
7686 
    self.success = success
7687 
    self.cex = cex
7688 
 
7689 
  def read(self, iprot):
7690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7692 
      return
7693 
    iprot.readStructBegin()
7694 
    while True:
7695 
      (fname, ftype, fid) = iprot.readFieldBegin()
7696 
      if ftype == TType.STOP:
7697 
        break
7698 
      if fid == 0:
7699 
        if ftype == TType.LIST:
7700 
          self.success = []
8590 kshitij.so 7701 
          (_etype49, _size46) = iprot.readListBegin()
7702 
          for _i50 in xrange(_size46):
7703 
            _elem51 = Item()
7704 
            _elem51.read(iprot)
7705 
            self.success.append(_elem51)
5944 mandeep.dh 7706 
          iprot.readListEnd()
7707 
        else:
7708 
          iprot.skip(ftype)
7709 
      elif fid == 1:
7710 
        if ftype == TType.STRUCT:
7711 
          self.cex = CatalogServiceException()
7712 
          self.cex.read(iprot)
7713 
        else:
7714 
          iprot.skip(ftype)
7715 
      else:
7716 
        iprot.skip(ftype)
7717 
      iprot.readFieldEnd()
7718 
    iprot.readStructEnd()
7719 
 
7720 
  def write(self, oprot):
7721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7723 
      return
7724 
    oprot.writeStructBegin('getItemsByCatalogId_result')
7725 
    if self.success is not None:
7726 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7727 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7728 
      for iter52 in self.success:
7729 
        iter52.write(oprot)
5944 mandeep.dh 7730 
      oprot.writeListEnd()
7731 
      oprot.writeFieldEnd()
7732 
    if self.cex is not None:
7733 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7734 
      self.cex.write(oprot)
7735 
      oprot.writeFieldEnd()
7736 
    oprot.writeFieldStop()
7737 
    oprot.writeStructEnd()
7738 
 
7739 
  def validate(self):
7740 
    return
7741 
 
7742 
 
7743 
  def __repr__(self):
7744 
    L = ['%s=%r' % (key, value)
7745 
      for key, value in self.__dict__.iteritems()]
7746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7747 
 
7748 
  def __eq__(self, other):
7749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7750 
 
7751 
  def __ne__(self, other):
7752 
    return not (self == other)
7753 
 
7754 
class getValidItemsByCatalogId_args:
7755 
  """
7756 
  Attributes:
7757 
   - catalog_item_id
7758 
  """
7759 
 
7760 
  thrift_spec = (
7761 
    None, # 0
7762 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
7763 
  )
7764 
 
7765 
  def __init__(self, catalog_item_id=None,):
7766 
    self.catalog_item_id = catalog_item_id
7767 
 
7768 
  def read(self, iprot):
7769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7771 
      return
7772 
    iprot.readStructBegin()
7773 
    while True:
7774 
      (fname, ftype, fid) = iprot.readFieldBegin()
7775 
      if ftype == TType.STOP:
7776 
        break
7777 
      if fid == 1:
7778 
        if ftype == TType.I64:
7779 
          self.catalog_item_id = iprot.readI64();
7780 
        else:
7781 
          iprot.skip(ftype)
7782 
      else:
7783 
        iprot.skip(ftype)
7784 
      iprot.readFieldEnd()
7785 
    iprot.readStructEnd()
7786 
 
7787 
  def write(self, oprot):
7788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7790 
      return
7791 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
7792 
    if self.catalog_item_id is not None:
7793 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
7794 
      oprot.writeI64(self.catalog_item_id)
7795 
      oprot.writeFieldEnd()
7796 
    oprot.writeFieldStop()
7797 
    oprot.writeStructEnd()
7798 
 
7799 
  def validate(self):
7800 
    return
7801 
 
7802 
 
7803 
  def __repr__(self):
7804 
    L = ['%s=%r' % (key, value)
7805 
      for key, value in self.__dict__.iteritems()]
7806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7807 
 
7808 
  def __eq__(self, other):
7809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7810 
 
7811 
  def __ne__(self, other):
7812 
    return not (self == other)
7813 
 
7814 
class getValidItemsByCatalogId_result:
7815 
  """
7816 
  Attributes:
7817 
   - success
7818 
   - cex
7819 
  """
7820 
 
7821 
  thrift_spec = (
7822 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7823 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7824 
  )
7825 
 
7826 
  def __init__(self, success=None, cex=None,):
7827 
    self.success = success
7828 
    self.cex = cex
7829 
 
7830 
  def read(self, iprot):
7831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7833 
      return
7834 
    iprot.readStructBegin()
7835 
    while True:
7836 
      (fname, ftype, fid) = iprot.readFieldBegin()
7837 
      if ftype == TType.STOP:
7838 
        break
7839 
      if fid == 0:
7840 
        if ftype == TType.LIST:
7841 
          self.success = []
8590 kshitij.so 7842 
          (_etype56, _size53) = iprot.readListBegin()
7843 
          for _i57 in xrange(_size53):
7844 
            _elem58 = Item()
7845 
            _elem58.read(iprot)
7846 
            self.success.append(_elem58)
5944 mandeep.dh 7847 
          iprot.readListEnd()
7848 
        else:
7849 
          iprot.skip(ftype)
7850 
      elif fid == 1:
7851 
        if ftype == TType.STRUCT:
7852 
          self.cex = CatalogServiceException()
7853 
          self.cex.read(iprot)
7854 
        else:
7855 
          iprot.skip(ftype)
7856 
      else:
7857 
        iprot.skip(ftype)
7858 
      iprot.readFieldEnd()
7859 
    iprot.readStructEnd()
7860 
 
7861 
  def write(self, oprot):
7862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7864 
      return
7865 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
7866 
    if self.success is not None:
7867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7868 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 7869 
      for iter59 in self.success:
7870 
        iter59.write(oprot)
5944 mandeep.dh 7871 
      oprot.writeListEnd()
7872 
      oprot.writeFieldEnd()
7873 
    if self.cex is not None:
7874 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7875 
      self.cex.write(oprot)
7876 
      oprot.writeFieldEnd()
7877 
    oprot.writeFieldStop()
7878 
    oprot.writeStructEnd()
7879 
 
7880 
  def validate(self):
7881 
    return
7882 
 
7883 
 
7884 
  def __repr__(self):
7885 
    L = ['%s=%r' % (key, value)
7886 
      for key, value in self.__dict__.iteritems()]
7887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7888 
 
7889 
  def __eq__(self, other):
7890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7891 
 
7892 
  def __ne__(self, other):
7893 
    return not (self == other)
7894 
 
7895 
class getAllItems_args:
7896 
  """
7897 
  Attributes:
7898 
   - isActive
7899 
  """
7900 
 
7901 
  thrift_spec = (
7902 
    None, # 0
7903 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
7904 
  )
7905 
 
7906 
  def __init__(self, isActive=None,):
7907 
    self.isActive = isActive
7908 
 
7909 
  def read(self, iprot):
7910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7912 
      return
7913 
    iprot.readStructBegin()
7914 
    while True:
7915 
      (fname, ftype, fid) = iprot.readFieldBegin()
7916 
      if ftype == TType.STOP:
7917 
        break
7918 
      if fid == 1:
7919 
        if ftype == TType.BOOL:
7920 
          self.isActive = iprot.readBool();
7921 
        else:
7922 
          iprot.skip(ftype)
7923 
      else:
7924 
        iprot.skip(ftype)
7925 
      iprot.readFieldEnd()
7926 
    iprot.readStructEnd()
7927 
 
7928 
  def write(self, oprot):
7929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7931 
      return
7932 
    oprot.writeStructBegin('getAllItems_args')
7933 
    if self.isActive is not None:
7934 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
7935 
      oprot.writeBool(self.isActive)
7936 
      oprot.writeFieldEnd()
7937 
    oprot.writeFieldStop()
7938 
    oprot.writeStructEnd()
7939 
 
7940 
  def validate(self):
7941 
    return
7942 
 
7943 
 
7944 
  def __repr__(self):
7945 
    L = ['%s=%r' % (key, value)
7946 
      for key, value in self.__dict__.iteritems()]
7947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7948 
 
7949 
  def __eq__(self, other):
7950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7951 
 
7952 
  def __ne__(self, other):
7953 
    return not (self == other)
7954 
 
7955 
class getAllItems_result:
7956 
  """
7957 
  Attributes:
7958 
   - success
7959 
   - cex
7960 
  """
7961 
 
7962 
  thrift_spec = (
7963 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7964 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7965 
  )
7966 
 
7967 
  def __init__(self, success=None, cex=None,):
7968 
    self.success = success
7969 
    self.cex = cex
7970 
 
7971 
  def read(self, iprot):
7972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7974 
      return
7975 
    iprot.readStructBegin()
7976 
    while True:
7977 
      (fname, ftype, fid) = iprot.readFieldBegin()
7978 
      if ftype == TType.STOP:
7979 
        break
7980 
      if fid == 0:
7981 
        if ftype == TType.LIST:
7982 
          self.success = []
8590 kshitij.so 7983 
          (_etype63, _size60) = iprot.readListBegin()
7984 
          for _i64 in xrange(_size60):
7985 
            _elem65 = Item()
7986 
            _elem65.read(iprot)
7987 
            self.success.append(_elem65)
5944 mandeep.dh 7988 
          iprot.readListEnd()
7989 
        else:
7990 
          iprot.skip(ftype)
7991 
      elif fid == 1:
7992 
        if ftype == TType.STRUCT:
7993 
          self.cex = CatalogServiceException()
7994 
          self.cex.read(iprot)
7995 
        else:
7996 
          iprot.skip(ftype)
7997 
      else:
7998 
        iprot.skip(ftype)
7999 
      iprot.readFieldEnd()
8000 
    iprot.readStructEnd()
8001 
 
8002 
  def write(self, oprot):
8003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8005 
      return
8006 
    oprot.writeStructBegin('getAllItems_result')
8007 
    if self.success is not None:
8008 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8009 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8010 
      for iter66 in self.success:
8011 
        iter66.write(oprot)
5944 mandeep.dh 8012 
      oprot.writeListEnd()
8013 
      oprot.writeFieldEnd()
8014 
    if self.cex is not None:
8015 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8016 
      self.cex.write(oprot)
8017 
      oprot.writeFieldEnd()
8018 
    oprot.writeFieldStop()
8019 
    oprot.writeStructEnd()
8020 
 
8021 
  def validate(self):
8022 
    return
8023 
 
8024 
 
8025 
  def __repr__(self):
8026 
    L = ['%s=%r' % (key, value)
8027 
      for key, value in self.__dict__.iteritems()]
8028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8029 
 
8030 
  def __eq__(self, other):
8031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8032 
 
8033 
  def __ne__(self, other):
8034 
    return not (self == other)
8035 
 
8036 
class getAllItemsByStatus_args:
8037 
  """
8038 
  Attributes:
8039 
   - itemStatus
8040 
  """
8041 
 
8042 
  thrift_spec = (
8043 
    None, # 0
8044 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8045 
  )
8046 
 
8047 
  def __init__(self, itemStatus=None,):
8048 
    self.itemStatus = itemStatus
8049 
 
8050 
  def read(self, iprot):
8051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8053 
      return
8054 
    iprot.readStructBegin()
8055 
    while True:
8056 
      (fname, ftype, fid) = iprot.readFieldBegin()
8057 
      if ftype == TType.STOP:
8058 
        break
8059 
      if fid == 1:
8060 
        if ftype == TType.I32:
8061 
          self.itemStatus = iprot.readI32();
8062 
        else:
8063 
          iprot.skip(ftype)
8064 
      else:
8065 
        iprot.skip(ftype)
8066 
      iprot.readFieldEnd()
8067 
    iprot.readStructEnd()
8068 
 
8069 
  def write(self, oprot):
8070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8072 
      return
8073 
    oprot.writeStructBegin('getAllItemsByStatus_args')
8074 
    if self.itemStatus is not None:
8075 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8076 
      oprot.writeI32(self.itemStatus)
8077 
      oprot.writeFieldEnd()
8078 
    oprot.writeFieldStop()
8079 
    oprot.writeStructEnd()
8080 
 
8081 
  def validate(self):
8082 
    return
8083 
 
8084 
 
8085 
  def __repr__(self):
8086 
    L = ['%s=%r' % (key, value)
8087 
      for key, value in self.__dict__.iteritems()]
8088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8089 
 
8090 
  def __eq__(self, other):
8091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8092 
 
8093 
  def __ne__(self, other):
8094 
    return not (self == other)
8095 
 
8096 
class getAllItemsByStatus_result:
8097 
  """
8098 
  Attributes:
8099 
   - success
8100 
   - cex
8101 
  """
8102 
 
8103 
  thrift_spec = (
8104 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8105 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8106 
  )
8107 
 
8108 
  def __init__(self, success=None, cex=None,):
8109 
    self.success = success
8110 
    self.cex = cex
8111 
 
8112 
  def read(self, iprot):
8113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8115 
      return
8116 
    iprot.readStructBegin()
8117 
    while True:
8118 
      (fname, ftype, fid) = iprot.readFieldBegin()
8119 
      if ftype == TType.STOP:
8120 
        break
8121 
      if fid == 0:
8122 
        if ftype == TType.LIST:
8123 
          self.success = []
8590 kshitij.so 8124 
          (_etype70, _size67) = iprot.readListBegin()
8125 
          for _i71 in xrange(_size67):
8126 
            _elem72 = Item()
8127 
            _elem72.read(iprot)
8128 
            self.success.append(_elem72)
5944 mandeep.dh 8129 
          iprot.readListEnd()
8130 
        else:
8131 
          iprot.skip(ftype)
8132 
      elif fid == 1:
8133 
        if ftype == TType.STRUCT:
8134 
          self.cex = CatalogServiceException()
8135 
          self.cex.read(iprot)
8136 
        else:
8137 
          iprot.skip(ftype)
8138 
      else:
8139 
        iprot.skip(ftype)
8140 
      iprot.readFieldEnd()
8141 
    iprot.readStructEnd()
8142 
 
8143 
  def write(self, oprot):
8144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8146 
      return
8147 
    oprot.writeStructBegin('getAllItemsByStatus_result')
8148 
    if self.success is not None:
8149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8150 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8151 
      for iter73 in self.success:
8152 
        iter73.write(oprot)
5944 mandeep.dh 8153 
      oprot.writeListEnd()
8154 
      oprot.writeFieldEnd()
8155 
    if self.cex is not None:
8156 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8157 
      self.cex.write(oprot)
8158 
      oprot.writeFieldEnd()
8159 
    oprot.writeFieldStop()
8160 
    oprot.writeStructEnd()
8161 
 
8162 
  def validate(self):
8163 
    return
8164 
 
8165 
 
8166 
  def __repr__(self):
8167 
    L = ['%s=%r' % (key, value)
8168 
      for key, value in self.__dict__.iteritems()]
8169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8170 
 
8171 
  def __eq__(self, other):
8172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8173 
 
8174 
  def __ne__(self, other):
8175 
    return not (self == other)
8176 
 
8177 
class markItemAsContentComplete_args:
8178 
  """
8179 
  Attributes:
8180 
   - entityId
8181 
   - category
8182 
   - brand
8183 
   - modelName
8184 
   - modelNumber
8185 
  """
8186 
 
8187 
  thrift_spec = (
8188 
    None, # 0
8189 
    (1, TType.I64, 'entityId', None, None, ), # 1
8190 
    (2, TType.I64, 'category', None, None, ), # 2
8191 
    (3, TType.STRING, 'brand', None, None, ), # 3
8192 
    (4, TType.STRING, 'modelName', None, None, ), # 4
8193 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
8194 
  )
8195 
 
8196 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
8197 
    self.entityId = entityId
8198 
    self.category = category
8199 
    self.brand = brand
8200 
    self.modelName = modelName
8201 
    self.modelNumber = modelNumber
8202 
 
8203 
  def read(self, iprot):
8204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8206 
      return
8207 
    iprot.readStructBegin()
8208 
    while True:
8209 
      (fname, ftype, fid) = iprot.readFieldBegin()
8210 
      if ftype == TType.STOP:
8211 
        break
8212 
      if fid == 1:
8213 
        if ftype == TType.I64:
8214 
          self.entityId = iprot.readI64();
8215 
        else:
8216 
          iprot.skip(ftype)
8217 
      elif fid == 2:
8218 
        if ftype == TType.I64:
8219 
          self.category = iprot.readI64();
8220 
        else:
8221 
          iprot.skip(ftype)
8222 
      elif fid == 3:
8223 
        if ftype == TType.STRING:
8224 
          self.brand = iprot.readString();
8225 
        else:
8226 
          iprot.skip(ftype)
8227 
      elif fid == 4:
8228 
        if ftype == TType.STRING:
8229 
          self.modelName = iprot.readString();
8230 
        else:
8231 
          iprot.skip(ftype)
8232 
      elif fid == 5:
8233 
        if ftype == TType.STRING:
8234 
          self.modelNumber = iprot.readString();
8235 
        else:
8236 
          iprot.skip(ftype)
8237 
      else:
8238 
        iprot.skip(ftype)
8239 
      iprot.readFieldEnd()
8240 
    iprot.readStructEnd()
8241 
 
8242 
  def write(self, oprot):
8243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8245 
      return
8246 
    oprot.writeStructBegin('markItemAsContentComplete_args')
8247 
    if self.entityId is not None:
8248 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
8249 
      oprot.writeI64(self.entityId)
8250 
      oprot.writeFieldEnd()
8251 
    if self.category is not None:
8252 
      oprot.writeFieldBegin('category', TType.I64, 2)
8253 
      oprot.writeI64(self.category)
8254 
      oprot.writeFieldEnd()
8255 
    if self.brand is not None:
8256 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8257 
      oprot.writeString(self.brand)
8258 
      oprot.writeFieldEnd()
8259 
    if self.modelName is not None:
8260 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
8261 
      oprot.writeString(self.modelName)
8262 
      oprot.writeFieldEnd()
8263 
    if self.modelNumber is not None:
8264 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
8265 
      oprot.writeString(self.modelNumber)
8266 
      oprot.writeFieldEnd()
8267 
    oprot.writeFieldStop()
8268 
    oprot.writeStructEnd()
8269 
 
8270 
  def validate(self):
8271 
    return
8272 
 
8273 
 
8274 
  def __repr__(self):
8275 
    L = ['%s=%r' % (key, value)
8276 
      for key, value in self.__dict__.iteritems()]
8277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8278 
 
8279 
  def __eq__(self, other):
8280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8281 
 
8282 
  def __ne__(self, other):
8283 
    return not (self == other)
8284 
 
8285 
class markItemAsContentComplete_result:
8286 
  """
8287 
  Attributes:
8288 
   - success
8289 
   - cex
8290 
  """
8291 
 
8292 
  thrift_spec = (
8293 
    (0, TType.BOOL, 'success', None, None, ), # 0
8294 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8295 
  )
8296 
 
8297 
  def __init__(self, success=None, cex=None,):
8298 
    self.success = success
8299 
    self.cex = cex
8300 
 
8301 
  def read(self, iprot):
8302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8304 
      return
8305 
    iprot.readStructBegin()
8306 
    while True:
8307 
      (fname, ftype, fid) = iprot.readFieldBegin()
8308 
      if ftype == TType.STOP:
8309 
        break
8310 
      if fid == 0:
8311 
        if ftype == TType.BOOL:
8312 
          self.success = iprot.readBool();
8313 
        else:
8314 
          iprot.skip(ftype)
8315 
      elif fid == 1:
8316 
        if ftype == TType.STRUCT:
8317 
          self.cex = CatalogServiceException()
8318 
          self.cex.read(iprot)
8319 
        else:
8320 
          iprot.skip(ftype)
8321 
      else:
8322 
        iprot.skip(ftype)
8323 
      iprot.readFieldEnd()
8324 
    iprot.readStructEnd()
8325 
 
8326 
  def write(self, oprot):
8327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8329 
      return
8330 
    oprot.writeStructBegin('markItemAsContentComplete_result')
8331 
    if self.success is not None:
8332 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8333 
      oprot.writeBool(self.success)
8334 
      oprot.writeFieldEnd()
8335 
    if self.cex is not None:
8336 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8337 
      self.cex.write(oprot)
8338 
      oprot.writeFieldEnd()
8339 
    oprot.writeFieldStop()
8340 
    oprot.writeStructEnd()
8341 
 
8342 
  def validate(self):
8343 
    return
8344 
 
8345 
 
8346 
  def __repr__(self):
8347 
    L = ['%s=%r' % (key, value)
8348 
      for key, value in self.__dict__.iteritems()]
8349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8350 
 
8351 
  def __eq__(self, other):
8352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8353 
 
8354 
  def __ne__(self, other):
8355 
    return not (self == other)
8356 
 
8357 
class getAllItemsInRange_args:
8358 
  """
8359 
  Attributes:
8360 
   - offset
8361 
   - limit
8362 
  """
8363 
 
8364 
  thrift_spec = (
8365 
    None, # 0
8366 
    (1, TType.I64, 'offset', None, None, ), # 1
8367 
    (2, TType.I64, 'limit', None, None, ), # 2
8368 
  )
8369 
 
8370 
  def __init__(self, offset=None, limit=None,):
8371 
    self.offset = offset
8372 
    self.limit = limit
8373 
 
8374 
  def read(self, iprot):
8375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8377 
      return
8378 
    iprot.readStructBegin()
8379 
    while True:
8380 
      (fname, ftype, fid) = iprot.readFieldBegin()
8381 
      if ftype == TType.STOP:
8382 
        break
8383 
      if fid == 1:
8384 
        if ftype == TType.I64:
8385 
          self.offset = iprot.readI64();
8386 
        else:
8387 
          iprot.skip(ftype)
8388 
      elif fid == 2:
8389 
        if ftype == TType.I64:
8390 
          self.limit = iprot.readI64();
8391 
        else:
8392 
          iprot.skip(ftype)
8393 
      else:
8394 
        iprot.skip(ftype)
8395 
      iprot.readFieldEnd()
8396 
    iprot.readStructEnd()
8397 
 
8398 
  def write(self, oprot):
8399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8401 
      return
8402 
    oprot.writeStructBegin('getAllItemsInRange_args')
8403 
    if self.offset is not None:
8404 
      oprot.writeFieldBegin('offset', TType.I64, 1)
8405 
      oprot.writeI64(self.offset)
8406 
      oprot.writeFieldEnd()
8407 
    if self.limit is not None:
8408 
      oprot.writeFieldBegin('limit', TType.I64, 2)
8409 
      oprot.writeI64(self.limit)
8410 
      oprot.writeFieldEnd()
8411 
    oprot.writeFieldStop()
8412 
    oprot.writeStructEnd()
8413 
 
8414 
  def validate(self):
8415 
    return
8416 
 
8417 
 
8418 
  def __repr__(self):
8419 
    L = ['%s=%r' % (key, value)
8420 
      for key, value in self.__dict__.iteritems()]
8421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8422 
 
8423 
  def __eq__(self, other):
8424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8425 
 
8426 
  def __ne__(self, other):
8427 
    return not (self == other)
8428 
 
8429 
class getAllItemsInRange_result:
8430 
  """
8431 
  Attributes:
8432 
   - success
8433 
   - cex
8434 
  """
8435 
 
8436 
  thrift_spec = (
8437 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8438 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8439 
  )
8440 
 
8441 
  def __init__(self, success=None, cex=None,):
8442 
    self.success = success
8443 
    self.cex = cex
8444 
 
8445 
  def read(self, iprot):
8446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8448 
      return
8449 
    iprot.readStructBegin()
8450 
    while True:
8451 
      (fname, ftype, fid) = iprot.readFieldBegin()
8452 
      if ftype == TType.STOP:
8453 
        break
8454 
      if fid == 0:
8455 
        if ftype == TType.LIST:
8456 
          self.success = []
8590 kshitij.so 8457 
          (_etype77, _size74) = iprot.readListBegin()
8458 
          for _i78 in xrange(_size74):
8459 
            _elem79 = Item()
8460 
            _elem79.read(iprot)
8461 
            self.success.append(_elem79)
5944 mandeep.dh 8462 
          iprot.readListEnd()
8463 
        else:
8464 
          iprot.skip(ftype)
8465 
      elif fid == 1:
8466 
        if ftype == TType.STRUCT:
8467 
          self.cex = CatalogServiceException()
8468 
          self.cex.read(iprot)
8469 
        else:
8470 
          iprot.skip(ftype)
8471 
      else:
8472 
        iprot.skip(ftype)
8473 
      iprot.readFieldEnd()
8474 
    iprot.readStructEnd()
8475 
 
8476 
  def write(self, oprot):
8477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8479 
      return
8480 
    oprot.writeStructBegin('getAllItemsInRange_result')
8481 
    if self.success is not None:
8482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8484 
      for iter80 in self.success:
8485 
        iter80.write(oprot)
5944 mandeep.dh 8486 
      oprot.writeListEnd()
8487 
      oprot.writeFieldEnd()
8488 
    if self.cex is not None:
8489 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8490 
      self.cex.write(oprot)
8491 
      oprot.writeFieldEnd()
8492 
    oprot.writeFieldStop()
8493 
    oprot.writeStructEnd()
8494 
 
8495 
  def validate(self):
8496 
    return
8497 
 
8498 
 
8499 
  def __repr__(self):
8500 
    L = ['%s=%r' % (key, value)
8501 
      for key, value in self.__dict__.iteritems()]
8502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8503 
 
8504 
  def __eq__(self, other):
8505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8506 
 
8507 
  def __ne__(self, other):
8508 
    return not (self == other)
8509 
 
8510 
class getAllItemsByStatusInRange_args:
8511 
  """
8512 
  Attributes:
8513 
   - itemStatus
8514 
   - offset
8515 
   - limit
8516 
  """
8517 
 
8518 
  thrift_spec = (
8519 
    None, # 0
8520 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
8521 
    (2, TType.I64, 'offset', None, None, ), # 2
8522 
    (3, TType.I64, 'limit', None, None, ), # 3
8523 
  )
8524 
 
8525 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
8526 
    self.itemStatus = itemStatus
8527 
    self.offset = offset
8528 
    self.limit = limit
8529 
 
8530 
  def read(self, iprot):
8531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8533 
      return
8534 
    iprot.readStructBegin()
8535 
    while True:
8536 
      (fname, ftype, fid) = iprot.readFieldBegin()
8537 
      if ftype == TType.STOP:
8538 
        break
8539 
      if fid == 1:
8540 
        if ftype == TType.I32:
8541 
          self.itemStatus = iprot.readI32();
8542 
        else:
8543 
          iprot.skip(ftype)
8544 
      elif fid == 2:
8545 
        if ftype == TType.I64:
8546 
          self.offset = iprot.readI64();
8547 
        else:
8548 
          iprot.skip(ftype)
8549 
      elif fid == 3:
8550 
        if ftype == TType.I64:
8551 
          self.limit = iprot.readI64();
8552 
        else:
8553 
          iprot.skip(ftype)
8554 
      else:
8555 
        iprot.skip(ftype)
8556 
      iprot.readFieldEnd()
8557 
    iprot.readStructEnd()
8558 
 
8559 
  def write(self, oprot):
8560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8562 
      return
8563 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
8564 
    if self.itemStatus is not None:
8565 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
8566 
      oprot.writeI32(self.itemStatus)
8567 
      oprot.writeFieldEnd()
8568 
    if self.offset is not None:
8569 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8570 
      oprot.writeI64(self.offset)
8571 
      oprot.writeFieldEnd()
8572 
    if self.limit is not None:
8573 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8574 
      oprot.writeI64(self.limit)
8575 
      oprot.writeFieldEnd()
8576 
    oprot.writeFieldStop()
8577 
    oprot.writeStructEnd()
8578 
 
8579 
  def validate(self):
8580 
    return
8581 
 
8582 
 
8583 
  def __repr__(self):
8584 
    L = ['%s=%r' % (key, value)
8585 
      for key, value in self.__dict__.iteritems()]
8586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8587 
 
8588 
  def __eq__(self, other):
8589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8590 
 
8591 
  def __ne__(self, other):
8592 
    return not (self == other)
8593 
 
8594 
class getAllItemsByStatusInRange_result:
8595 
  """
8596 
  Attributes:
8597 
   - success
8598 
   - cex
8599 
  """
8600 
 
8601 
  thrift_spec = (
8602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8603 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8604 
  )
8605 
 
8606 
  def __init__(self, success=None, cex=None,):
8607 
    self.success = success
8608 
    self.cex = cex
8609 
 
8610 
  def read(self, iprot):
8611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8613 
      return
8614 
    iprot.readStructBegin()
8615 
    while True:
8616 
      (fname, ftype, fid) = iprot.readFieldBegin()
8617 
      if ftype == TType.STOP:
8618 
        break
8619 
      if fid == 0:
8620 
        if ftype == TType.LIST:
8621 
          self.success = []
8590 kshitij.so 8622 
          (_etype84, _size81) = iprot.readListBegin()
8623 
          for _i85 in xrange(_size81):
8624 
            _elem86 = Item()
8625 
            _elem86.read(iprot)
8626 
            self.success.append(_elem86)
5944 mandeep.dh 8627 
          iprot.readListEnd()
8628 
        else:
8629 
          iprot.skip(ftype)
8630 
      elif fid == 1:
8631 
        if ftype == TType.STRUCT:
8632 
          self.cex = CatalogServiceException()
8633 
          self.cex.read(iprot)
8634 
        else:
8635 
          iprot.skip(ftype)
8636 
      else:
8637 
        iprot.skip(ftype)
8638 
      iprot.readFieldEnd()
8639 
    iprot.readStructEnd()
8640 
 
8641 
  def write(self, oprot):
8642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8644 
      return
8645 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
8646 
    if self.success is not None:
8647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8649 
      for iter87 in self.success:
8650 
        iter87.write(oprot)
5944 mandeep.dh 8651 
      oprot.writeListEnd()
8652 
      oprot.writeFieldEnd()
8653 
    if self.cex is not None:
8654 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8655 
      self.cex.write(oprot)
8656 
      oprot.writeFieldEnd()
8657 
    oprot.writeFieldStop()
8658 
    oprot.writeStructEnd()
8659 
 
8660 
  def validate(self):
8661 
    return
8662 
 
8663 
 
8664 
  def __repr__(self):
8665 
    L = ['%s=%r' % (key, value)
8666 
      for key, value in self.__dict__.iteritems()]
8667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8668 
 
8669 
  def __eq__(self, other):
8670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8671 
 
8672 
  def __ne__(self, other):
8673 
    return not (self == other)
8674 
 
8675 
class getItemCountByStatus_args:
8676 
  """
8677 
  Attributes:
8678 
   - useStatus
8679 
   - itemStatus
8680 
  """
8681 
 
8682 
  thrift_spec = (
8683 
    None, # 0
8684 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
8685 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
8686 
  )
8687 
 
8688 
  def __init__(self, useStatus=None, itemStatus=None,):
8689 
    self.useStatus = useStatus
8690 
    self.itemStatus = itemStatus
8691 
 
8692 
  def read(self, iprot):
8693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8695 
      return
8696 
    iprot.readStructBegin()
8697 
    while True:
8698 
      (fname, ftype, fid) = iprot.readFieldBegin()
8699 
      if ftype == TType.STOP:
8700 
        break
8701 
      if fid == 1:
8702 
        if ftype == TType.BOOL:
8703 
          self.useStatus = iprot.readBool();
8704 
        else:
8705 
          iprot.skip(ftype)
8706 
      elif fid == 2:
8707 
        if ftype == TType.I32:
8708 
          self.itemStatus = iprot.readI32();
8709 
        else:
8710 
          iprot.skip(ftype)
8711 
      else:
8712 
        iprot.skip(ftype)
8713 
      iprot.readFieldEnd()
8714 
    iprot.readStructEnd()
8715 
 
8716 
  def write(self, oprot):
8717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8719 
      return
8720 
    oprot.writeStructBegin('getItemCountByStatus_args')
8721 
    if self.useStatus is not None:
8722 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
8723 
      oprot.writeBool(self.useStatus)
8724 
      oprot.writeFieldEnd()
8725 
    if self.itemStatus is not None:
8726 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
8727 
      oprot.writeI32(self.itemStatus)
8728 
      oprot.writeFieldEnd()
8729 
    oprot.writeFieldStop()
8730 
    oprot.writeStructEnd()
8731 
 
8732 
  def validate(self):
8733 
    return
8734 
 
8735 
 
8736 
  def __repr__(self):
8737 
    L = ['%s=%r' % (key, value)
8738 
      for key, value in self.__dict__.iteritems()]
8739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8740 
 
8741 
  def __eq__(self, other):
8742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8743 
 
8744 
  def __ne__(self, other):
8745 
    return not (self == other)
8746 
 
8747 
class getItemCountByStatus_result:
8748 
  """
8749 
  Attributes:
8750 
   - success
8751 
  """
8752 
 
8753 
  thrift_spec = (
8754 
    (0, TType.I32, 'success', None, None, ), # 0
8755 
  )
8756 
 
8757 
  def __init__(self, success=None,):
8758 
    self.success = success
8759 
 
8760 
  def read(self, iprot):
8761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8763 
      return
8764 
    iprot.readStructBegin()
8765 
    while True:
8766 
      (fname, ftype, fid) = iprot.readFieldBegin()
8767 
      if ftype == TType.STOP:
8768 
        break
8769 
      if fid == 0:
8770 
        if ftype == TType.I32:
8771 
          self.success = iprot.readI32();
8772 
        else:
8773 
          iprot.skip(ftype)
8774 
      else:
8775 
        iprot.skip(ftype)
8776 
      iprot.readFieldEnd()
8777 
    iprot.readStructEnd()
8778 
 
8779 
  def write(self, oprot):
8780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8782 
      return
8783 
    oprot.writeStructBegin('getItemCountByStatus_result')
8784 
    if self.success is not None:
8785 
      oprot.writeFieldBegin('success', TType.I32, 0)
8786 
      oprot.writeI32(self.success)
8787 
      oprot.writeFieldEnd()
8788 
    oprot.writeFieldStop()
8789 
    oprot.writeStructEnd()
8790 
 
8791 
  def validate(self):
8792 
    return
8793 
 
8794 
 
8795 
  def __repr__(self):
8796 
    L = ['%s=%r' % (key, value)
8797 
      for key, value in self.__dict__.iteritems()]
8798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8799 
 
8800 
  def __eq__(self, other):
8801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8802 
 
8803 
  def __ne__(self, other):
8804 
    return not (self == other)
8805 
 
8806 
class getBestSellers_args:
8807 
 
8808 
  thrift_spec = (
8809 
  )
8810 
 
8811 
  def read(self, iprot):
8812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8814 
      return
8815 
    iprot.readStructBegin()
8816 
    while True:
8817 
      (fname, ftype, fid) = iprot.readFieldBegin()
8818 
      if ftype == TType.STOP:
8819 
        break
8820 
      else:
8821 
        iprot.skip(ftype)
8822 
      iprot.readFieldEnd()
8823 
    iprot.readStructEnd()
8824 
 
8825 
  def write(self, oprot):
8826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8828 
      return
8829 
    oprot.writeStructBegin('getBestSellers_args')
8830 
    oprot.writeFieldStop()
8831 
    oprot.writeStructEnd()
8832 
 
8833 
  def validate(self):
8834 
    return
8835 
 
8836 
 
8837 
  def __repr__(self):
8838 
    L = ['%s=%r' % (key, value)
8839 
      for key, value in self.__dict__.iteritems()]
8840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8841 
 
8842 
  def __eq__(self, other):
8843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8844 
 
8845 
  def __ne__(self, other):
8846 
    return not (self == other)
8847 
 
8848 
class getBestSellers_result:
8849 
  """
8850 
  Attributes:
8851 
   - success
8852 
   - isex
8853 
  """
8854 
 
8855 
  thrift_spec = (
8856 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8857 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8858 
  )
8859 
 
8860 
  def __init__(self, success=None, isex=None,):
8861 
    self.success = success
8862 
    self.isex = isex
8863 
 
8864 
  def read(self, iprot):
8865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8867 
      return
8868 
    iprot.readStructBegin()
8869 
    while True:
8870 
      (fname, ftype, fid) = iprot.readFieldBegin()
8871 
      if ftype == TType.STOP:
8872 
        break
8873 
      if fid == 0:
8874 
        if ftype == TType.LIST:
8875 
          self.success = []
8590 kshitij.so 8876 
          (_etype91, _size88) = iprot.readListBegin()
8877 
          for _i92 in xrange(_size88):
8878 
            _elem93 = Item()
8879 
            _elem93.read(iprot)
8880 
            self.success.append(_elem93)
5944 mandeep.dh 8881 
          iprot.readListEnd()
8882 
        else:
8883 
          iprot.skip(ftype)
8884 
      elif fid == 1:
8885 
        if ftype == TType.STRUCT:
8886 
          self.isex = CatalogServiceException()
8887 
          self.isex.read(iprot)
8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      else:
8891 
        iprot.skip(ftype)
8892 
      iprot.readFieldEnd()
8893 
    iprot.readStructEnd()
8894 
 
8895 
  def write(self, oprot):
8896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8898 
      return
8899 
    oprot.writeStructBegin('getBestSellers_result')
8900 
    if self.success is not None:
8901 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8902 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 8903 
      for iter94 in self.success:
8904 
        iter94.write(oprot)
5944 mandeep.dh 8905 
      oprot.writeListEnd()
8906 
      oprot.writeFieldEnd()
8907 
    if self.isex is not None:
8908 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8909 
      self.isex.write(oprot)
8910 
      oprot.writeFieldEnd()
8911 
    oprot.writeFieldStop()
8912 
    oprot.writeStructEnd()
8913 
 
8914 
  def validate(self):
8915 
    return
8916 
 
8917 
 
8918 
  def __repr__(self):
8919 
    L = ['%s=%r' % (key, value)
8920 
      for key, value in self.__dict__.iteritems()]
8921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8922 
 
8923 
  def __eq__(self, other):
8924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8925 
 
8926 
  def __ne__(self, other):
8927 
    return not (self == other)
8928 
 
8929 
class getBestSellersCatalogIds_args:
8930 
  """
8931 
  Attributes:
8932 
   - beginIndex
8933 
   - totalItems
8934 
   - brand
8935 
   - category
8936 
  """
8937 
 
8938 
  thrift_spec = (
8939 
    None, # 0
8940 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8941 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8942 
    (3, TType.STRING, 'brand', None, None, ), # 3
8943 
    (4, TType.I64, 'category', None, None, ), # 4
8944 
  )
8945 
 
8946 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8947 
    self.beginIndex = beginIndex
8948 
    self.totalItems = totalItems
8949 
    self.brand = brand
8950 
    self.category = category
8951 
 
8952 
  def read(self, iprot):
8953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8955 
      return
8956 
    iprot.readStructBegin()
8957 
    while True:
8958 
      (fname, ftype, fid) = iprot.readFieldBegin()
8959 
      if ftype == TType.STOP:
8960 
        break
8961 
      if fid == 1:
8962 
        if ftype == TType.I64:
8963 
          self.beginIndex = iprot.readI64();
8964 
        else:
8965 
          iprot.skip(ftype)
8966 
      elif fid == 2:
8967 
        if ftype == TType.I64:
8968 
          self.totalItems = iprot.readI64();
8969 
        else:
8970 
          iprot.skip(ftype)
8971 
      elif fid == 3:
8972 
        if ftype == TType.STRING:
8973 
          self.brand = iprot.readString();
8974 
        else:
8975 
          iprot.skip(ftype)
8976 
      elif fid == 4:
8977 
        if ftype == TType.I64:
8978 
          self.category = iprot.readI64();
8979 
        else:
8980 
          iprot.skip(ftype)
8981 
      else:
8982 
        iprot.skip(ftype)
8983 
      iprot.readFieldEnd()
8984 
    iprot.readStructEnd()
8985 
 
8986 
  def write(self, oprot):
8987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8989 
      return
8990 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
8991 
    if self.beginIndex is not None:
8992 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8993 
      oprot.writeI64(self.beginIndex)
8994 
      oprot.writeFieldEnd()
8995 
    if self.totalItems is not None:
8996 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8997 
      oprot.writeI64(self.totalItems)
8998 
      oprot.writeFieldEnd()
8999 
    if self.brand is not None:
9000 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9001 
      oprot.writeString(self.brand)
9002 
      oprot.writeFieldEnd()
9003 
    if self.category is not None:
9004 
      oprot.writeFieldBegin('category', TType.I64, 4)
9005 
      oprot.writeI64(self.category)
9006 
      oprot.writeFieldEnd()
9007 
    oprot.writeFieldStop()
9008 
    oprot.writeStructEnd()
9009 
 
9010 
  def validate(self):
9011 
    return
9012 
 
9013 
 
9014 
  def __repr__(self):
9015 
    L = ['%s=%r' % (key, value)
9016 
      for key, value in self.__dict__.iteritems()]
9017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9018 
 
9019 
  def __eq__(self, other):
9020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9021 
 
9022 
  def __ne__(self, other):
9023 
    return not (self == other)
9024 
 
9025 
class getBestSellersCatalogIds_result:
9026 
  """
9027 
  Attributes:
9028 
   - success
9029 
   - cex
9030 
  """
9031 
 
9032 
  thrift_spec = (
9033 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9034 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9035 
  )
9036 
 
9037 
  def __init__(self, success=None, cex=None,):
9038 
    self.success = success
9039 
    self.cex = cex
9040 
 
9041 
  def read(self, iprot):
9042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9044 
      return
9045 
    iprot.readStructBegin()
9046 
    while True:
9047 
      (fname, ftype, fid) = iprot.readFieldBegin()
9048 
      if ftype == TType.STOP:
9049 
        break
9050 
      if fid == 0:
9051 
        if ftype == TType.LIST:
9052 
          self.success = []
8590 kshitij.so 9053 
          (_etype98, _size95) = iprot.readListBegin()
9054 
          for _i99 in xrange(_size95):
9055 
            _elem100 = iprot.readI64();
9056 
            self.success.append(_elem100)
5944 mandeep.dh 9057 
          iprot.readListEnd()
9058 
        else:
9059 
          iprot.skip(ftype)
9060 
      elif fid == 1:
9061 
        if ftype == TType.STRUCT:
9062 
          self.cex = CatalogServiceException()
9063 
          self.cex.read(iprot)
9064 
        else:
9065 
          iprot.skip(ftype)
9066 
      else:
9067 
        iprot.skip(ftype)
9068 
      iprot.readFieldEnd()
9069 
    iprot.readStructEnd()
9070 
 
9071 
  def write(self, oprot):
9072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9074 
      return
9075 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
9076 
    if self.success is not None:
9077 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9078 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9079 
      for iter101 in self.success:
9080 
        oprot.writeI64(iter101)
5944 mandeep.dh 9081 
      oprot.writeListEnd()
9082 
      oprot.writeFieldEnd()
9083 
    if self.cex is not None:
9084 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9085 
      self.cex.write(oprot)
9086 
      oprot.writeFieldEnd()
9087 
    oprot.writeFieldStop()
9088 
    oprot.writeStructEnd()
9089 
 
9090 
  def validate(self):
9091 
    return
9092 
 
9093 
 
9094 
  def __repr__(self):
9095 
    L = ['%s=%r' % (key, value)
9096 
      for key, value in self.__dict__.iteritems()]
9097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9098 
 
9099 
  def __eq__(self, other):
9100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9101 
 
9102 
  def __ne__(self, other):
9103 
    return not (self == other)
9104 
 
9105 
class getBestSellersCount_args:
9106 
 
9107 
  thrift_spec = (
9108 
  )
9109 
 
9110 
  def read(self, iprot):
9111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9113 
      return
9114 
    iprot.readStructBegin()
9115 
    while True:
9116 
      (fname, ftype, fid) = iprot.readFieldBegin()
9117 
      if ftype == TType.STOP:
9118 
        break
9119 
      else:
9120 
        iprot.skip(ftype)
9121 
      iprot.readFieldEnd()
9122 
    iprot.readStructEnd()
9123 
 
9124 
  def write(self, oprot):
9125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9127 
      return
9128 
    oprot.writeStructBegin('getBestSellersCount_args')
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 getBestSellersCount_result:
9148 
  """
9149 
  Attributes:
9150 
   - success
9151 
   - cex
9152 
  """
9153 
 
9154 
  thrift_spec = (
9155 
    (0, TType.I64, 'success', None, None, ), # 0
9156 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9157 
  )
9158 
 
9159 
  def __init__(self, success=None, cex=None,):
9160 
    self.success = success
9161 
    self.cex = cex
9162 
 
9163 
  def read(self, iprot):
9164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9166 
      return
9167 
    iprot.readStructBegin()
9168 
    while True:
9169 
      (fname, ftype, fid) = iprot.readFieldBegin()
9170 
      if ftype == TType.STOP:
9171 
        break
9172 
      if fid == 0:
9173 
        if ftype == TType.I64:
9174 
          self.success = iprot.readI64();
9175 
        else:
9176 
          iprot.skip(ftype)
9177 
      elif fid == 1:
9178 
        if ftype == TType.STRUCT:
9179 
          self.cex = CatalogServiceException()
9180 
          self.cex.read(iprot)
9181 
        else:
9182 
          iprot.skip(ftype)
9183 
      else:
9184 
        iprot.skip(ftype)
9185 
      iprot.readFieldEnd()
9186 
    iprot.readStructEnd()
9187 
 
9188 
  def write(self, oprot):
9189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9191 
      return
9192 
    oprot.writeStructBegin('getBestSellersCount_result')
9193 
    if self.success is not None:
9194 
      oprot.writeFieldBegin('success', TType.I64, 0)
9195 
      oprot.writeI64(self.success)
9196 
      oprot.writeFieldEnd()
9197 
    if self.cex is not None:
9198 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9199 
      self.cex.write(oprot)
9200 
      oprot.writeFieldEnd()
9201 
    oprot.writeFieldStop()
9202 
    oprot.writeStructEnd()
9203 
 
9204 
  def validate(self):
9205 
    return
9206 
 
9207 
 
9208 
  def __repr__(self):
9209 
    L = ['%s=%r' % (key, value)
9210 
      for key, value in self.__dict__.iteritems()]
9211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9212 
 
9213 
  def __eq__(self, other):
9214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9215 
 
9216 
  def __ne__(self, other):
9217 
    return not (self == other)
9218 
 
9219 
class getBestDeals_args:
9220 
 
9221 
  thrift_spec = (
9222 
  )
9223 
 
9224 
  def read(self, iprot):
9225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9227 
      return
9228 
    iprot.readStructBegin()
9229 
    while True:
9230 
      (fname, ftype, fid) = iprot.readFieldBegin()
9231 
      if ftype == TType.STOP:
9232 
        break
9233 
      else:
9234 
        iprot.skip(ftype)
9235 
      iprot.readFieldEnd()
9236 
    iprot.readStructEnd()
9237 
 
9238 
  def write(self, oprot):
9239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9241 
      return
9242 
    oprot.writeStructBegin('getBestDeals_args')
9243 
    oprot.writeFieldStop()
9244 
    oprot.writeStructEnd()
9245 
 
9246 
  def validate(self):
9247 
    return
9248 
 
9249 
 
9250 
  def __repr__(self):
9251 
    L = ['%s=%r' % (key, value)
9252 
      for key, value in self.__dict__.iteritems()]
9253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9254 
 
9255 
  def __eq__(self, other):
9256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9257 
 
9258 
  def __ne__(self, other):
9259 
    return not (self == other)
9260 
 
9261 
class getBestDeals_result:
9262 
  """
9263 
  Attributes:
9264 
   - success
9265 
   - isex
9266 
  """
9267 
 
9268 
  thrift_spec = (
9269 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9270 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9271 
  )
9272 
 
9273 
  def __init__(self, success=None, isex=None,):
9274 
    self.success = success
9275 
    self.isex = isex
9276 
 
9277 
  def read(self, iprot):
9278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9280 
      return
9281 
    iprot.readStructBegin()
9282 
    while True:
9283 
      (fname, ftype, fid) = iprot.readFieldBegin()
9284 
      if ftype == TType.STOP:
9285 
        break
9286 
      if fid == 0:
9287 
        if ftype == TType.LIST:
9288 
          self.success = []
8590 kshitij.so 9289 
          (_etype105, _size102) = iprot.readListBegin()
9290 
          for _i106 in xrange(_size102):
9291 
            _elem107 = Item()
9292 
            _elem107.read(iprot)
9293 
            self.success.append(_elem107)
5944 mandeep.dh 9294 
          iprot.readListEnd()
9295 
        else:
9296 
          iprot.skip(ftype)
9297 
      elif fid == 1:
9298 
        if ftype == TType.STRUCT:
9299 
          self.isex = CatalogServiceException()
9300 
          self.isex.read(iprot)
9301 
        else:
9302 
          iprot.skip(ftype)
9303 
      else:
9304 
        iprot.skip(ftype)
9305 
      iprot.readFieldEnd()
9306 
    iprot.readStructEnd()
9307 
 
9308 
  def write(self, oprot):
9309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9311 
      return
9312 
    oprot.writeStructBegin('getBestDeals_result')
9313 
    if self.success is not None:
9314 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9315 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9316 
      for iter108 in self.success:
9317 
        iter108.write(oprot)
5944 mandeep.dh 9318 
      oprot.writeListEnd()
9319 
      oprot.writeFieldEnd()
9320 
    if self.isex is not None:
9321 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9322 
      self.isex.write(oprot)
9323 
      oprot.writeFieldEnd()
9324 
    oprot.writeFieldStop()
9325 
    oprot.writeStructEnd()
9326 
 
9327 
  def validate(self):
9328 
    return
9329 
 
9330 
 
9331 
  def __repr__(self):
9332 
    L = ['%s=%r' % (key, value)
9333 
      for key, value in self.__dict__.iteritems()]
9334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9335 
 
9336 
  def __eq__(self, other):
9337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9338 
 
9339 
  def __ne__(self, other):
9340 
    return not (self == other)
9341 
 
9342 
class getBestDealsCatalogIds_args:
9343 
  """
9344 
  Attributes:
9345 
   - beginIndex
9346 
   - totalItems
9347 
   - brand
9348 
   - category
9349 
  """
9350 
 
9351 
  thrift_spec = (
9352 
    None, # 0
9353 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9354 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9355 
    (3, TType.STRING, 'brand', None, None, ), # 3
9356 
    (4, TType.I64, 'category', None, None, ), # 4
9357 
  )
9358 
 
9359 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9360 
    self.beginIndex = beginIndex
9361 
    self.totalItems = totalItems
9362 
    self.brand = brand
9363 
    self.category = category
9364 
 
9365 
  def read(self, iprot):
9366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9368 
      return
9369 
    iprot.readStructBegin()
9370 
    while True:
9371 
      (fname, ftype, fid) = iprot.readFieldBegin()
9372 
      if ftype == TType.STOP:
9373 
        break
9374 
      if fid == 1:
9375 
        if ftype == TType.I64:
9376 
          self.beginIndex = iprot.readI64();
9377 
        else:
9378 
          iprot.skip(ftype)
9379 
      elif fid == 2:
9380 
        if ftype == TType.I64:
9381 
          self.totalItems = iprot.readI64();
9382 
        else:
9383 
          iprot.skip(ftype)
9384 
      elif fid == 3:
9385 
        if ftype == TType.STRING:
9386 
          self.brand = iprot.readString();
9387 
        else:
9388 
          iprot.skip(ftype)
9389 
      elif fid == 4:
9390 
        if ftype == TType.I64:
9391 
          self.category = iprot.readI64();
9392 
        else:
9393 
          iprot.skip(ftype)
9394 
      else:
9395 
        iprot.skip(ftype)
9396 
      iprot.readFieldEnd()
9397 
    iprot.readStructEnd()
9398 
 
9399 
  def write(self, oprot):
9400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9402 
      return
9403 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
9404 
    if self.beginIndex is not None:
9405 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9406 
      oprot.writeI64(self.beginIndex)
9407 
      oprot.writeFieldEnd()
9408 
    if self.totalItems is not None:
9409 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9410 
      oprot.writeI64(self.totalItems)
9411 
      oprot.writeFieldEnd()
9412 
    if self.brand is not None:
9413 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9414 
      oprot.writeString(self.brand)
9415 
      oprot.writeFieldEnd()
9416 
    if self.category is not None:
9417 
      oprot.writeFieldBegin('category', TType.I64, 4)
9418 
      oprot.writeI64(self.category)
9419 
      oprot.writeFieldEnd()
9420 
    oprot.writeFieldStop()
9421 
    oprot.writeStructEnd()
9422 
 
9423 
  def validate(self):
9424 
    return
9425 
 
9426 
 
9427 
  def __repr__(self):
9428 
    L = ['%s=%r' % (key, value)
9429 
      for key, value in self.__dict__.iteritems()]
9430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9431 
 
9432 
  def __eq__(self, other):
9433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9434 
 
9435 
  def __ne__(self, other):
9436 
    return not (self == other)
9437 
 
9438 
class getBestDealsCatalogIds_result:
9439 
  """
9440 
  Attributes:
9441 
   - success
9442 
   - cex
9443 
  """
9444 
 
9445 
  thrift_spec = (
9446 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9447 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9448 
  )
9449 
 
9450 
  def __init__(self, success=None, cex=None,):
9451 
    self.success = success
9452 
    self.cex = cex
9453 
 
9454 
  def read(self, iprot):
9455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9457 
      return
9458 
    iprot.readStructBegin()
9459 
    while True:
9460 
      (fname, ftype, fid) = iprot.readFieldBegin()
9461 
      if ftype == TType.STOP:
9462 
        break
9463 
      if fid == 0:
9464 
        if ftype == TType.LIST:
9465 
          self.success = []
8590 kshitij.so 9466 
          (_etype112, _size109) = iprot.readListBegin()
9467 
          for _i113 in xrange(_size109):
9468 
            _elem114 = iprot.readI64();
9469 
            self.success.append(_elem114)
5944 mandeep.dh 9470 
          iprot.readListEnd()
9471 
        else:
9472 
          iprot.skip(ftype)
9473 
      elif fid == 1:
9474 
        if ftype == TType.STRUCT:
9475 
          self.cex = CatalogServiceException()
9476 
          self.cex.read(iprot)
9477 
        else:
9478 
          iprot.skip(ftype)
9479 
      else:
9480 
        iprot.skip(ftype)
9481 
      iprot.readFieldEnd()
9482 
    iprot.readStructEnd()
9483 
 
9484 
  def write(self, oprot):
9485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9487 
      return
9488 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
9489 
    if self.success is not None:
9490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9491 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9492 
      for iter115 in self.success:
9493 
        oprot.writeI64(iter115)
5944 mandeep.dh 9494 
      oprot.writeListEnd()
9495 
      oprot.writeFieldEnd()
9496 
    if self.cex is not None:
9497 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9498 
      self.cex.write(oprot)
9499 
      oprot.writeFieldEnd()
9500 
    oprot.writeFieldStop()
9501 
    oprot.writeStructEnd()
9502 
 
9503 
  def validate(self):
9504 
    return
9505 
 
9506 
 
9507 
  def __repr__(self):
9508 
    L = ['%s=%r' % (key, value)
9509 
      for key, value in self.__dict__.iteritems()]
9510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9511 
 
9512 
  def __eq__(self, other):
9513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9514 
 
9515 
  def __ne__(self, other):
9516 
    return not (self == other)
9517 
 
9518 
class getBestDealsCount_args:
9519 
 
9520 
  thrift_spec = (
9521 
  )
9522 
 
9523 
  def read(self, iprot):
9524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9526 
      return
9527 
    iprot.readStructBegin()
9528 
    while True:
9529 
      (fname, ftype, fid) = iprot.readFieldBegin()
9530 
      if ftype == TType.STOP:
9531 
        break
9532 
      else:
9533 
        iprot.skip(ftype)
9534 
      iprot.readFieldEnd()
9535 
    iprot.readStructEnd()
9536 
 
9537 
  def write(self, oprot):
9538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9540 
      return
9541 
    oprot.writeStructBegin('getBestDealsCount_args')
9542 
    oprot.writeFieldStop()
9543 
    oprot.writeStructEnd()
9544 
 
9545 
  def validate(self):
9546 
    return
9547 
 
9548 
 
9549 
  def __repr__(self):
9550 
    L = ['%s=%r' % (key, value)
9551 
      for key, value in self.__dict__.iteritems()]
9552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9553 
 
9554 
  def __eq__(self, other):
9555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9556 
 
9557 
  def __ne__(self, other):
9558 
    return not (self == other)
9559 
 
9560 
class getBestDealsCount_result:
9561 
  """
9562 
  Attributes:
9563 
   - success
9564 
   - cex
9565 
  """
9566 
 
9567 
  thrift_spec = (
9568 
    (0, TType.I64, 'success', None, None, ), # 0
9569 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9570 
  )
9571 
 
9572 
  def __init__(self, success=None, cex=None,):
9573 
    self.success = success
9574 
    self.cex = cex
9575 
 
9576 
  def read(self, iprot):
9577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9579 
      return
9580 
    iprot.readStructBegin()
9581 
    while True:
9582 
      (fname, ftype, fid) = iprot.readFieldBegin()
9583 
      if ftype == TType.STOP:
9584 
        break
9585 
      if fid == 0:
9586 
        if ftype == TType.I64:
9587 
          self.success = iprot.readI64();
9588 
        else:
9589 
          iprot.skip(ftype)
9590 
      elif fid == 1:
9591 
        if ftype == TType.STRUCT:
9592 
          self.cex = CatalogServiceException()
9593 
          self.cex.read(iprot)
9594 
        else:
9595 
          iprot.skip(ftype)
9596 
      else:
9597 
        iprot.skip(ftype)
9598 
      iprot.readFieldEnd()
9599 
    iprot.readStructEnd()
9600 
 
9601 
  def write(self, oprot):
9602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9604 
      return
9605 
    oprot.writeStructBegin('getBestDealsCount_result')
9606 
    if self.success is not None:
9607 
      oprot.writeFieldBegin('success', TType.I64, 0)
9608 
      oprot.writeI64(self.success)
9609 
      oprot.writeFieldEnd()
9610 
    if self.cex is not None:
9611 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9612 
      self.cex.write(oprot)
9613 
      oprot.writeFieldEnd()
9614 
    oprot.writeFieldStop()
9615 
    oprot.writeStructEnd()
9616 
 
9617 
  def validate(self):
9618 
    return
9619 
 
9620 
 
9621 
  def __repr__(self):
9622 
    L = ['%s=%r' % (key, value)
9623 
      for key, value in self.__dict__.iteritems()]
9624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9625 
 
9626 
  def __eq__(self, other):
9627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9628 
 
9629 
  def __ne__(self, other):
9630 
    return not (self == other)
9631 
 
9632 
class getComingSoon_args:
9633 
 
9634 
  thrift_spec = (
9635 
  )
9636 
 
9637 
  def read(self, iprot):
9638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9640 
      return
9641 
    iprot.readStructBegin()
9642 
    while True:
9643 
      (fname, ftype, fid) = iprot.readFieldBegin()
9644 
      if ftype == TType.STOP:
9645 
        break
9646 
      else:
9647 
        iprot.skip(ftype)
9648 
      iprot.readFieldEnd()
9649 
    iprot.readStructEnd()
9650 
 
9651 
  def write(self, oprot):
9652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9654 
      return
9655 
    oprot.writeStructBegin('getComingSoon_args')
9656 
    oprot.writeFieldStop()
9657 
    oprot.writeStructEnd()
9658 
 
9659 
  def validate(self):
9660 
    return
9661 
 
9662 
 
9663 
  def __repr__(self):
9664 
    L = ['%s=%r' % (key, value)
9665 
      for key, value in self.__dict__.iteritems()]
9666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9667 
 
9668 
  def __eq__(self, other):
9669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9670 
 
9671 
  def __ne__(self, other):
9672 
    return not (self == other)
9673 
 
9674 
class getComingSoon_result:
9675 
  """
9676 
  Attributes:
9677 
   - success
9678 
   - isex
9679 
  """
9680 
 
9681 
  thrift_spec = (
9682 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9683 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9684 
  )
9685 
 
9686 
  def __init__(self, success=None, isex=None,):
9687 
    self.success = success
9688 
    self.isex = isex
9689 
 
9690 
  def read(self, iprot):
9691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9693 
      return
9694 
    iprot.readStructBegin()
9695 
    while True:
9696 
      (fname, ftype, fid) = iprot.readFieldBegin()
9697 
      if ftype == TType.STOP:
9698 
        break
9699 
      if fid == 0:
9700 
        if ftype == TType.LIST:
9701 
          self.success = []
8590 kshitij.so 9702 
          (_etype119, _size116) = iprot.readListBegin()
9703 
          for _i120 in xrange(_size116):
9704 
            _elem121 = Item()
9705 
            _elem121.read(iprot)
9706 
            self.success.append(_elem121)
5944 mandeep.dh 9707 
          iprot.readListEnd()
9708 
        else:
9709 
          iprot.skip(ftype)
9710 
      elif fid == 1:
9711 
        if ftype == TType.STRUCT:
9712 
          self.isex = CatalogServiceException()
9713 
          self.isex.read(iprot)
9714 
        else:
9715 
          iprot.skip(ftype)
9716 
      else:
9717 
        iprot.skip(ftype)
9718 
      iprot.readFieldEnd()
9719 
    iprot.readStructEnd()
9720 
 
9721 
  def write(self, oprot):
9722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9724 
      return
9725 
    oprot.writeStructBegin('getComingSoon_result')
9726 
    if self.success is not None:
9727 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9728 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 9729 
      for iter122 in self.success:
9730 
        iter122.write(oprot)
5944 mandeep.dh 9731 
      oprot.writeListEnd()
9732 
      oprot.writeFieldEnd()
9733 
    if self.isex is not None:
9734 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
9735 
      self.isex.write(oprot)
9736 
      oprot.writeFieldEnd()
9737 
    oprot.writeFieldStop()
9738 
    oprot.writeStructEnd()
9739 
 
9740 
  def validate(self):
9741 
    return
9742 
 
9743 
 
9744 
  def __repr__(self):
9745 
    L = ['%s=%r' % (key, value)
9746 
      for key, value in self.__dict__.iteritems()]
9747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9748 
 
9749 
  def __eq__(self, other):
9750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9751 
 
9752 
  def __ne__(self, other):
9753 
    return not (self == other)
9754 
 
9755 
class getComingSoonCatalogIds_args:
9756 
  """
9757 
  Attributes:
9758 
   - beginIndex
9759 
   - totalItems
9760 
   - brand
9761 
   - category
9762 
  """
9763 
 
9764 
  thrift_spec = (
9765 
    None, # 0
9766 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
9767 
    (2, TType.I64, 'totalItems', None, None, ), # 2
9768 
    (3, TType.STRING, 'brand', None, None, ), # 3
9769 
    (4, TType.I64, 'category', None, None, ), # 4
9770 
  )
9771 
 
9772 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
9773 
    self.beginIndex = beginIndex
9774 
    self.totalItems = totalItems
9775 
    self.brand = brand
9776 
    self.category = category
9777 
 
9778 
  def read(self, iprot):
9779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9781 
      return
9782 
    iprot.readStructBegin()
9783 
    while True:
9784 
      (fname, ftype, fid) = iprot.readFieldBegin()
9785 
      if ftype == TType.STOP:
9786 
        break
9787 
      if fid == 1:
9788 
        if ftype == TType.I64:
9789 
          self.beginIndex = iprot.readI64();
9790 
        else:
9791 
          iprot.skip(ftype)
9792 
      elif fid == 2:
9793 
        if ftype == TType.I64:
9794 
          self.totalItems = iprot.readI64();
9795 
        else:
9796 
          iprot.skip(ftype)
9797 
      elif fid == 3:
9798 
        if ftype == TType.STRING:
9799 
          self.brand = iprot.readString();
9800 
        else:
9801 
          iprot.skip(ftype)
9802 
      elif fid == 4:
9803 
        if ftype == TType.I64:
9804 
          self.category = iprot.readI64();
9805 
        else:
9806 
          iprot.skip(ftype)
9807 
      else:
9808 
        iprot.skip(ftype)
9809 
      iprot.readFieldEnd()
9810 
    iprot.readStructEnd()
9811 
 
9812 
  def write(self, oprot):
9813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9815 
      return
9816 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
9817 
    if self.beginIndex is not None:
9818 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9819 
      oprot.writeI64(self.beginIndex)
9820 
      oprot.writeFieldEnd()
9821 
    if self.totalItems is not None:
9822 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9823 
      oprot.writeI64(self.totalItems)
9824 
      oprot.writeFieldEnd()
9825 
    if self.brand is not None:
9826 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9827 
      oprot.writeString(self.brand)
9828 
      oprot.writeFieldEnd()
9829 
    if self.category is not None:
9830 
      oprot.writeFieldBegin('category', TType.I64, 4)
9831 
      oprot.writeI64(self.category)
9832 
      oprot.writeFieldEnd()
9833 
    oprot.writeFieldStop()
9834 
    oprot.writeStructEnd()
9835 
 
9836 
  def validate(self):
9837 
    return
9838 
 
9839 
 
9840 
  def __repr__(self):
9841 
    L = ['%s=%r' % (key, value)
9842 
      for key, value in self.__dict__.iteritems()]
9843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9844 
 
9845 
  def __eq__(self, other):
9846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9847 
 
9848 
  def __ne__(self, other):
9849 
    return not (self == other)
9850 
 
9851 
class getComingSoonCatalogIds_result:
9852 
  """
9853 
  Attributes:
9854 
   - success
9855 
   - cex
9856 
  """
9857 
 
9858 
  thrift_spec = (
9859 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9860 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9861 
  )
9862 
 
9863 
  def __init__(self, success=None, cex=None,):
9864 
    self.success = success
9865 
    self.cex = cex
9866 
 
9867 
  def read(self, iprot):
9868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9870 
      return
9871 
    iprot.readStructBegin()
9872 
    while True:
9873 
      (fname, ftype, fid) = iprot.readFieldBegin()
9874 
      if ftype == TType.STOP:
9875 
        break
9876 
      if fid == 0:
9877 
        if ftype == TType.LIST:
9878 
          self.success = []
8590 kshitij.so 9879 
          (_etype126, _size123) = iprot.readListBegin()
9880 
          for _i127 in xrange(_size123):
9881 
            _elem128 = iprot.readI64();
9882 
            self.success.append(_elem128)
5944 mandeep.dh 9883 
          iprot.readListEnd()
9884 
        else:
9885 
          iprot.skip(ftype)
9886 
      elif fid == 1:
9887 
        if ftype == TType.STRUCT:
9888 
          self.cex = CatalogServiceException()
9889 
          self.cex.read(iprot)
9890 
        else:
9891 
          iprot.skip(ftype)
9892 
      else:
9893 
        iprot.skip(ftype)
9894 
      iprot.readFieldEnd()
9895 
    iprot.readStructEnd()
9896 
 
9897 
  def write(self, oprot):
9898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9900 
      return
9901 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
9902 
    if self.success is not None:
9903 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9904 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 9905 
      for iter129 in self.success:
9906 
        oprot.writeI64(iter129)
5944 mandeep.dh 9907 
      oprot.writeListEnd()
9908 
      oprot.writeFieldEnd()
9909 
    if self.cex is not None:
9910 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9911 
      self.cex.write(oprot)
9912 
      oprot.writeFieldEnd()
9913 
    oprot.writeFieldStop()
9914 
    oprot.writeStructEnd()
9915 
 
9916 
  def validate(self):
9917 
    return
9918 
 
9919 
 
9920 
  def __repr__(self):
9921 
    L = ['%s=%r' % (key, value)
9922 
      for key, value in self.__dict__.iteritems()]
9923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9924 
 
9925 
  def __eq__(self, other):
9926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9927 
 
9928 
  def __ne__(self, other):
9929 
    return not (self == other)
9930 
 
9931 
class getComingSoonCount_args:
9932 
 
9933 
  thrift_spec = (
9934 
  )
9935 
 
9936 
  def read(self, iprot):
9937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9939 
      return
9940 
    iprot.readStructBegin()
9941 
    while True:
9942 
      (fname, ftype, fid) = iprot.readFieldBegin()
9943 
      if ftype == TType.STOP:
9944 
        break
9945 
      else:
9946 
        iprot.skip(ftype)
9947 
      iprot.readFieldEnd()
9948 
    iprot.readStructEnd()
9949 
 
9950 
  def write(self, oprot):
9951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9953 
      return
9954 
    oprot.writeStructBegin('getComingSoonCount_args')
9955 
    oprot.writeFieldStop()
9956 
    oprot.writeStructEnd()
9957 
 
9958 
  def validate(self):
9959 
    return
9960 
 
9961 
 
9962 
  def __repr__(self):
9963 
    L = ['%s=%r' % (key, value)
9964 
      for key, value in self.__dict__.iteritems()]
9965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9966 
 
9967 
  def __eq__(self, other):
9968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9969 
 
9970 
  def __ne__(self, other):
9971 
    return not (self == other)
9972 
 
9973 
class getComingSoonCount_result:
9974 
  """
9975 
  Attributes:
9976 
   - success
9977 
   - cex
9978 
  """
9979 
 
9980 
  thrift_spec = (
9981 
    (0, TType.I64, 'success', None, None, ), # 0
9982 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9983 
  )
9984 
 
9985 
  def __init__(self, success=None, cex=None,):
9986 
    self.success = success
9987 
    self.cex = cex
9988 
 
9989 
  def read(self, iprot):
9990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9992 
      return
9993 
    iprot.readStructBegin()
9994 
    while True:
9995 
      (fname, ftype, fid) = iprot.readFieldBegin()
9996 
      if ftype == TType.STOP:
9997 
        break
9998 
      if fid == 0:
9999 
        if ftype == TType.I64:
10000 
          self.success = iprot.readI64();
10001 
        else:
10002 
          iprot.skip(ftype)
10003 
      elif fid == 1:
10004 
        if ftype == TType.STRUCT:
10005 
          self.cex = CatalogServiceException()
10006 
          self.cex.read(iprot)
10007 
        else:
10008 
          iprot.skip(ftype)
10009 
      else:
10010 
        iprot.skip(ftype)
10011 
      iprot.readFieldEnd()
10012 
    iprot.readStructEnd()
10013 
 
10014 
  def write(self, oprot):
10015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10017 
      return
10018 
    oprot.writeStructBegin('getComingSoonCount_result')
10019 
    if self.success is not None:
10020 
      oprot.writeFieldBegin('success', TType.I64, 0)
10021 
      oprot.writeI64(self.success)
10022 
      oprot.writeFieldEnd()
10023 
    if self.cex is not None:
10024 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10025 
      self.cex.write(oprot)
10026 
      oprot.writeFieldEnd()
10027 
    oprot.writeFieldStop()
10028 
    oprot.writeStructEnd()
10029 
 
10030 
  def validate(self):
10031 
    return
10032 
 
10033 
 
10034 
  def __repr__(self):
10035 
    L = ['%s=%r' % (key, value)
10036 
      for key, value in self.__dict__.iteritems()]
10037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10038 
 
10039 
  def __eq__(self, other):
10040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10041 
 
10042 
  def __ne__(self, other):
10043 
    return not (self == other)
10044 
 
10045 
class getLatestArrivals_args:
10046 
 
10047 
  thrift_spec = (
10048 
  )
10049 
 
10050 
  def read(self, iprot):
10051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10053 
      return
10054 
    iprot.readStructBegin()
10055 
    while True:
10056 
      (fname, ftype, fid) = iprot.readFieldBegin()
10057 
      if ftype == TType.STOP:
10058 
        break
10059 
      else:
10060 
        iprot.skip(ftype)
10061 
      iprot.readFieldEnd()
10062 
    iprot.readStructEnd()
10063 
 
10064 
  def write(self, oprot):
10065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10067 
      return
10068 
    oprot.writeStructBegin('getLatestArrivals_args')
10069 
    oprot.writeFieldStop()
10070 
    oprot.writeStructEnd()
10071 
 
10072 
  def validate(self):
10073 
    return
10074 
 
10075 
 
10076 
  def __repr__(self):
10077 
    L = ['%s=%r' % (key, value)
10078 
      for key, value in self.__dict__.iteritems()]
10079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10080 
 
10081 
  def __eq__(self, other):
10082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10083 
 
10084 
  def __ne__(self, other):
10085 
    return not (self == other)
10086 
 
10087 
class getLatestArrivals_result:
10088 
  """
10089 
  Attributes:
10090 
   - success
10091 
   - isex
10092 
  """
10093 
 
10094 
  thrift_spec = (
10095 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10096 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10097 
  )
10098 
 
10099 
  def __init__(self, success=None, isex=None,):
10100 
    self.success = success
10101 
    self.isex = isex
10102 
 
10103 
  def read(self, iprot):
10104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10106 
      return
10107 
    iprot.readStructBegin()
10108 
    while True:
10109 
      (fname, ftype, fid) = iprot.readFieldBegin()
10110 
      if ftype == TType.STOP:
10111 
        break
10112 
      if fid == 0:
10113 
        if ftype == TType.LIST:
10114 
          self.success = []
8590 kshitij.so 10115 
          (_etype133, _size130) = iprot.readListBegin()
10116 
          for _i134 in xrange(_size130):
10117 
            _elem135 = Item()
10118 
            _elem135.read(iprot)
10119 
            self.success.append(_elem135)
5944 mandeep.dh 10120 
          iprot.readListEnd()
10121 
        else:
10122 
          iprot.skip(ftype)
10123 
      elif fid == 1:
10124 
        if ftype == TType.STRUCT:
10125 
          self.isex = CatalogServiceException()
10126 
          self.isex.read(iprot)
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      else:
10130 
        iprot.skip(ftype)
10131 
      iprot.readFieldEnd()
10132 
    iprot.readStructEnd()
10133 
 
10134 
  def write(self, oprot):
10135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10137 
      return
10138 
    oprot.writeStructBegin('getLatestArrivals_result')
10139 
    if self.success is not None:
10140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10142 
      for iter136 in self.success:
10143 
        iter136.write(oprot)
5944 mandeep.dh 10144 
      oprot.writeListEnd()
10145 
      oprot.writeFieldEnd()
10146 
    if self.isex is not None:
10147 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
10148 
      self.isex.write(oprot)
10149 
      oprot.writeFieldEnd()
10150 
    oprot.writeFieldStop()
10151 
    oprot.writeStructEnd()
10152 
 
10153 
  def validate(self):
10154 
    return
10155 
 
10156 
 
10157 
  def __repr__(self):
10158 
    L = ['%s=%r' % (key, value)
10159 
      for key, value in self.__dict__.iteritems()]
10160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10161 
 
10162 
  def __eq__(self, other):
10163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10164 
 
10165 
  def __ne__(self, other):
10166 
    return not (self == other)
10167 
 
10168 
class getLatestArrivalsCatalogIds_args:
10169 
  """
10170 
  Attributes:
10171 
   - beginIndex
10172 
   - totalItems
10173 
   - brand
10174 
   - categories
10175 
  """
10176 
 
10177 
  thrift_spec = (
10178 
    None, # 0
10179 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
10180 
    (2, TType.I64, 'totalItems', None, None, ), # 2
10181 
    (3, TType.STRING, 'brand', None, None, ), # 3
10182 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
10183 
  )
10184 
 
10185 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
10186 
    self.beginIndex = beginIndex
10187 
    self.totalItems = totalItems
10188 
    self.brand = brand
10189 
    self.categories = categories
10190 
 
10191 
  def read(self, iprot):
10192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10194 
      return
10195 
    iprot.readStructBegin()
10196 
    while True:
10197 
      (fname, ftype, fid) = iprot.readFieldBegin()
10198 
      if ftype == TType.STOP:
10199 
        break
10200 
      if fid == 1:
10201 
        if ftype == TType.I64:
10202 
          self.beginIndex = iprot.readI64();
10203 
        else:
10204 
          iprot.skip(ftype)
10205 
      elif fid == 2:
10206 
        if ftype == TType.I64:
10207 
          self.totalItems = iprot.readI64();
10208 
        else:
10209 
          iprot.skip(ftype)
10210 
      elif fid == 3:
10211 
        if ftype == TType.STRING:
10212 
          self.brand = iprot.readString();
10213 
        else:
10214 
          iprot.skip(ftype)
10215 
      elif fid == 4:
10216 
        if ftype == TType.LIST:
10217 
          self.categories = []
8590 kshitij.so 10218 
          (_etype140, _size137) = iprot.readListBegin()
10219 
          for _i141 in xrange(_size137):
10220 
            _elem142 = iprot.readI64();
10221 
            self.categories.append(_elem142)
5944 mandeep.dh 10222 
          iprot.readListEnd()
10223 
        else:
10224 
          iprot.skip(ftype)
10225 
      else:
10226 
        iprot.skip(ftype)
10227 
      iprot.readFieldEnd()
10228 
    iprot.readStructEnd()
10229 
 
10230 
  def write(self, oprot):
10231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10233 
      return
10234 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
10235 
    if self.beginIndex is not None:
10236 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
10237 
      oprot.writeI64(self.beginIndex)
10238 
      oprot.writeFieldEnd()
10239 
    if self.totalItems is not None:
10240 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
10241 
      oprot.writeI64(self.totalItems)
10242 
      oprot.writeFieldEnd()
10243 
    if self.brand is not None:
10244 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
10245 
      oprot.writeString(self.brand)
10246 
      oprot.writeFieldEnd()
10247 
    if self.categories is not None:
10248 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
10249 
      oprot.writeListBegin(TType.I64, len(self.categories))
8590 kshitij.so 10250 
      for iter143 in self.categories:
10251 
        oprot.writeI64(iter143)
5944 mandeep.dh 10252 
      oprot.writeListEnd()
10253 
      oprot.writeFieldEnd()
10254 
    oprot.writeFieldStop()
10255 
    oprot.writeStructEnd()
10256 
 
10257 
  def validate(self):
10258 
    return
10259 
 
10260 
 
10261 
  def __repr__(self):
10262 
    L = ['%s=%r' % (key, value)
10263 
      for key, value in self.__dict__.iteritems()]
10264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10265 
 
10266 
  def __eq__(self, other):
10267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10268 
 
10269 
  def __ne__(self, other):
10270 
    return not (self == other)
10271 
 
10272 
class getLatestArrivalsCatalogIds_result:
10273 
  """
10274 
  Attributes:
10275 
   - success
10276 
   - cex
10277 
  """
10278 
 
10279 
  thrift_spec = (
10280 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10281 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10282 
  )
10283 
 
10284 
  def __init__(self, success=None, cex=None,):
10285 
    self.success = success
10286 
    self.cex = cex
10287 
 
10288 
  def read(self, iprot):
10289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10291 
      return
10292 
    iprot.readStructBegin()
10293 
    while True:
10294 
      (fname, ftype, fid) = iprot.readFieldBegin()
10295 
      if ftype == TType.STOP:
10296 
        break
10297 
      if fid == 0:
10298 
        if ftype == TType.LIST:
10299 
          self.success = []
8590 kshitij.so 10300 
          (_etype147, _size144) = iprot.readListBegin()
10301 
          for _i148 in xrange(_size144):
10302 
            _elem149 = iprot.readI64();
10303 
            self.success.append(_elem149)
5944 mandeep.dh 10304 
          iprot.readListEnd()
10305 
        else:
10306 
          iprot.skip(ftype)
10307 
      elif fid == 1:
10308 
        if ftype == TType.STRUCT:
10309 
          self.cex = CatalogServiceException()
10310 
          self.cex.read(iprot)
10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      else:
10314 
        iprot.skip(ftype)
10315 
      iprot.readFieldEnd()
10316 
    iprot.readStructEnd()
10317 
 
10318 
  def write(self, oprot):
10319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10321 
      return
10322 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
10323 
    if self.success is not None:
10324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10325 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 10326 
      for iter150 in self.success:
10327 
        oprot.writeI64(iter150)
5944 mandeep.dh 10328 
      oprot.writeListEnd()
10329 
      oprot.writeFieldEnd()
10330 
    if self.cex is not None:
10331 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10332 
      self.cex.write(oprot)
10333 
      oprot.writeFieldEnd()
10334 
    oprot.writeFieldStop()
10335 
    oprot.writeStructEnd()
10336 
 
10337 
  def validate(self):
10338 
    return
10339 
 
10340 
 
10341 
  def __repr__(self):
10342 
    L = ['%s=%r' % (key, value)
10343 
      for key, value in self.__dict__.iteritems()]
10344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10345 
 
10346 
  def __eq__(self, other):
10347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10348 
 
10349 
  def __ne__(self, other):
10350 
    return not (self == other)
10351 
 
10352 
class getLatestArrivalsCount_args:
10353 
 
10354 
  thrift_spec = (
10355 
  )
10356 
 
10357 
  def read(self, iprot):
10358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10360 
      return
10361 
    iprot.readStructBegin()
10362 
    while True:
10363 
      (fname, ftype, fid) = iprot.readFieldBegin()
10364 
      if ftype == TType.STOP:
10365 
        break
10366 
      else:
10367 
        iprot.skip(ftype)
10368 
      iprot.readFieldEnd()
10369 
    iprot.readStructEnd()
10370 
 
10371 
  def write(self, oprot):
10372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10374 
      return
10375 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
10376 
    oprot.writeFieldStop()
10377 
    oprot.writeStructEnd()
10378 
 
10379 
  def validate(self):
10380 
    return
10381 
 
10382 
 
10383 
  def __repr__(self):
10384 
    L = ['%s=%r' % (key, value)
10385 
      for key, value in self.__dict__.iteritems()]
10386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10387 
 
10388 
  def __eq__(self, other):
10389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10390 
 
10391 
  def __ne__(self, other):
10392 
    return not (self == other)
10393 
 
10394 
class getLatestArrivalsCount_result:
10395 
  """
10396 
  Attributes:
10397 
   - success
10398 
   - cex
10399 
  """
10400 
 
10401 
  thrift_spec = (
10402 
    (0, TType.I64, 'success', None, None, ), # 0
10403 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
10404 
  )
10405 
 
10406 
  def __init__(self, success=None, cex=None,):
10407 
    self.success = success
10408 
    self.cex = cex
10409 
 
10410 
  def read(self, iprot):
10411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10413 
      return
10414 
    iprot.readStructBegin()
10415 
    while True:
10416 
      (fname, ftype, fid) = iprot.readFieldBegin()
10417 
      if ftype == TType.STOP:
10418 
        break
10419 
      if fid == 0:
10420 
        if ftype == TType.I64:
10421 
          self.success = iprot.readI64();
10422 
        else:
10423 
          iprot.skip(ftype)
10424 
      elif fid == 1:
10425 
        if ftype == TType.STRUCT:
10426 
          self.cex = CatalogServiceException()
10427 
          self.cex.read(iprot)
10428 
        else:
10429 
          iprot.skip(ftype)
10430 
      else:
10431 
        iprot.skip(ftype)
10432 
      iprot.readFieldEnd()
10433 
    iprot.readStructEnd()
10434 
 
10435 
  def write(self, oprot):
10436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10438 
      return
10439 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
10440 
    if self.success is not None:
10441 
      oprot.writeFieldBegin('success', TType.I64, 0)
10442 
      oprot.writeI64(self.success)
10443 
      oprot.writeFieldEnd()
10444 
    if self.cex is not None:
10445 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
10446 
      self.cex.write(oprot)
10447 
      oprot.writeFieldEnd()
10448 
    oprot.writeFieldStop()
10449 
    oprot.writeStructEnd()
10450 
 
10451 
  def validate(self):
10452 
    return
10453 
 
10454 
 
10455 
  def __repr__(self):
10456 
    L = ['%s=%r' % (key, value)
10457 
      for key, value in self.__dict__.iteritems()]
10458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10459 
 
10460 
  def __eq__(self, other):
10461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10462 
 
10463 
  def __ne__(self, other):
10464 
    return not (self == other)
10465 
 
10466 
class generateNewEntityID_args:
10467 
 
10468 
  thrift_spec = (
10469 
  )
10470 
 
10471 
  def read(self, iprot):
10472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10474 
      return
10475 
    iprot.readStructBegin()
10476 
    while True:
10477 
      (fname, ftype, fid) = iprot.readFieldBegin()
10478 
      if ftype == TType.STOP:
10479 
        break
10480 
      else:
10481 
        iprot.skip(ftype)
10482 
      iprot.readFieldEnd()
10483 
    iprot.readStructEnd()
10484 
 
10485 
  def write(self, oprot):
10486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10488 
      return
10489 
    oprot.writeStructBegin('generateNewEntityID_args')
10490 
    oprot.writeFieldStop()
10491 
    oprot.writeStructEnd()
10492 
 
10493 
  def validate(self):
10494 
    return
10495 
 
10496 
 
10497 
  def __repr__(self):
10498 
    L = ['%s=%r' % (key, value)
10499 
      for key, value in self.__dict__.iteritems()]
10500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10501 
 
10502 
  def __eq__(self, other):
10503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10504 
 
10505 
  def __ne__(self, other):
10506 
    return not (self == other)
10507 
 
10508 
class generateNewEntityID_result:
10509 
  """
10510 
  Attributes:
10511 
   - success
10512 
  """
10513 
 
10514 
  thrift_spec = (
10515 
    (0, TType.I64, 'success', None, None, ), # 0
10516 
  )
10517 
 
10518 
  def __init__(self, success=None,):
10519 
    self.success = success
10520 
 
10521 
  def read(self, iprot):
10522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10524 
      return
10525 
    iprot.readStructBegin()
10526 
    while True:
10527 
      (fname, ftype, fid) = iprot.readFieldBegin()
10528 
      if ftype == TType.STOP:
10529 
        break
10530 
      if fid == 0:
10531 
        if ftype == TType.I64:
10532 
          self.success = iprot.readI64();
10533 
        else:
10534 
          iprot.skip(ftype)
10535 
      else:
10536 
        iprot.skip(ftype)
10537 
      iprot.readFieldEnd()
10538 
    iprot.readStructEnd()
10539 
 
10540 
  def write(self, oprot):
10541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10543 
      return
10544 
    oprot.writeStructBegin('generateNewEntityID_result')
10545 
    if self.success is not None:
10546 
      oprot.writeFieldBegin('success', TType.I64, 0)
10547 
      oprot.writeI64(self.success)
10548 
      oprot.writeFieldEnd()
10549 
    oprot.writeFieldStop()
10550 
    oprot.writeStructEnd()
10551 
 
10552 
  def validate(self):
10553 
    return
10554 
 
10555 
 
10556 
  def __repr__(self):
10557 
    L = ['%s=%r' % (key, value)
10558 
      for key, value in self.__dict__.iteritems()]
10559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10560 
 
10561 
  def __eq__(self, other):
10562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10563 
 
10564 
  def __ne__(self, other):
10565 
    return not (self == other)
10566 
 
10567 
class addCategory_args:
10568 
  """
10569 
  Attributes:
10570 
   - category
10571 
  """
10572 
 
10573 
  thrift_spec = (
10574 
    None, # 0
10575 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
10576 
  )
10577 
 
10578 
  def __init__(self, category=None,):
10579 
    self.category = category
10580 
 
10581 
  def read(self, iprot):
10582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10584 
      return
10585 
    iprot.readStructBegin()
10586 
    while True:
10587 
      (fname, ftype, fid) = iprot.readFieldBegin()
10588 
      if ftype == TType.STOP:
10589 
        break
10590 
      if fid == 1:
10591 
        if ftype == TType.STRUCT:
10592 
          self.category = Category()
10593 
          self.category.read(iprot)
10594 
        else:
10595 
          iprot.skip(ftype)
10596 
      else:
10597 
        iprot.skip(ftype)
10598 
      iprot.readFieldEnd()
10599 
    iprot.readStructEnd()
10600 
 
10601 
  def write(self, oprot):
10602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10604 
      return
10605 
    oprot.writeStructBegin('addCategory_args')
10606 
    if self.category is not None:
10607 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
10608 
      self.category.write(oprot)
10609 
      oprot.writeFieldEnd()
10610 
    oprot.writeFieldStop()
10611 
    oprot.writeStructEnd()
10612 
 
10613 
  def validate(self):
10614 
    return
10615 
 
10616 
 
10617 
  def __repr__(self):
10618 
    L = ['%s=%r' % (key, value)
10619 
      for key, value in self.__dict__.iteritems()]
10620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10621 
 
10622 
  def __eq__(self, other):
10623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10624 
 
10625 
  def __ne__(self, other):
10626 
    return not (self == other)
10627 
 
10628 
class addCategory_result:
10629 
  """
10630 
  Attributes:
10631 
   - success
10632 
  """
10633 
 
10634 
  thrift_spec = (
10635 
    (0, TType.BOOL, 'success', None, None, ), # 0
10636 
  )
10637 
 
10638 
  def __init__(self, success=None,):
10639 
    self.success = success
10640 
 
10641 
  def read(self, iprot):
10642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10644 
      return
10645 
    iprot.readStructBegin()
10646 
    while True:
10647 
      (fname, ftype, fid) = iprot.readFieldBegin()
10648 
      if ftype == TType.STOP:
10649 
        break
10650 
      if fid == 0:
10651 
        if ftype == TType.BOOL:
10652 
          self.success = iprot.readBool();
10653 
        else:
10654 
          iprot.skip(ftype)
10655 
      else:
10656 
        iprot.skip(ftype)
10657 
      iprot.readFieldEnd()
10658 
    iprot.readStructEnd()
10659 
 
10660 
  def write(self, oprot):
10661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10663 
      return
10664 
    oprot.writeStructBegin('addCategory_result')
10665 
    if self.success is not None:
10666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10667 
      oprot.writeBool(self.success)
10668 
      oprot.writeFieldEnd()
10669 
    oprot.writeFieldStop()
10670 
    oprot.writeStructEnd()
10671 
 
10672 
  def validate(self):
10673 
    return
10674 
 
10675 
 
10676 
  def __repr__(self):
10677 
    L = ['%s=%r' % (key, value)
10678 
      for key, value in self.__dict__.iteritems()]
10679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10680 
 
10681 
  def __eq__(self, other):
10682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10683 
 
10684 
  def __ne__(self, other):
10685 
    return not (self == other)
10686 
 
10687 
class getCategory_args:
10688 
  """
10689 
  Attributes:
10690 
   - id
10691 
  """
10692 
 
10693 
  thrift_spec = (
10694 
    None, # 0
10695 
    (1, TType.I64, 'id', None, None, ), # 1
10696 
  )
10697 
 
10698 
  def __init__(self, id=None,):
10699 
    self.id = id
10700 
 
10701 
  def read(self, iprot):
10702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10704 
      return
10705 
    iprot.readStructBegin()
10706 
    while True:
10707 
      (fname, ftype, fid) = iprot.readFieldBegin()
10708 
      if ftype == TType.STOP:
10709 
        break
10710 
      if fid == 1:
10711 
        if ftype == TType.I64:
10712 
          self.id = iprot.readI64();
10713 
        else:
10714 
          iprot.skip(ftype)
10715 
      else:
10716 
        iprot.skip(ftype)
10717 
      iprot.readFieldEnd()
10718 
    iprot.readStructEnd()
10719 
 
10720 
  def write(self, oprot):
10721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10723 
      return
10724 
    oprot.writeStructBegin('getCategory_args')
10725 
    if self.id is not None:
10726 
      oprot.writeFieldBegin('id', TType.I64, 1)
10727 
      oprot.writeI64(self.id)
10728 
      oprot.writeFieldEnd()
10729 
    oprot.writeFieldStop()
10730 
    oprot.writeStructEnd()
10731 
 
10732 
  def validate(self):
10733 
    return
10734 
 
10735 
 
10736 
  def __repr__(self):
10737 
    L = ['%s=%r' % (key, value)
10738 
      for key, value in self.__dict__.iteritems()]
10739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10740 
 
10741 
  def __eq__(self, other):
10742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10743 
 
10744 
  def __ne__(self, other):
10745 
    return not (self == other)
10746 
 
10747 
class getCategory_result:
10748 
  """
10749 
  Attributes:
10750 
   - success
10751 
  """
10752 
 
10753 
  thrift_spec = (
10754 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
10755 
  )
10756 
 
10757 
  def __init__(self, success=None,):
10758 
    self.success = success
10759 
 
10760 
  def read(self, iprot):
10761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10763 
      return
10764 
    iprot.readStructBegin()
10765 
    while True:
10766 
      (fname, ftype, fid) = iprot.readFieldBegin()
10767 
      if ftype == TType.STOP:
10768 
        break
10769 
      if fid == 0:
10770 
        if ftype == TType.STRUCT:
10771 
          self.success = Category()
10772 
          self.success.read(iprot)
10773 
        else:
10774 
          iprot.skip(ftype)
10775 
      else:
10776 
        iprot.skip(ftype)
10777 
      iprot.readFieldEnd()
10778 
    iprot.readStructEnd()
10779 
 
10780 
  def write(self, oprot):
10781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10783 
      return
10784 
    oprot.writeStructBegin('getCategory_result')
10785 
    if self.success is not None:
10786 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10787 
      self.success.write(oprot)
10788 
      oprot.writeFieldEnd()
10789 
    oprot.writeFieldStop()
10790 
    oprot.writeStructEnd()
10791 
 
10792 
  def validate(self):
10793 
    return
10794 
 
10795 
 
10796 
  def __repr__(self):
10797 
    L = ['%s=%r' % (key, value)
10798 
      for key, value in self.__dict__.iteritems()]
10799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10800 
 
10801 
  def __eq__(self, other):
10802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10803 
 
10804 
  def __ne__(self, other):
10805 
    return not (self == other)
10806 
 
10807 
class getAllCategories_args:
10808 
 
10809 
  thrift_spec = (
10810 
  )
10811 
 
10812 
  def read(self, iprot):
10813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10815 
      return
10816 
    iprot.readStructBegin()
10817 
    while True:
10818 
      (fname, ftype, fid) = iprot.readFieldBegin()
10819 
      if ftype == TType.STOP:
10820 
        break
10821 
      else:
10822 
        iprot.skip(ftype)
10823 
      iprot.readFieldEnd()
10824 
    iprot.readStructEnd()
10825 
 
10826 
  def write(self, oprot):
10827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10829 
      return
10830 
    oprot.writeStructBegin('getAllCategories_args')
10831 
    oprot.writeFieldStop()
10832 
    oprot.writeStructEnd()
10833 
 
10834 
  def validate(self):
10835 
    return
10836 
 
10837 
 
10838 
  def __repr__(self):
10839 
    L = ['%s=%r' % (key, value)
10840 
      for key, value in self.__dict__.iteritems()]
10841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10842 
 
10843 
  def __eq__(self, other):
10844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10845 
 
10846 
  def __ne__(self, other):
10847 
    return not (self == other)
10848 
 
10849 
class getAllCategories_result:
10850 
  """
10851 
  Attributes:
10852 
   - success
10853 
  """
10854 
 
10855 
  thrift_spec = (
10856 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
10857 
  )
10858 
 
10859 
  def __init__(self, success=None,):
10860 
    self.success = success
10861 
 
10862 
  def read(self, iprot):
10863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10865 
      return
10866 
    iprot.readStructBegin()
10867 
    while True:
10868 
      (fname, ftype, fid) = iprot.readFieldBegin()
10869 
      if ftype == TType.STOP:
10870 
        break
10871 
      if fid == 0:
10872 
        if ftype == TType.LIST:
10873 
          self.success = []
8590 kshitij.so 10874 
          (_etype154, _size151) = iprot.readListBegin()
10875 
          for _i155 in xrange(_size151):
10876 
            _elem156 = Category()
10877 
            _elem156.read(iprot)
10878 
            self.success.append(_elem156)
5944 mandeep.dh 10879 
          iprot.readListEnd()
10880 
        else:
10881 
          iprot.skip(ftype)
10882 
      else:
10883 
        iprot.skip(ftype)
10884 
      iprot.readFieldEnd()
10885 
    iprot.readStructEnd()
10886 
 
10887 
  def write(self, oprot):
10888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10890 
      return
10891 
    oprot.writeStructBegin('getAllCategories_result')
10892 
    if self.success is not None:
10893 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10894 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 10895 
      for iter157 in self.success:
10896 
        iter157.write(oprot)
5944 mandeep.dh 10897 
      oprot.writeListEnd()
10898 
      oprot.writeFieldEnd()
10899 
    oprot.writeFieldStop()
10900 
    oprot.writeStructEnd()
10901 
 
10902 
  def validate(self):
10903 
    return
10904 
 
10905 
 
10906 
  def __repr__(self):
10907 
    L = ['%s=%r' % (key, value)
10908 
      for key, value in self.__dict__.iteritems()]
10909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10910 
 
10911 
  def __eq__(self, other):
10912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10913 
 
10914 
  def __ne__(self, other):
10915 
    return not (self == other)
10916 
 
10917 
class getAllSimilarItems_args:
10918 
  """
10919 
  Attributes:
10920 
   - itemId
10921 
  """
10922 
 
10923 
  thrift_spec = (
10924 
    None, # 0
10925 
    (1, TType.I64, 'itemId', None, None, ), # 1
10926 
  )
10927 
 
10928 
  def __init__(self, itemId=None,):
10929 
    self.itemId = itemId
10930 
 
10931 
  def read(self, iprot):
10932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10934 
      return
10935 
    iprot.readStructBegin()
10936 
    while True:
10937 
      (fname, ftype, fid) = iprot.readFieldBegin()
10938 
      if ftype == TType.STOP:
10939 
        break
10940 
      if fid == 1:
10941 
        if ftype == TType.I64:
10942 
          self.itemId = iprot.readI64();
10943 
        else:
10944 
          iprot.skip(ftype)
10945 
      else:
10946 
        iprot.skip(ftype)
10947 
      iprot.readFieldEnd()
10948 
    iprot.readStructEnd()
10949 
 
10950 
  def write(self, oprot):
10951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10953 
      return
10954 
    oprot.writeStructBegin('getAllSimilarItems_args')
10955 
    if self.itemId is not None:
10956 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10957 
      oprot.writeI64(self.itemId)
10958 
      oprot.writeFieldEnd()
10959 
    oprot.writeFieldStop()
10960 
    oprot.writeStructEnd()
10961 
 
10962 
  def validate(self):
10963 
    return
10964 
 
10965 
 
10966 
  def __repr__(self):
10967 
    L = ['%s=%r' % (key, value)
10968 
      for key, value in self.__dict__.iteritems()]
10969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10970 
 
10971 
  def __eq__(self, other):
10972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10973 
 
10974 
  def __ne__(self, other):
10975 
    return not (self == other)
10976 
 
10977 
class getAllSimilarItems_result:
10978 
  """
10979 
  Attributes:
10980 
   - success
10981 
  """
10982 
 
10983 
  thrift_spec = (
10984 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
10985 
  )
10986 
 
10987 
  def __init__(self, success=None,):
10988 
    self.success = success
10989 
 
10990 
  def read(self, iprot):
10991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10993 
      return
10994 
    iprot.readStructBegin()
10995 
    while True:
10996 
      (fname, ftype, fid) = iprot.readFieldBegin()
10997 
      if ftype == TType.STOP:
10998 
        break
10999 
      if fid == 0:
11000 
        if ftype == TType.LIST:
11001 
          self.success = []
8590 kshitij.so 11002 
          (_etype161, _size158) = iprot.readListBegin()
11003 
          for _i162 in xrange(_size158):
11004 
            _elem163 = Item()
11005 
            _elem163.read(iprot)
11006 
            self.success.append(_elem163)
5944 mandeep.dh 11007 
          iprot.readListEnd()
11008 
        else:
11009 
          iprot.skip(ftype)
11010 
      else:
11011 
        iprot.skip(ftype)
11012 
      iprot.readFieldEnd()
11013 
    iprot.readStructEnd()
11014 
 
11015 
  def write(self, oprot):
11016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11018 
      return
11019 
    oprot.writeStructBegin('getAllSimilarItems_result')
11020 
    if self.success is not None:
11021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 11023 
      for iter164 in self.success:
11024 
        iter164.write(oprot)
5944 mandeep.dh 11025 
      oprot.writeListEnd()
11026 
      oprot.writeFieldEnd()
11027 
    oprot.writeFieldStop()
11028 
    oprot.writeStructEnd()
11029 
 
11030 
  def validate(self):
11031 
    return
11032 
 
11033 
 
11034 
  def __repr__(self):
11035 
    L = ['%s=%r' % (key, value)
11036 
      for key, value in self.__dict__.iteritems()]
11037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11038 
 
11039 
  def __eq__(self, other):
11040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11041 
 
11042 
  def __ne__(self, other):
11043 
    return not (self == other)
11044 
 
11045 
class addSimilarItem_args:
11046 
  """
11047 
  Attributes:
11048 
   - itemId
11049 
   - catalogItemId
11050 
  """
11051 
 
11052 
  thrift_spec = (
11053 
    None, # 0
11054 
    (1, TType.I64, 'itemId', None, None, ), # 1
11055 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11056 
  )
11057 
 
11058 
  def __init__(self, itemId=None, catalogItemId=None,):
11059 
    self.itemId = itemId
11060 
    self.catalogItemId = catalogItemId
11061 
 
11062 
  def read(self, iprot):
11063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11065 
      return
11066 
    iprot.readStructBegin()
11067 
    while True:
11068 
      (fname, ftype, fid) = iprot.readFieldBegin()
11069 
      if ftype == TType.STOP:
11070 
        break
11071 
      if fid == 1:
11072 
        if ftype == TType.I64:
11073 
          self.itemId = iprot.readI64();
11074 
        else:
11075 
          iprot.skip(ftype)
11076 
      elif fid == 2:
11077 
        if ftype == TType.I64:
11078 
          self.catalogItemId = iprot.readI64();
11079 
        else:
11080 
          iprot.skip(ftype)
11081 
      else:
11082 
        iprot.skip(ftype)
11083 
      iprot.readFieldEnd()
11084 
    iprot.readStructEnd()
11085 
 
11086 
  def write(self, oprot):
11087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11089 
      return
11090 
    oprot.writeStructBegin('addSimilarItem_args')
11091 
    if self.itemId is not None:
11092 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11093 
      oprot.writeI64(self.itemId)
11094 
      oprot.writeFieldEnd()
11095 
    if self.catalogItemId is not None:
11096 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11097 
      oprot.writeI64(self.catalogItemId)
11098 
      oprot.writeFieldEnd()
11099 
    oprot.writeFieldStop()
11100 
    oprot.writeStructEnd()
11101 
 
11102 
  def validate(self):
11103 
    return
11104 
 
11105 
 
11106 
  def __repr__(self):
11107 
    L = ['%s=%r' % (key, value)
11108 
      for key, value in self.__dict__.iteritems()]
11109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11110 
 
11111 
  def __eq__(self, other):
11112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11113 
 
11114 
  def __ne__(self, other):
11115 
    return not (self == other)
11116 
 
11117 
class addSimilarItem_result:
11118 
  """
11119 
  Attributes:
11120 
   - success
11121 
   - cex
11122 
  """
11123 
 
11124 
  thrift_spec = (
11125 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
11126 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11127 
  )
11128 
 
11129 
  def __init__(self, success=None, cex=None,):
11130 
    self.success = success
11131 
    self.cex = cex
11132 
 
11133 
  def read(self, iprot):
11134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11136 
      return
11137 
    iprot.readStructBegin()
11138 
    while True:
11139 
      (fname, ftype, fid) = iprot.readFieldBegin()
11140 
      if ftype == TType.STOP:
11141 
        break
11142 
      if fid == 0:
11143 
        if ftype == TType.STRUCT:
11144 
          self.success = Item()
11145 
          self.success.read(iprot)
11146 
        else:
11147 
          iprot.skip(ftype)
11148 
      elif fid == 1:
11149 
        if ftype == TType.STRUCT:
11150 
          self.cex = CatalogServiceException()
11151 
          self.cex.read(iprot)
11152 
        else:
11153 
          iprot.skip(ftype)
11154 
      else:
11155 
        iprot.skip(ftype)
11156 
      iprot.readFieldEnd()
11157 
    iprot.readStructEnd()
11158 
 
11159 
  def write(self, oprot):
11160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11162 
      return
11163 
    oprot.writeStructBegin('addSimilarItem_result')
11164 
    if self.success is not None:
11165 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11166 
      self.success.write(oprot)
11167 
      oprot.writeFieldEnd()
11168 
    if self.cex is not None:
11169 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11170 
      self.cex.write(oprot)
11171 
      oprot.writeFieldEnd()
11172 
    oprot.writeFieldStop()
11173 
    oprot.writeStructEnd()
11174 
 
11175 
  def validate(self):
11176 
    return
11177 
 
11178 
 
11179 
  def __repr__(self):
11180 
    L = ['%s=%r' % (key, value)
11181 
      for key, value in self.__dict__.iteritems()]
11182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11183 
 
11184 
  def __eq__(self, other):
11185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11186 
 
11187 
  def __ne__(self, other):
11188 
    return not (self == other)
11189 
 
6512 kshitij.so 11190 
class addTag_args:
11191 
  """
11192 
  Attributes:
11193 
   - displayName
11194 
   - itemId
11195 
  """
11196 
 
11197 
  thrift_spec = (
11198 
    None, # 0
11199 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11200 
    (2, TType.I64, 'itemId', None, None, ), # 2
11201 
  )
11202 
 
11203 
  def __init__(self, displayName=None, itemId=None,):
11204 
    self.displayName = displayName
11205 
    self.itemId = itemId
11206 
 
11207 
  def read(self, iprot):
11208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11210 
      return
11211 
    iprot.readStructBegin()
11212 
    while True:
11213 
      (fname, ftype, fid) = iprot.readFieldBegin()
11214 
      if ftype == TType.STOP:
11215 
        break
11216 
      if fid == 1:
11217 
        if ftype == TType.STRING:
11218 
          self.displayName = iprot.readString();
11219 
        else:
11220 
          iprot.skip(ftype)
11221 
      elif fid == 2:
11222 
        if ftype == TType.I64:
11223 
          self.itemId = iprot.readI64();
11224 
        else:
11225 
          iprot.skip(ftype)
11226 
      else:
11227 
        iprot.skip(ftype)
11228 
      iprot.readFieldEnd()
11229 
    iprot.readStructEnd()
11230 
 
11231 
  def write(self, oprot):
11232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11234 
      return
11235 
    oprot.writeStructBegin('addTag_args')
11236 
    if self.displayName is not None:
11237 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11238 
      oprot.writeString(self.displayName)
11239 
      oprot.writeFieldEnd()
11240 
    if self.itemId is not None:
11241 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11242 
      oprot.writeI64(self.itemId)
11243 
      oprot.writeFieldEnd()
11244 
    oprot.writeFieldStop()
11245 
    oprot.writeStructEnd()
11246 
 
11247 
  def validate(self):
11248 
    return
11249 
 
11250 
 
11251 
  def __repr__(self):
11252 
    L = ['%s=%r' % (key, value)
11253 
      for key, value in self.__dict__.iteritems()]
11254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11255 
 
11256 
  def __eq__(self, other):
11257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11258 
 
11259 
  def __ne__(self, other):
11260 
    return not (self == other)
11261 
 
11262 
class addTag_result:
11263 
  """
11264 
  Attributes:
11265 
   - success
11266 
  """
11267 
 
11268 
  thrift_spec = (
11269 
    (0, TType.BOOL, 'success', None, None, ), # 0
11270 
  )
11271 
 
11272 
  def __init__(self, success=None,):
11273 
    self.success = success
11274 
 
11275 
  def read(self, iprot):
11276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11278 
      return
11279 
    iprot.readStructBegin()
11280 
    while True:
11281 
      (fname, ftype, fid) = iprot.readFieldBegin()
11282 
      if ftype == TType.STOP:
11283 
        break
11284 
      if fid == 0:
11285 
        if ftype == TType.BOOL:
11286 
          self.success = iprot.readBool();
11287 
        else:
11288 
          iprot.skip(ftype)
11289 
      else:
11290 
        iprot.skip(ftype)
11291 
      iprot.readFieldEnd()
11292 
    iprot.readStructEnd()
11293 
 
11294 
  def write(self, oprot):
11295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11297 
      return
11298 
    oprot.writeStructBegin('addTag_result')
11299 
    if self.success is not None:
11300 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11301 
      oprot.writeBool(self.success)
11302 
      oprot.writeFieldEnd()
11303 
    oprot.writeFieldStop()
11304 
    oprot.writeStructEnd()
11305 
 
11306 
  def validate(self):
11307 
    return
11308 
 
11309 
 
11310 
  def __repr__(self):
11311 
    L = ['%s=%r' % (key, value)
11312 
      for key, value in self.__dict__.iteritems()]
11313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11314 
 
11315 
  def __eq__(self, other):
11316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11317 
 
11318 
  def __ne__(self, other):
11319 
    return not (self == other)
11320 
 
11321 
class deleteEntityTag_args:
11322 
  """
11323 
  Attributes:
11324 
   - displayName
11325 
   - itemId
11326 
  """
11327 
 
11328 
  thrift_spec = (
11329 
    None, # 0
11330 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11331 
    (2, TType.I64, 'itemId', None, None, ), # 2
11332 
  )
11333 
 
11334 
  def __init__(self, displayName=None, itemId=None,):
11335 
    self.displayName = displayName
11336 
    self.itemId = itemId
11337 
 
11338 
  def read(self, iprot):
11339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11341 
      return
11342 
    iprot.readStructBegin()
11343 
    while True:
11344 
      (fname, ftype, fid) = iprot.readFieldBegin()
11345 
      if ftype == TType.STOP:
11346 
        break
11347 
      if fid == 1:
11348 
        if ftype == TType.STRING:
11349 
          self.displayName = iprot.readString();
11350 
        else:
11351 
          iprot.skip(ftype)
11352 
      elif fid == 2:
11353 
        if ftype == TType.I64:
11354 
          self.itemId = iprot.readI64();
11355 
        else:
11356 
          iprot.skip(ftype)
11357 
      else:
11358 
        iprot.skip(ftype)
11359 
      iprot.readFieldEnd()
11360 
    iprot.readStructEnd()
11361 
 
11362 
  def write(self, oprot):
11363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11365 
      return
11366 
    oprot.writeStructBegin('deleteEntityTag_args')
11367 
    if self.displayName is not None:
11368 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11369 
      oprot.writeString(self.displayName)
11370 
      oprot.writeFieldEnd()
11371 
    if self.itemId is not None:
11372 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11373 
      oprot.writeI64(self.itemId)
11374 
      oprot.writeFieldEnd()
11375 
    oprot.writeFieldStop()
11376 
    oprot.writeStructEnd()
11377 
 
11378 
  def validate(self):
11379 
    return
11380 
 
11381 
 
11382 
  def __repr__(self):
11383 
    L = ['%s=%r' % (key, value)
11384 
      for key, value in self.__dict__.iteritems()]
11385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11386 
 
11387 
  def __eq__(self, other):
11388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11389 
 
11390 
  def __ne__(self, other):
11391 
    return not (self == other)
11392 
 
11393 
class deleteEntityTag_result:
11394 
  """
11395 
  Attributes:
11396 
   - success
11397 
  """
11398 
 
11399 
  thrift_spec = (
11400 
    (0, TType.BOOL, 'success', None, None, ), # 0
11401 
  )
11402 
 
11403 
  def __init__(self, success=None,):
11404 
    self.success = success
11405 
 
11406 
  def read(self, iprot):
11407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11409 
      return
11410 
    iprot.readStructBegin()
11411 
    while True:
11412 
      (fname, ftype, fid) = iprot.readFieldBegin()
11413 
      if ftype == TType.STOP:
11414 
        break
11415 
      if fid == 0:
11416 
        if ftype == TType.BOOL:
11417 
          self.success = iprot.readBool();
11418 
        else:
11419 
          iprot.skip(ftype)
11420 
      else:
11421 
        iprot.skip(ftype)
11422 
      iprot.readFieldEnd()
11423 
    iprot.readStructEnd()
11424 
 
11425 
  def write(self, oprot):
11426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11428 
      return
11429 
    oprot.writeStructBegin('deleteEntityTag_result')
11430 
    if self.success is not None:
11431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11432 
      oprot.writeBool(self.success)
11433 
      oprot.writeFieldEnd()
11434 
    oprot.writeFieldStop()
11435 
    oprot.writeStructEnd()
11436 
 
11437 
  def validate(self):
11438 
    return
11439 
 
11440 
 
11441 
  def __repr__(self):
11442 
    L = ['%s=%r' % (key, value)
11443 
      for key, value in self.__dict__.iteritems()]
11444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11445 
 
11446 
  def __eq__(self, other):
11447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11448 
 
11449 
  def __ne__(self, other):
11450 
    return not (self == other)
11451 
 
11452 
class deleteTag_args:
11453 
  """
11454 
  Attributes:
11455 
   - displayName
11456 
  """
11457 
 
11458 
  thrift_spec = (
11459 
    None, # 0
11460 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11461 
  )
11462 
 
11463 
  def __init__(self, displayName=None,):
11464 
    self.displayName = displayName
11465 
 
11466 
  def read(self, iprot):
11467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11469 
      return
11470 
    iprot.readStructBegin()
11471 
    while True:
11472 
      (fname, ftype, fid) = iprot.readFieldBegin()
11473 
      if ftype == TType.STOP:
11474 
        break
11475 
      if fid == 1:
11476 
        if ftype == TType.STRING:
11477 
          self.displayName = iprot.readString();
11478 
        else:
11479 
          iprot.skip(ftype)
11480 
      else:
11481 
        iprot.skip(ftype)
11482 
      iprot.readFieldEnd()
11483 
    iprot.readStructEnd()
11484 
 
11485 
  def write(self, oprot):
11486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11488 
      return
11489 
    oprot.writeStructBegin('deleteTag_args')
11490 
    if self.displayName is not None:
11491 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11492 
      oprot.writeString(self.displayName)
11493 
      oprot.writeFieldEnd()
11494 
    oprot.writeFieldStop()
11495 
    oprot.writeStructEnd()
11496 
 
11497 
  def validate(self):
11498 
    return
11499 
 
11500 
 
11501 
  def __repr__(self):
11502 
    L = ['%s=%r' % (key, value)
11503 
      for key, value in self.__dict__.iteritems()]
11504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11505 
 
11506 
  def __eq__(self, other):
11507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11508 
 
11509 
  def __ne__(self, other):
11510 
    return not (self == other)
11511 
 
11512 
class deleteTag_result:
11513 
  """
11514 
  Attributes:
11515 
   - success
11516 
  """
11517 
 
11518 
  thrift_spec = (
11519 
    (0, TType.BOOL, 'success', None, None, ), # 0
11520 
  )
11521 
 
11522 
  def __init__(self, success=None,):
11523 
    self.success = success
11524 
 
11525 
  def read(self, iprot):
11526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11528 
      return
11529 
    iprot.readStructBegin()
11530 
    while True:
11531 
      (fname, ftype, fid) = iprot.readFieldBegin()
11532 
      if ftype == TType.STOP:
11533 
        break
11534 
      if fid == 0:
11535 
        if ftype == TType.BOOL:
11536 
          self.success = iprot.readBool();
11537 
        else:
11538 
          iprot.skip(ftype)
11539 
      else:
11540 
        iprot.skip(ftype)
11541 
      iprot.readFieldEnd()
11542 
    iprot.readStructEnd()
11543 
 
11544 
  def write(self, oprot):
11545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11547 
      return
11548 
    oprot.writeStructBegin('deleteTag_result')
11549 
    if self.success is not None:
11550 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11551 
      oprot.writeBool(self.success)
11552 
      oprot.writeFieldEnd()
11553 
    oprot.writeFieldStop()
11554 
    oprot.writeStructEnd()
11555 
 
11556 
  def validate(self):
11557 
    return
11558 
 
11559 
 
11560 
  def __repr__(self):
11561 
    L = ['%s=%r' % (key, value)
11562 
      for key, value in self.__dict__.iteritems()]
11563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11564 
 
11565 
  def __eq__(self, other):
11566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11567 
 
11568 
  def __ne__(self, other):
11569 
    return not (self == other)
11570 
 
11571 
class getAllTags_args:
11572 
 
11573 
  thrift_spec = (
11574 
  )
11575 
 
11576 
  def read(self, iprot):
11577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11579 
      return
11580 
    iprot.readStructBegin()
11581 
    while True:
11582 
      (fname, ftype, fid) = iprot.readFieldBegin()
11583 
      if ftype == TType.STOP:
11584 
        break
11585 
      else:
11586 
        iprot.skip(ftype)
11587 
      iprot.readFieldEnd()
11588 
    iprot.readStructEnd()
11589 
 
11590 
  def write(self, oprot):
11591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11593 
      return
11594 
    oprot.writeStructBegin('getAllTags_args')
11595 
    oprot.writeFieldStop()
11596 
    oprot.writeStructEnd()
11597 
 
11598 
  def validate(self):
11599 
    return
11600 
 
11601 
 
11602 
  def __repr__(self):
11603 
    L = ['%s=%r' % (key, value)
11604 
      for key, value in self.__dict__.iteritems()]
11605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11606 
 
11607 
  def __eq__(self, other):
11608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11609 
 
11610 
  def __ne__(self, other):
11611 
    return not (self == other)
11612 
 
11613 
class getAllTags_result:
11614 
  """
11615 
  Attributes:
11616 
   - success
11617 
  """
11618 
 
11619 
  thrift_spec = (
11620 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
11621 
  )
11622 
 
11623 
  def __init__(self, success=None,):
11624 
    self.success = success
11625 
 
11626 
  def read(self, iprot):
11627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11629 
      return
11630 
    iprot.readStructBegin()
11631 
    while True:
11632 
      (fname, ftype, fid) = iprot.readFieldBegin()
11633 
      if ftype == TType.STOP:
11634 
        break
11635 
      if fid == 0:
11636 
        if ftype == TType.LIST:
11637 
          self.success = []
8590 kshitij.so 11638 
          (_etype168, _size165) = iprot.readListBegin()
11639 
          for _i169 in xrange(_size165):
11640 
            _elem170 = iprot.readString();
11641 
            self.success.append(_elem170)
6512 kshitij.so 11642 
          iprot.readListEnd()
11643 
        else:
11644 
          iprot.skip(ftype)
11645 
      else:
11646 
        iprot.skip(ftype)
11647 
      iprot.readFieldEnd()
11648 
    iprot.readStructEnd()
11649 
 
11650 
  def write(self, oprot):
11651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11653 
      return
11654 
    oprot.writeStructBegin('getAllTags_result')
11655 
    if self.success is not None:
11656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11657 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 11658 
      for iter171 in self.success:
11659 
        oprot.writeString(iter171)
6512 kshitij.so 11660 
      oprot.writeListEnd()
11661 
      oprot.writeFieldEnd()
11662 
    oprot.writeFieldStop()
11663 
    oprot.writeStructEnd()
11664 
 
11665 
  def validate(self):
11666 
    return
11667 
 
11668 
 
11669 
  def __repr__(self):
11670 
    L = ['%s=%r' % (key, value)
11671 
      for key, value in self.__dict__.iteritems()]
11672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11673 
 
11674 
  def __eq__(self, other):
11675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11676 
 
11677 
  def __ne__(self, other):
11678 
    return not (self == other)
11679 
 
11680 
class getAllEntitiesByTagName_args:
11681 
  """
11682 
  Attributes:
11683 
   - displayName
11684 
  """
11685 
 
11686 
  thrift_spec = (
11687 
    None, # 0
11688 
    (1, TType.STRING, 'displayName', None, None, ), # 1
11689 
  )
11690 
 
11691 
  def __init__(self, displayName=None,):
11692 
    self.displayName = displayName
11693 
 
11694 
  def read(self, iprot):
11695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11697 
      return
11698 
    iprot.readStructBegin()
11699 
    while True:
11700 
      (fname, ftype, fid) = iprot.readFieldBegin()
11701 
      if ftype == TType.STOP:
11702 
        break
11703 
      if fid == 1:
11704 
        if ftype == TType.STRING:
11705 
          self.displayName = iprot.readString();
11706 
        else:
11707 
          iprot.skip(ftype)
11708 
      else:
11709 
        iprot.skip(ftype)
11710 
      iprot.readFieldEnd()
11711 
    iprot.readStructEnd()
11712 
 
11713 
  def write(self, oprot):
11714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11716 
      return
11717 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
11718 
    if self.displayName is not None:
11719 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
11720 
      oprot.writeString(self.displayName)
11721 
      oprot.writeFieldEnd()
11722 
    oprot.writeFieldStop()
11723 
    oprot.writeStructEnd()
11724 
 
11725 
  def validate(self):
11726 
    return
11727 
 
11728 
 
11729 
  def __repr__(self):
11730 
    L = ['%s=%r' % (key, value)
11731 
      for key, value in self.__dict__.iteritems()]
11732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11733 
 
11734 
  def __eq__(self, other):
11735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11736 
 
11737 
  def __ne__(self, other):
11738 
    return not (self == other)
11739 
 
11740 
class getAllEntitiesByTagName_result:
11741 
  """
11742 
  Attributes:
11743 
   - success
11744 
  """
11745 
 
11746 
  thrift_spec = (
11747 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11748 
  )
11749 
 
11750 
  def __init__(self, success=None,):
11751 
    self.success = success
11752 
 
11753 
  def read(self, iprot):
11754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11756 
      return
11757 
    iprot.readStructBegin()
11758 
    while True:
11759 
      (fname, ftype, fid) = iprot.readFieldBegin()
11760 
      if ftype == TType.STOP:
11761 
        break
11762 
      if fid == 0:
11763 
        if ftype == TType.LIST:
11764 
          self.success = []
8590 kshitij.so 11765 
          (_etype175, _size172) = iprot.readListBegin()
11766 
          for _i176 in xrange(_size172):
11767 
            _elem177 = iprot.readI64();
11768 
            self.success.append(_elem177)
6512 kshitij.so 11769 
          iprot.readListEnd()
11770 
        else:
11771 
          iprot.skip(ftype)
11772 
      else:
11773 
        iprot.skip(ftype)
11774 
      iprot.readFieldEnd()
11775 
    iprot.readStructEnd()
11776 
 
11777 
  def write(self, oprot):
11778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11780 
      return
11781 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
11782 
    if self.success is not None:
11783 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11784 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 11785 
      for iter178 in self.success:
11786 
        oprot.writeI64(iter178)
6512 kshitij.so 11787 
      oprot.writeListEnd()
11788 
      oprot.writeFieldEnd()
11789 
    oprot.writeFieldStop()
11790 
    oprot.writeStructEnd()
11791 
 
11792 
  def validate(self):
11793 
    return
11794 
 
11795 
 
11796 
  def __repr__(self):
11797 
    L = ['%s=%r' % (key, value)
11798 
      for key, value in self.__dict__.iteritems()]
11799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11800 
 
11801 
  def __eq__(self, other):
11802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11803 
 
11804 
  def __ne__(self, other):
11805 
    return not (self == other)
11806 
 
6845 amit.gupta 11807 
class getAllEntityTags_args:
11808 
 
11809 
  thrift_spec = (
11810 
  )
11811 
 
11812 
  def read(self, iprot):
11813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11815 
      return
11816 
    iprot.readStructBegin()
11817 
    while True:
11818 
      (fname, ftype, fid) = iprot.readFieldBegin()
11819 
      if ftype == TType.STOP:
11820 
        break
11821 
      else:
11822 
        iprot.skip(ftype)
11823 
      iprot.readFieldEnd()
11824 
    iprot.readStructEnd()
11825 
 
11826 
  def write(self, oprot):
11827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11829 
      return
11830 
    oprot.writeStructBegin('getAllEntityTags_args')
11831 
    oprot.writeFieldStop()
11832 
    oprot.writeStructEnd()
11833 
 
11834 
  def validate(self):
11835 
    return
11836 
 
11837 
 
11838 
  def __repr__(self):
11839 
    L = ['%s=%r' % (key, value)
11840 
      for key, value in self.__dict__.iteritems()]
11841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11842 
 
11843 
  def __eq__(self, other):
11844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11845 
 
11846 
  def __ne__(self, other):
11847 
    return not (self == other)
11848 
 
11849 
class getAllEntityTags_result:
11850 
  """
11851 
  Attributes:
11852 
   - success
11853 
  """
11854 
 
11855 
  thrift_spec = (
11856 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
11857 
  )
11858 
 
11859 
  def __init__(self, success=None,):
11860 
    self.success = success
11861 
 
11862 
  def read(self, iprot):
11863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11865 
      return
11866 
    iprot.readStructBegin()
11867 
    while True:
11868 
      (fname, ftype, fid) = iprot.readFieldBegin()
11869 
      if ftype == TType.STOP:
11870 
        break
11871 
      if fid == 0:
11872 
        if ftype == TType.MAP:
11873 
          self.success = {}
8590 kshitij.so 11874 
          (_ktype180, _vtype181, _size179 ) = iprot.readMapBegin()
11875 
          for _i183 in xrange(_size179):
11876 
            _key184 = iprot.readI64();
11877 
            _val185 = []
11878 
            (_etype189, _size186) = iprot.readListBegin()
11879 
            for _i190 in xrange(_size186):
11880 
              _elem191 = iprot.readString();
11881 
              _val185.append(_elem191)
6845 amit.gupta 11882 
            iprot.readListEnd()
8590 kshitij.so 11883 
            self.success[_key184] = _val185
6845 amit.gupta 11884 
          iprot.readMapEnd()
11885 
        else:
11886 
          iprot.skip(ftype)
11887 
      else:
11888 
        iprot.skip(ftype)
11889 
      iprot.readFieldEnd()
11890 
    iprot.readStructEnd()
11891 
 
11892 
  def write(self, oprot):
11893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11895 
      return
11896 
    oprot.writeStructBegin('getAllEntityTags_result')
11897 
    if self.success is not None:
11898 
      oprot.writeFieldBegin('success', TType.MAP, 0)
11899 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
8590 kshitij.so 11900 
      for kiter192,viter193 in self.success.items():
11901 
        oprot.writeI64(kiter192)
11902 
        oprot.writeListBegin(TType.STRING, len(viter193))
11903 
        for iter194 in viter193:
11904 
          oprot.writeString(iter194)
6845 amit.gupta 11905 
        oprot.writeListEnd()
11906 
      oprot.writeMapEnd()
11907 
      oprot.writeFieldEnd()
11908 
    oprot.writeFieldStop()
11909 
    oprot.writeStructEnd()
11910 
 
11911 
  def validate(self):
11912 
    return
11913 
 
11914 
 
11915 
  def __repr__(self):
11916 
    L = ['%s=%r' % (key, value)
11917 
      for key, value in self.__dict__.iteritems()]
11918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11919 
 
11920 
  def __eq__(self, other):
11921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11922 
 
11923 
  def __ne__(self, other):
11924 
    return not (self == other)
11925 
 
6850 kshitij.so 11926 
class addBanner_args:
11927 
  """
11928 
  Attributes:
8590 kshitij.so 11929 
   - bannerCongregate
6850 kshitij.so 11930 
  """
11931 
 
11932 
  thrift_spec = (
11933 
    None, # 0
8590 kshitij.so 11934 
    (1, TType.STRUCT, 'bannerCongregate', (BannerCongregate, BannerCongregate.thrift_spec), None, ), # 1
6850 kshitij.so 11935 
  )
11936 
 
8590 kshitij.so 11937 
  def __init__(self, bannerCongregate=None,):
11938 
    self.bannerCongregate = bannerCongregate
6850 kshitij.so 11939 
 
11940 
  def read(self, iprot):
11941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11943 
      return
11944 
    iprot.readStructBegin()
11945 
    while True:
11946 
      (fname, ftype, fid) = iprot.readFieldBegin()
11947 
      if ftype == TType.STOP:
11948 
        break
11949 
      if fid == 1:
8579 kshitij.so 11950 
        if ftype == TType.STRUCT:
8590 kshitij.so 11951 
          self.bannerCongregate = BannerCongregate()
11952 
          self.bannerCongregate.read(iprot)
6850 kshitij.so 11953 
        else:
11954 
          iprot.skip(ftype)
8579 kshitij.so 11955 
      else:
11956 
        iprot.skip(ftype)
11957 
      iprot.readFieldEnd()
11958 
    iprot.readStructEnd()
11959 
 
11960 
  def write(self, oprot):
11961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11963 
      return
11964 
    oprot.writeStructBegin('addBanner_args')
8590 kshitij.so 11965 
    if self.bannerCongregate is not None:
11966 
      oprot.writeFieldBegin('bannerCongregate', TType.STRUCT, 1)
11967 
      self.bannerCongregate.write(oprot)
8579 kshitij.so 11968 
      oprot.writeFieldEnd()
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 addBanner_result:
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('addBanner_result')
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 updateBanner_args:
12030 
  """
12031 
  Attributes:
12032 
   - banner
12033 
  """
12034 
 
12035 
  thrift_spec = (
12036 
    None, # 0
12037 
    (1, TType.STRUCT, 'banner', (Banner, Banner.thrift_spec), None, ), # 1
12038 
  )
12039 
 
12040 
  def __init__(self, banner=None,):
12041 
    self.banner = banner
12042 
 
12043 
  def read(self, iprot):
12044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12046 
      return
12047 
    iprot.readStructBegin()
12048 
    while True:
12049 
      (fname, ftype, fid) = iprot.readFieldBegin()
12050 
      if ftype == TType.STOP:
12051 
        break
12052 
      if fid == 1:
12053 
        if ftype == TType.STRUCT:
12054 
          self.banner = Banner()
12055 
          self.banner.read(iprot)
6850 kshitij.so 12056 
        else:
12057 
          iprot.skip(ftype)
12058 
      else:
12059 
        iprot.skip(ftype)
12060 
      iprot.readFieldEnd()
12061 
    iprot.readStructEnd()
12062 
 
12063 
  def write(self, oprot):
12064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12066 
      return
8579 kshitij.so 12067 
    oprot.writeStructBegin('updateBanner_args')
12068 
    if self.banner is not None:
12069 
      oprot.writeFieldBegin('banner', TType.STRUCT, 1)
12070 
      self.banner.write(oprot)
6850 kshitij.so 12071 
      oprot.writeFieldEnd()
12072 
    oprot.writeFieldStop()
12073 
    oprot.writeStructEnd()
12074 
 
12075 
  def validate(self):
12076 
    return
12077 
 
12078 
 
12079 
  def __repr__(self):
12080 
    L = ['%s=%r' % (key, value)
12081 
      for key, value in self.__dict__.iteritems()]
12082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12083 
 
12084 
  def __eq__(self, other):
12085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12086 
 
12087 
  def __ne__(self, other):
12088 
    return not (self == other)
12089 
 
8579 kshitij.so 12090 
class updateBanner_result:
6850 kshitij.so 12091 
  """
12092 
  Attributes:
12093 
   - success
12094 
  """
12095 
 
12096 
  thrift_spec = (
12097 
    (0, TType.BOOL, 'success', None, None, ), # 0
12098 
  )
12099 
 
12100 
  def __init__(self, success=None,):
12101 
    self.success = success
12102 
 
12103 
  def read(self, iprot):
12104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12106 
      return
12107 
    iprot.readStructBegin()
12108 
    while True:
12109 
      (fname, ftype, fid) = iprot.readFieldBegin()
12110 
      if ftype == TType.STOP:
12111 
        break
12112 
      if fid == 0:
12113 
        if ftype == TType.BOOL:
12114 
          self.success = iprot.readBool();
12115 
        else:
12116 
          iprot.skip(ftype)
12117 
      else:
12118 
        iprot.skip(ftype)
12119 
      iprot.readFieldEnd()
12120 
    iprot.readStructEnd()
12121 
 
12122 
  def write(self, oprot):
12123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12125 
      return
8579 kshitij.so 12126 
    oprot.writeStructBegin('updateBanner_result')
6850 kshitij.so 12127 
    if self.success is not None:
12128 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12129 
      oprot.writeBool(self.success)
12130 
      oprot.writeFieldEnd()
12131 
    oprot.writeFieldStop()
12132 
    oprot.writeStructEnd()
12133 
 
12134 
  def validate(self):
12135 
    return
12136 
 
12137 
 
12138 
  def __repr__(self):
12139 
    L = ['%s=%r' % (key, value)
12140 
      for key, value in self.__dict__.iteritems()]
12141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12142 
 
12143 
  def __eq__(self, other):
12144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12145 
 
12146 
  def __ne__(self, other):
12147 
    return not (self == other)
12148 
 
12149 
class getAllBanners_args:
12150 
 
12151 
  thrift_spec = (
12152 
  )
12153 
 
12154 
  def read(self, iprot):
12155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12157 
      return
12158 
    iprot.readStructBegin()
12159 
    while True:
12160 
      (fname, ftype, fid) = iprot.readFieldBegin()
12161 
      if ftype == TType.STOP:
12162 
        break
12163 
      else:
12164 
        iprot.skip(ftype)
12165 
      iprot.readFieldEnd()
12166 
    iprot.readStructEnd()
12167 
 
12168 
  def write(self, oprot):
12169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12171 
      return
12172 
    oprot.writeStructBegin('getAllBanners_args')
12173 
    oprot.writeFieldStop()
12174 
    oprot.writeStructEnd()
12175 
 
12176 
  def validate(self):
12177 
    return
12178 
 
12179 
 
12180 
  def __repr__(self):
12181 
    L = ['%s=%r' % (key, value)
12182 
      for key, value in self.__dict__.iteritems()]
12183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12184 
 
12185 
  def __eq__(self, other):
12186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12187 
 
12188 
  def __ne__(self, other):
12189 
    return not (self == other)
12190 
 
12191 
class getAllBanners_result:
12192 
  """
12193 
  Attributes:
12194 
   - success
12195 
  """
12196 
 
12197 
  thrift_spec = (
8579 kshitij.so 12198 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
6850 kshitij.so 12199 
  )
12200 
 
12201 
  def __init__(self, success=None,):
12202 
    self.success = success
12203 
 
12204 
  def read(self, iprot):
12205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12207 
      return
12208 
    iprot.readStructBegin()
12209 
    while True:
12210 
      (fname, ftype, fid) = iprot.readFieldBegin()
12211 
      if ftype == TType.STOP:
12212 
        break
12213 
      if fid == 0:
12214 
        if ftype == TType.LIST:
12215 
          self.success = []
8590 kshitij.so 12216 
          (_etype198, _size195) = iprot.readListBegin()
12217 
          for _i199 in xrange(_size195):
12218 
            _elem200 = Banner()
12219 
            _elem200.read(iprot)
12220 
            self.success.append(_elem200)
6850 kshitij.so 12221 
          iprot.readListEnd()
12222 
        else:
12223 
          iprot.skip(ftype)
12224 
      else:
12225 
        iprot.skip(ftype)
12226 
      iprot.readFieldEnd()
12227 
    iprot.readStructEnd()
12228 
 
12229 
  def write(self, oprot):
12230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12232 
      return
12233 
    oprot.writeStructBegin('getAllBanners_result')
12234 
    if self.success is not None:
12235 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8579 kshitij.so 12236 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 12237 
      for iter201 in self.success:
12238 
        iter201.write(oprot)
6850 kshitij.so 12239 
      oprot.writeListEnd()
12240 
      oprot.writeFieldEnd()
12241 
    oprot.writeFieldStop()
12242 
    oprot.writeStructEnd()
12243 
 
12244 
  def validate(self):
12245 
    return
12246 
 
12247 
 
12248 
  def __repr__(self):
12249 
    L = ['%s=%r' % (key, value)
12250 
      for key, value in self.__dict__.iteritems()]
12251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12252 
 
12253 
  def __eq__(self, other):
12254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12255 
 
12256 
  def __ne__(self, other):
12257 
    return not (self == other)
12258 
 
12259 
class deleteBanner_args:
12260 
  """
12261 
  Attributes:
12262 
   - bannerName
12263 
  """
12264 
 
12265 
  thrift_spec = (
12266 
    None, # 0
12267 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12268 
  )
12269 
 
12270 
  def __init__(self, bannerName=None,):
12271 
    self.bannerName = bannerName
12272 
 
12273 
  def read(self, iprot):
12274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12276 
      return
12277 
    iprot.readStructBegin()
12278 
    while True:
12279 
      (fname, ftype, fid) = iprot.readFieldBegin()
12280 
      if ftype == TType.STOP:
12281 
        break
12282 
      if fid == 1:
12283 
        if ftype == TType.STRING:
12284 
          self.bannerName = iprot.readString();
12285 
        else:
12286 
          iprot.skip(ftype)
12287 
      else:
12288 
        iprot.skip(ftype)
12289 
      iprot.readFieldEnd()
12290 
    iprot.readStructEnd()
12291 
 
12292 
  def write(self, oprot):
12293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12295 
      return
12296 
    oprot.writeStructBegin('deleteBanner_args')
12297 
    if self.bannerName is not None:
12298 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12299 
      oprot.writeString(self.bannerName)
12300 
      oprot.writeFieldEnd()
12301 
    oprot.writeFieldStop()
12302 
    oprot.writeStructEnd()
12303 
 
12304 
  def validate(self):
12305 
    return
12306 
 
12307 
 
12308 
  def __repr__(self):
12309 
    L = ['%s=%r' % (key, value)
12310 
      for key, value in self.__dict__.iteritems()]
12311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12312 
 
12313 
  def __eq__(self, other):
12314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12315 
 
12316 
  def __ne__(self, other):
12317 
    return not (self == other)
12318 
 
12319 
class deleteBanner_result:
12320 
  """
12321 
  Attributes:
12322 
   - success
12323 
  """
12324 
 
12325 
  thrift_spec = (
12326 
    (0, TType.BOOL, 'success', None, None, ), # 0
12327 
  )
12328 
 
12329 
  def __init__(self, success=None,):
12330 
    self.success = success
12331 
 
12332 
  def read(self, iprot):
12333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12335 
      return
12336 
    iprot.readStructBegin()
12337 
    while True:
12338 
      (fname, ftype, fid) = iprot.readFieldBegin()
12339 
      if ftype == TType.STOP:
12340 
        break
12341 
      if fid == 0:
12342 
        if ftype == TType.BOOL:
12343 
          self.success = iprot.readBool();
12344 
        else:
12345 
          iprot.skip(ftype)
12346 
      else:
12347 
        iprot.skip(ftype)
12348 
      iprot.readFieldEnd()
12349 
    iprot.readStructEnd()
12350 
 
12351 
  def write(self, oprot):
12352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12354 
      return
12355 
    oprot.writeStructBegin('deleteBanner_result')
12356 
    if self.success is not None:
12357 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12358 
      oprot.writeBool(self.success)
12359 
      oprot.writeFieldEnd()
12360 
    oprot.writeFieldStop()
12361 
    oprot.writeStructEnd()
12362 
 
12363 
  def validate(self):
12364 
    return
12365 
 
12366 
 
12367 
  def __repr__(self):
12368 
    L = ['%s=%r' % (key, value)
12369 
      for key, value in self.__dict__.iteritems()]
12370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12371 
 
12372 
  def __eq__(self, other):
12373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12374 
 
12375 
  def __ne__(self, other):
12376 
    return not (self == other)
12377 
 
12378 
class getBannerDetails_args:
12379 
  """
12380 
  Attributes:
12381 
   - bannerName
12382 
  """
12383 
 
12384 
  thrift_spec = (
12385 
    None, # 0
12386 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12387 
  )
12388 
 
12389 
  def __init__(self, bannerName=None,):
12390 
    self.bannerName = bannerName
12391 
 
12392 
  def read(self, iprot):
12393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12395 
      return
12396 
    iprot.readStructBegin()
12397 
    while True:
12398 
      (fname, ftype, fid) = iprot.readFieldBegin()
12399 
      if ftype == TType.STOP:
12400 
        break
12401 
      if fid == 1:
12402 
        if ftype == TType.STRING:
12403 
          self.bannerName = iprot.readString();
12404 
        else:
12405 
          iprot.skip(ftype)
12406 
      else:
12407 
        iprot.skip(ftype)
12408 
      iprot.readFieldEnd()
12409 
    iprot.readStructEnd()
12410 
 
12411 
  def write(self, oprot):
12412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12414 
      return
12415 
    oprot.writeStructBegin('getBannerDetails_args')
12416 
    if self.bannerName is not None:
12417 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12418 
      oprot.writeString(self.bannerName)
12419 
      oprot.writeFieldEnd()
12420 
    oprot.writeFieldStop()
12421 
    oprot.writeStructEnd()
12422 
 
12423 
  def validate(self):
12424 
    return
12425 
 
12426 
 
12427 
  def __repr__(self):
12428 
    L = ['%s=%r' % (key, value)
12429 
      for key, value in self.__dict__.iteritems()]
12430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12431 
 
12432 
  def __eq__(self, other):
12433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12434 
 
12435 
  def __ne__(self, other):
12436 
    return not (self == other)
12437 
 
12438 
class getBannerDetails_result:
12439 
  """
12440 
  Attributes:
12441 
   - success
12442 
  """
12443 
 
12444 
  thrift_spec = (
12445 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
12446 
  )
12447 
 
12448 
  def __init__(self, success=None,):
12449 
    self.success = success
12450 
 
12451 
  def read(self, iprot):
12452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12454 
      return
12455 
    iprot.readStructBegin()
12456 
    while True:
12457 
      (fname, ftype, fid) = iprot.readFieldBegin()
12458 
      if ftype == TType.STOP:
12459 
        break
12460 
      if fid == 0:
12461 
        if ftype == TType.STRUCT:
12462 
          self.success = Banner()
12463 
          self.success.read(iprot)
12464 
        else:
12465 
          iprot.skip(ftype)
12466 
      else:
12467 
        iprot.skip(ftype)
12468 
      iprot.readFieldEnd()
12469 
    iprot.readStructEnd()
12470 
 
12471 
  def write(self, oprot):
12472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12474 
      return
12475 
    oprot.writeStructBegin('getBannerDetails_result')
12476 
    if self.success is not None:
12477 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12478 
      self.success.write(oprot)
12479 
      oprot.writeFieldEnd()
12480 
    oprot.writeFieldStop()
12481 
    oprot.writeStructEnd()
12482 
 
12483 
  def validate(self):
12484 
    return
12485 
 
12486 
 
12487 
  def __repr__(self):
12488 
    L = ['%s=%r' % (key, value)
12489 
      for key, value in self.__dict__.iteritems()]
12490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12491 
 
12492 
  def __eq__(self, other):
12493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12494 
 
12495 
  def __ne__(self, other):
12496 
    return not (self == other)
12497 
 
12498 
class getActiveBanners_args:
12499 
 
12500 
  thrift_spec = (
12501 
  )
12502 
 
12503 
  def read(self, iprot):
12504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12506 
      return
12507 
    iprot.readStructBegin()
12508 
    while True:
12509 
      (fname, ftype, fid) = iprot.readFieldBegin()
12510 
      if ftype == TType.STOP:
12511 
        break
12512 
      else:
12513 
        iprot.skip(ftype)
12514 
      iprot.readFieldEnd()
12515 
    iprot.readStructEnd()
12516 
 
12517 
  def write(self, oprot):
12518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12520 
      return
12521 
    oprot.writeStructBegin('getActiveBanners_args')
12522 
    oprot.writeFieldStop()
12523 
    oprot.writeStructEnd()
12524 
 
12525 
  def validate(self):
12526 
    return
12527 
 
12528 
 
12529 
  def __repr__(self):
12530 
    L = ['%s=%r' % (key, value)
12531 
      for key, value in self.__dict__.iteritems()]
12532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12533 
 
12534 
  def __eq__(self, other):
12535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12536 
 
12537 
  def __ne__(self, other):
12538 
    return not (self == other)
12539 
 
12540 
class getActiveBanners_result:
12541 
  """
12542 
  Attributes:
12543 
   - success
12544 
  """
12545 
 
12546 
  thrift_spec = (
8579 kshitij.so 12547 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.LIST,(TType.STRUCT,(Banner, Banner.thrift_spec))), None, ), # 0
6850 kshitij.so 12548 
  )
12549 
 
12550 
  def __init__(self, success=None,):
12551 
    self.success = success
12552 
 
12553 
  def read(self, iprot):
12554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12556 
      return
12557 
    iprot.readStructBegin()
12558 
    while True:
12559 
      (fname, ftype, fid) = iprot.readFieldBegin()
12560 
      if ftype == TType.STOP:
12561 
        break
12562 
      if fid == 0:
8579 kshitij.so 12563 
        if ftype == TType.MAP:
12564 
          self.success = {}
8590 kshitij.so 12565 
          (_ktype203, _vtype204, _size202 ) = iprot.readMapBegin()
12566 
          for _i206 in xrange(_size202):
12567 
            _key207 = iprot.readString();
12568 
            _val208 = []
12569 
            (_etype212, _size209) = iprot.readListBegin()
12570 
            for _i213 in xrange(_size209):
12571 
              _elem214 = Banner()
12572 
              _elem214.read(iprot)
12573 
              _val208.append(_elem214)
8579 kshitij.so 12574 
            iprot.readListEnd()
8590 kshitij.so 12575 
            self.success[_key207] = _val208
8579 kshitij.so 12576 
          iprot.readMapEnd()
6850 kshitij.so 12577 
        else:
12578 
          iprot.skip(ftype)
12579 
      else:
12580 
        iprot.skip(ftype)
12581 
      iprot.readFieldEnd()
12582 
    iprot.readStructEnd()
12583 
 
12584 
  def write(self, oprot):
12585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12587 
      return
12588 
    oprot.writeStructBegin('getActiveBanners_result')
12589 
    if self.success is not None:
8579 kshitij.so 12590 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12591 
      oprot.writeMapBegin(TType.STRING, TType.LIST, len(self.success))
8590 kshitij.so 12592 
      for kiter215,viter216 in self.success.items():
12593 
        oprot.writeString(kiter215)
12594 
        oprot.writeListBegin(TType.STRUCT, len(viter216))
12595 
        for iter217 in viter216:
12596 
          iter217.write(oprot)
8579 kshitij.so 12597 
        oprot.writeListEnd()
12598 
      oprot.writeMapEnd()
6850 kshitij.so 12599 
      oprot.writeFieldEnd()
12600 
    oprot.writeFieldStop()
12601 
    oprot.writeStructEnd()
12602 
 
12603 
  def validate(self):
12604 
    return
12605 
 
12606 
 
12607 
  def __repr__(self):
12608 
    L = ['%s=%r' % (key, value)
12609 
      for key, value in self.__dict__.iteritems()]
12610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12611 
 
12612 
  def __eq__(self, other):
12613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12614 
 
12615 
  def __ne__(self, other):
12616 
    return not (self == other)
12617 
 
6849 kshitij.so 12618 
class addBannerMap_args:
12619 
  """
12620 
  Attributes:
8579 kshitij.so 12621 
   - bannerMaps
6849 kshitij.so 12622 
  """
12623 
 
12624 
  thrift_spec = (
12625 
    None, # 0
8579 kshitij.so 12626 
    (1, TType.LIST, 'bannerMaps', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 1
6849 kshitij.so 12627 
  )
12628 
 
8579 kshitij.so 12629 
  def __init__(self, bannerMaps=None,):
12630 
    self.bannerMaps = bannerMaps
6849 kshitij.so 12631 
 
12632 
  def read(self, iprot):
12633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12635 
      return
12636 
    iprot.readStructBegin()
12637 
    while True:
12638 
      (fname, ftype, fid) = iprot.readFieldBegin()
12639 
      if ftype == TType.STOP:
12640 
        break
12641 
      if fid == 1:
8579 kshitij.so 12642 
        if ftype == TType.LIST:
12643 
          self.bannerMaps = []
8590 kshitij.so 12644 
          (_etype221, _size218) = iprot.readListBegin()
12645 
          for _i222 in xrange(_size218):
12646 
            _elem223 = BannerMap()
12647 
            _elem223.read(iprot)
12648 
            self.bannerMaps.append(_elem223)
8579 kshitij.so 12649 
          iprot.readListEnd()
6849 kshitij.so 12650 
        else:
12651 
          iprot.skip(ftype)
8579 kshitij.so 12652 
      else:
12653 
        iprot.skip(ftype)
12654 
      iprot.readFieldEnd()
12655 
    iprot.readStructEnd()
12656 
 
12657 
  def write(self, oprot):
12658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12660 
      return
12661 
    oprot.writeStructBegin('addBannerMap_args')
12662 
    if self.bannerMaps is not None:
12663 
      oprot.writeFieldBegin('bannerMaps', TType.LIST, 1)
12664 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerMaps))
8590 kshitij.so 12665 
      for iter224 in self.bannerMaps:
12666 
        iter224.write(oprot)
8579 kshitij.so 12667 
      oprot.writeListEnd()
12668 
      oprot.writeFieldEnd()
12669 
    oprot.writeFieldStop()
12670 
    oprot.writeStructEnd()
12671 
 
12672 
  def validate(self):
12673 
    return
12674 
 
12675 
 
12676 
  def __repr__(self):
12677 
    L = ['%s=%r' % (key, value)
12678 
      for key, value in self.__dict__.iteritems()]
12679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12680 
 
12681 
  def __eq__(self, other):
12682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12683 
 
12684 
  def __ne__(self, other):
12685 
    return not (self == other)
12686 
 
12687 
class addBannerMap_result:
12688 
  """
12689 
  Attributes:
12690 
   - success
12691 
  """
12692 
 
12693 
  thrift_spec = (
12694 
    (0, TType.BOOL, 'success', None, None, ), # 0
12695 
  )
12696 
 
12697 
  def __init__(self, success=None,):
12698 
    self.success = success
12699 
 
12700 
  def read(self, iprot):
12701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12703 
      return
12704 
    iprot.readStructBegin()
12705 
    while True:
12706 
      (fname, ftype, fid) = iprot.readFieldBegin()
12707 
      if ftype == TType.STOP:
12708 
        break
12709 
      if fid == 0:
12710 
        if ftype == TType.BOOL:
12711 
          self.success = iprot.readBool();
6849 kshitij.so 12712 
        else:
12713 
          iprot.skip(ftype)
8579 kshitij.so 12714 
      else:
12715 
        iprot.skip(ftype)
12716 
      iprot.readFieldEnd()
12717 
    iprot.readStructEnd()
12718 
 
12719 
  def write(self, oprot):
12720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12722 
      return
12723 
    oprot.writeStructBegin('addBannerMap_result')
12724 
    if self.success is not None:
12725 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12726 
      oprot.writeBool(self.success)
12727 
      oprot.writeFieldEnd()
12728 
    oprot.writeFieldStop()
12729 
    oprot.writeStructEnd()
12730 
 
12731 
  def validate(self):
12732 
    return
12733 
 
12734 
 
12735 
  def __repr__(self):
12736 
    L = ['%s=%r' % (key, value)
12737 
      for key, value in self.__dict__.iteritems()]
12738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12739 
 
12740 
  def __eq__(self, other):
12741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12742 
 
12743 
  def __ne__(self, other):
12744 
    return not (self == other)
12745 
 
12746 
class updateBannerMap_args:
12747 
  """
12748 
  Attributes:
12749 
   - bannerMap
12750 
  """
12751 
 
12752 
  thrift_spec = (
12753 
    None, # 0
12754 
    (1, TType.STRUCT, 'bannerMap', (BannerMap, BannerMap.thrift_spec), None, ), # 1
12755 
  )
12756 
 
12757 
  def __init__(self, bannerMap=None,):
12758 
    self.bannerMap = bannerMap
12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
12769 
      if fid == 1:
12770 
        if ftype == TType.STRUCT:
12771 
          self.bannerMap = BannerMap()
12772 
          self.bannerMap.read(iprot)
6849 kshitij.so 12773 
        else:
12774 
          iprot.skip(ftype)
12775 
      else:
12776 
        iprot.skip(ftype)
12777 
      iprot.readFieldEnd()
12778 
    iprot.readStructEnd()
12779 
 
12780 
  def write(self, oprot):
12781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12783 
      return
8579 kshitij.so 12784 
    oprot.writeStructBegin('updateBannerMap_args')
12785 
    if self.bannerMap is not None:
12786 
      oprot.writeFieldBegin('bannerMap', TType.STRUCT, 1)
12787 
      self.bannerMap.write(oprot)
6849 kshitij.so 12788 
      oprot.writeFieldEnd()
12789 
    oprot.writeFieldStop()
12790 
    oprot.writeStructEnd()
12791 
 
12792 
  def validate(self):
12793 
    return
12794 
 
12795 
 
12796 
  def __repr__(self):
12797 
    L = ['%s=%r' % (key, value)
12798 
      for key, value in self.__dict__.iteritems()]
12799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12800 
 
12801 
  def __eq__(self, other):
12802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12803 
 
12804 
  def __ne__(self, other):
12805 
    return not (self == other)
12806 
 
8579 kshitij.so 12807 
class updateBannerMap_result:
6849 kshitij.so 12808 
  """
12809 
  Attributes:
12810 
   - success
12811 
  """
12812 
 
12813 
  thrift_spec = (
12814 
    (0, TType.BOOL, 'success', None, None, ), # 0
12815 
  )
12816 
 
12817 
  def __init__(self, success=None,):
12818 
    self.success = success
12819 
 
12820 
  def read(self, iprot):
12821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12823 
      return
12824 
    iprot.readStructBegin()
12825 
    while True:
12826 
      (fname, ftype, fid) = iprot.readFieldBegin()
12827 
      if ftype == TType.STOP:
12828 
        break
12829 
      if fid == 0:
12830 
        if ftype == TType.BOOL:
12831 
          self.success = iprot.readBool();
12832 
        else:
12833 
          iprot.skip(ftype)
12834 
      else:
12835 
        iprot.skip(ftype)
12836 
      iprot.readFieldEnd()
12837 
    iprot.readStructEnd()
12838 
 
12839 
  def write(self, oprot):
12840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12842 
      return
8579 kshitij.so 12843 
    oprot.writeStructBegin('updateBannerMap_result')
6849 kshitij.so 12844 
    if self.success is not None:
12845 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12846 
      oprot.writeBool(self.success)
12847 
      oprot.writeFieldEnd()
12848 
    oprot.writeFieldStop()
12849 
    oprot.writeStructEnd()
12850 
 
12851 
  def validate(self):
12852 
    return
12853 
 
12854 
 
12855 
  def __repr__(self):
12856 
    L = ['%s=%r' % (key, value)
12857 
      for key, value in self.__dict__.iteritems()]
12858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12859 
 
12860 
  def __eq__(self, other):
12861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12862 
 
12863 
  def __ne__(self, other):
12864 
    return not (self == other)
12865 
 
12866 
class deleteBannerMap_args:
12867 
  """
12868 
  Attributes:
12869 
   - bannerName
12870 
  """
12871 
 
12872 
  thrift_spec = (
12873 
    None, # 0
12874 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12875 
  )
12876 
 
12877 
  def __init__(self, bannerName=None,):
12878 
    self.bannerName = bannerName
12879 
 
12880 
  def read(self, iprot):
12881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12883 
      return
12884 
    iprot.readStructBegin()
12885 
    while True:
12886 
      (fname, ftype, fid) = iprot.readFieldBegin()
12887 
      if ftype == TType.STOP:
12888 
        break
12889 
      if fid == 1:
12890 
        if ftype == TType.STRING:
12891 
          self.bannerName = iprot.readString();
12892 
        else:
12893 
          iprot.skip(ftype)
12894 
      else:
12895 
        iprot.skip(ftype)
12896 
      iprot.readFieldEnd()
12897 
    iprot.readStructEnd()
12898 
 
12899 
  def write(self, oprot):
12900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12902 
      return
12903 
    oprot.writeStructBegin('deleteBannerMap_args')
12904 
    if self.bannerName is not None:
12905 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
12906 
      oprot.writeString(self.bannerName)
12907 
      oprot.writeFieldEnd()
12908 
    oprot.writeFieldStop()
12909 
    oprot.writeStructEnd()
12910 
 
12911 
  def validate(self):
12912 
    return
12913 
 
12914 
 
12915 
  def __repr__(self):
12916 
    L = ['%s=%r' % (key, value)
12917 
      for key, value in self.__dict__.iteritems()]
12918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12919 
 
12920 
  def __eq__(self, other):
12921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12922 
 
12923 
  def __ne__(self, other):
12924 
    return not (self == other)
12925 
 
12926 
class deleteBannerMap_result:
12927 
  """
12928 
  Attributes:
12929 
   - success
12930 
  """
12931 
 
12932 
  thrift_spec = (
12933 
    (0, TType.BOOL, 'success', None, None, ), # 0
12934 
  )
12935 
 
12936 
  def __init__(self, success=None,):
12937 
    self.success = success
12938 
 
12939 
  def read(self, iprot):
12940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12942 
      return
12943 
    iprot.readStructBegin()
12944 
    while True:
12945 
      (fname, ftype, fid) = iprot.readFieldBegin()
12946 
      if ftype == TType.STOP:
12947 
        break
12948 
      if fid == 0:
12949 
        if ftype == TType.BOOL:
12950 
          self.success = iprot.readBool();
12951 
        else:
12952 
          iprot.skip(ftype)
12953 
      else:
12954 
        iprot.skip(ftype)
12955 
      iprot.readFieldEnd()
12956 
    iprot.readStructEnd()
12957 
 
12958 
  def write(self, oprot):
12959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12961 
      return
12962 
    oprot.writeStructBegin('deleteBannerMap_result')
12963 
    if self.success is not None:
12964 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12965 
      oprot.writeBool(self.success)
12966 
      oprot.writeFieldEnd()
12967 
    oprot.writeFieldStop()
12968 
    oprot.writeStructEnd()
12969 
 
12970 
  def validate(self):
12971 
    return
12972 
 
12973 
 
12974 
  def __repr__(self):
12975 
    L = ['%s=%r' % (key, value)
12976 
      for key, value in self.__dict__.iteritems()]
12977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12978 
 
12979 
  def __eq__(self, other):
12980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12981 
 
12982 
  def __ne__(self, other):
12983 
    return not (self == other)
12984 
 
12985 
class getBannerMapDetails_args:
12986 
  """
12987 
  Attributes:
12988 
   - bannerName
12989 
  """
12990 
 
12991 
  thrift_spec = (
12992 
    None, # 0
12993 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
12994 
  )
12995 
 
12996 
  def __init__(self, bannerName=None,):
12997 
    self.bannerName = bannerName
12998 
 
12999 
  def read(self, iprot):
13000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13002 
      return
13003 
    iprot.readStructBegin()
13004 
    while True:
13005 
      (fname, ftype, fid) = iprot.readFieldBegin()
13006 
      if ftype == TType.STOP:
13007 
        break
13008 
      if fid == 1:
13009 
        if ftype == TType.STRING:
13010 
          self.bannerName = iprot.readString();
13011 
        else:
13012 
          iprot.skip(ftype)
13013 
      else:
13014 
        iprot.skip(ftype)
13015 
      iprot.readFieldEnd()
13016 
    iprot.readStructEnd()
13017 
 
13018 
  def write(self, oprot):
13019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13021 
      return
13022 
    oprot.writeStructBegin('getBannerMapDetails_args')
13023 
    if self.bannerName is not None:
13024 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13025 
      oprot.writeString(self.bannerName)
13026 
      oprot.writeFieldEnd()
13027 
    oprot.writeFieldStop()
13028 
    oprot.writeStructEnd()
13029 
 
13030 
  def validate(self):
13031 
    return
13032 
 
13033 
 
13034 
  def __repr__(self):
13035 
    L = ['%s=%r' % (key, value)
13036 
      for key, value in self.__dict__.iteritems()]
13037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13038 
 
13039 
  def __eq__(self, other):
13040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13041 
 
13042 
  def __ne__(self, other):
13043 
    return not (self == other)
13044 
 
13045 
class getBannerMapDetails_result:
13046 
  """
13047 
  Attributes:
13048 
   - success
13049 
  """
13050 
 
13051 
  thrift_spec = (
13052 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
13053 
  )
13054 
 
13055 
  def __init__(self, success=None,):
13056 
    self.success = success
13057 
 
13058 
  def read(self, iprot):
13059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13061 
      return
13062 
    iprot.readStructBegin()
13063 
    while True:
13064 
      (fname, ftype, fid) = iprot.readFieldBegin()
13065 
      if ftype == TType.STOP:
13066 
        break
13067 
      if fid == 0:
13068 
        if ftype == TType.LIST:
13069 
          self.success = []
8590 kshitij.so 13070 
          (_etype228, _size225) = iprot.readListBegin()
13071 
          for _i229 in xrange(_size225):
13072 
            _elem230 = BannerMap()
13073 
            _elem230.read(iprot)
13074 
            self.success.append(_elem230)
6849 kshitij.so 13075 
          iprot.readListEnd()
13076 
        else:
13077 
          iprot.skip(ftype)
13078 
      else:
13079 
        iprot.skip(ftype)
13080 
      iprot.readFieldEnd()
13081 
    iprot.readStructEnd()
13082 
 
13083 
  def write(self, oprot):
13084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13086 
      return
13087 
    oprot.writeStructBegin('getBannerMapDetails_result')
13088 
    if self.success is not None:
13089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13090 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13091 
      for iter231 in self.success:
13092 
        iter231.write(oprot)
6849 kshitij.so 13093 
      oprot.writeListEnd()
13094 
      oprot.writeFieldEnd()
13095 
    oprot.writeFieldStop()
13096 
    oprot.writeStructEnd()
13097 
 
13098 
  def validate(self):
13099 
    return
13100 
 
13101 
 
13102 
  def __repr__(self):
13103 
    L = ['%s=%r' % (key, value)
13104 
      for key, value in self.__dict__.iteritems()]
13105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13106 
 
13107 
  def __eq__(self, other):
13108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13109 
 
13110 
  def __ne__(self, other):
13111 
    return not (self == other)
13112 
 
8579 kshitij.so 13113 
class addBannerUri_args:
13114 
  """
13115 
  Attributes:
13116 
   - bannerUriMappings
13117 
  """
13118 
 
13119 
  thrift_spec = (
13120 
    None, # 0
13121 
    (1, TType.LIST, 'bannerUriMappings', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 1
13122 
  )
13123 
 
13124 
  def __init__(self, bannerUriMappings=None,):
13125 
    self.bannerUriMappings = bannerUriMappings
13126 
 
13127 
  def read(self, iprot):
13128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13130 
      return
13131 
    iprot.readStructBegin()
13132 
    while True:
13133 
      (fname, ftype, fid) = iprot.readFieldBegin()
13134 
      if ftype == TType.STOP:
13135 
        break
13136 
      if fid == 1:
13137 
        if ftype == TType.LIST:
13138 
          self.bannerUriMappings = []
8590 kshitij.so 13139 
          (_etype235, _size232) = iprot.readListBegin()
13140 
          for _i236 in xrange(_size232):
13141 
            _elem237 = BannerUriMapping()
13142 
            _elem237.read(iprot)
13143 
            self.bannerUriMappings.append(_elem237)
8579 kshitij.so 13144 
          iprot.readListEnd()
13145 
        else:
13146 
          iprot.skip(ftype)
13147 
      else:
13148 
        iprot.skip(ftype)
13149 
      iprot.readFieldEnd()
13150 
    iprot.readStructEnd()
13151 
 
13152 
  def write(self, oprot):
13153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13155 
      return
13156 
    oprot.writeStructBegin('addBannerUri_args')
13157 
    if self.bannerUriMappings is not None:
13158 
      oprot.writeFieldBegin('bannerUriMappings', TType.LIST, 1)
13159 
      oprot.writeListBegin(TType.STRUCT, len(self.bannerUriMappings))
8590 kshitij.so 13160 
      for iter238 in self.bannerUriMappings:
13161 
        iter238.write(oprot)
8579 kshitij.so 13162 
      oprot.writeListEnd()
13163 
      oprot.writeFieldEnd()
13164 
    oprot.writeFieldStop()
13165 
    oprot.writeStructEnd()
13166 
 
13167 
  def validate(self):
13168 
    return
13169 
 
13170 
 
13171 
  def __repr__(self):
13172 
    L = ['%s=%r' % (key, value)
13173 
      for key, value in self.__dict__.iteritems()]
13174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13175 
 
13176 
  def __eq__(self, other):
13177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13178 
 
13179 
  def __ne__(self, other):
13180 
    return not (self == other)
13181 
 
13182 
class addBannerUri_result:
13183 
 
13184 
  thrift_spec = (
13185 
  )
13186 
 
13187 
  def read(self, iprot):
13188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13190 
      return
13191 
    iprot.readStructBegin()
13192 
    while True:
13193 
      (fname, ftype, fid) = iprot.readFieldBegin()
13194 
      if ftype == TType.STOP:
13195 
        break
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('addBannerUri_result')
13206 
    oprot.writeFieldStop()
13207 
    oprot.writeStructEnd()
13208 
 
13209 
  def validate(self):
13210 
    return
13211 
 
13212 
 
13213 
  def __repr__(self):
13214 
    L = ['%s=%r' % (key, value)
13215 
      for key, value in self.__dict__.iteritems()]
13216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13217 
 
13218 
  def __eq__(self, other):
13219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13220 
 
13221 
  def __ne__(self, other):
13222 
    return not (self == other)
13223 
 
13224 
class getUriMapping_args:
13225 
  """
13226 
  Attributes:
13227 
   - bannerName
13228 
  """
13229 
 
13230 
  thrift_spec = (
13231 
    None, # 0
13232 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
13233 
  )
13234 
 
13235 
  def __init__(self, bannerName=None,):
13236 
    self.bannerName = bannerName
13237 
 
13238 
  def read(self, iprot):
13239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13241 
      return
13242 
    iprot.readStructBegin()
13243 
    while True:
13244 
      (fname, ftype, fid) = iprot.readFieldBegin()
13245 
      if ftype == TType.STOP:
13246 
        break
13247 
      if fid == 1:
13248 
        if ftype == TType.STRING:
13249 
          self.bannerName = iprot.readString();
13250 
        else:
13251 
          iprot.skip(ftype)
13252 
      else:
13253 
        iprot.skip(ftype)
13254 
      iprot.readFieldEnd()
13255 
    iprot.readStructEnd()
13256 
 
13257 
  def write(self, oprot):
13258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13260 
      return
13261 
    oprot.writeStructBegin('getUriMapping_args')
13262 
    if self.bannerName is not None:
13263 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
13264 
      oprot.writeString(self.bannerName)
13265 
      oprot.writeFieldEnd()
13266 
    oprot.writeFieldStop()
13267 
    oprot.writeStructEnd()
13268 
 
13269 
  def validate(self):
13270 
    return
13271 
 
13272 
 
13273 
  def __repr__(self):
13274 
    L = ['%s=%r' % (key, value)
13275 
      for key, value in self.__dict__.iteritems()]
13276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13277 
 
13278 
  def __eq__(self, other):
13279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13280 
 
13281 
  def __ne__(self, other):
13282 
    return not (self == other)
13283 
 
13284 
class getUriMapping_result:
13285 
  """
13286 
  Attributes:
13287 
   - success
13288 
  """
13289 
 
13290 
  thrift_spec = (
13291 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerUriMapping, BannerUriMapping.thrift_spec)), None, ), # 0
13292 
  )
13293 
 
13294 
  def __init__(self, success=None,):
13295 
    self.success = success
13296 
 
13297 
  def read(self, iprot):
13298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13300 
      return
13301 
    iprot.readStructBegin()
13302 
    while True:
13303 
      (fname, ftype, fid) = iprot.readFieldBegin()
13304 
      if ftype == TType.STOP:
13305 
        break
13306 
      if fid == 0:
13307 
        if ftype == TType.LIST:
13308 
          self.success = []
8590 kshitij.so 13309 
          (_etype242, _size239) = iprot.readListBegin()
13310 
          for _i243 in xrange(_size239):
13311 
            _elem244 = BannerUriMapping()
13312 
            _elem244.read(iprot)
13313 
            self.success.append(_elem244)
8579 kshitij.so 13314 
          iprot.readListEnd()
13315 
        else:
13316 
          iprot.skip(ftype)
13317 
      else:
13318 
        iprot.skip(ftype)
13319 
      iprot.readFieldEnd()
13320 
    iprot.readStructEnd()
13321 
 
13322 
  def write(self, oprot):
13323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13325 
      return
13326 
    oprot.writeStructBegin('getUriMapping_result')
13327 
    if self.success is not None:
13328 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13329 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13330 
      for iter245 in self.success:
13331 
        iter245.write(oprot)
8579 kshitij.so 13332 
      oprot.writeListEnd()
13333 
      oprot.writeFieldEnd()
13334 
    oprot.writeFieldStop()
13335 
    oprot.writeStructEnd()
13336 
 
13337 
  def validate(self):
13338 
    return
13339 
 
13340 
 
13341 
  def __repr__(self):
13342 
    L = ['%s=%r' % (key, value)
13343 
      for key, value in self.__dict__.iteritems()]
13344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13345 
 
13346 
  def __eq__(self, other):
13347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13348 
 
13349 
  def __ne__(self, other):
13350 
    return not (self == other)
13351 
 
13352 
class addCampaign_args:
13353 
  """
13354 
  Attributes:
13355 
   - campaign
13356 
  """
13357 
 
13358 
  thrift_spec = (
13359 
    None, # 0
13360 
    (1, TType.STRUCT, 'campaign', (Campaign, Campaign.thrift_spec), None, ), # 1
13361 
  )
13362 
 
13363 
  def __init__(self, campaign=None,):
13364 
    self.campaign = campaign
13365 
 
13366 
  def read(self, iprot):
13367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13369 
      return
13370 
    iprot.readStructBegin()
13371 
    while True:
13372 
      (fname, ftype, fid) = iprot.readFieldBegin()
13373 
      if ftype == TType.STOP:
13374 
        break
13375 
      if fid == 1:
13376 
        if ftype == TType.STRUCT:
13377 
          self.campaign = Campaign()
13378 
          self.campaign.read(iprot)
13379 
        else:
13380 
          iprot.skip(ftype)
13381 
      else:
13382 
        iprot.skip(ftype)
13383 
      iprot.readFieldEnd()
13384 
    iprot.readStructEnd()
13385 
 
13386 
  def write(self, oprot):
13387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13389 
      return
13390 
    oprot.writeStructBegin('addCampaign_args')
13391 
    if self.campaign is not None:
13392 
      oprot.writeFieldBegin('campaign', TType.STRUCT, 1)
13393 
      self.campaign.write(oprot)
13394 
      oprot.writeFieldEnd()
13395 
    oprot.writeFieldStop()
13396 
    oprot.writeStructEnd()
13397 
 
13398 
  def validate(self):
13399 
    return
13400 
 
13401 
 
13402 
  def __repr__(self):
13403 
    L = ['%s=%r' % (key, value)
13404 
      for key, value in self.__dict__.iteritems()]
13405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13406 
 
13407 
  def __eq__(self, other):
13408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13409 
 
13410 
  def __ne__(self, other):
13411 
    return not (self == other)
13412 
 
13413 
class addCampaign_result:
13414 
 
13415 
  thrift_spec = (
13416 
  )
13417 
 
13418 
  def read(self, iprot):
13419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13421 
      return
13422 
    iprot.readStructBegin()
13423 
    while True:
13424 
      (fname, ftype, fid) = iprot.readFieldBegin()
13425 
      if ftype == TType.STOP:
13426 
        break
13427 
      else:
13428 
        iprot.skip(ftype)
13429 
      iprot.readFieldEnd()
13430 
    iprot.readStructEnd()
13431 
 
13432 
  def write(self, oprot):
13433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13435 
      return
13436 
    oprot.writeStructBegin('addCampaign_result')
13437 
    oprot.writeFieldStop()
13438 
    oprot.writeStructEnd()
13439 
 
13440 
  def validate(self):
13441 
    return
13442 
 
13443 
 
13444 
  def __repr__(self):
13445 
    L = ['%s=%r' % (key, value)
13446 
      for key, value in self.__dict__.iteritems()]
13447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13448 
 
13449 
  def __eq__(self, other):
13450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13451 
 
13452 
  def __ne__(self, other):
13453 
    return not (self == other)
13454 
 
13455 
class getCampaigns_args:
13456 
  """
13457 
  Attributes:
13458 
   - campaignName
13459 
  """
13460 
 
13461 
  thrift_spec = (
13462 
    None, # 0
13463 
    (1, TType.STRING, 'campaignName', None, None, ), # 1
13464 
  )
13465 
 
13466 
  def __init__(self, campaignName=None,):
13467 
    self.campaignName = campaignName
13468 
 
13469 
  def read(self, iprot):
13470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13472 
      return
13473 
    iprot.readStructBegin()
13474 
    while True:
13475 
      (fname, ftype, fid) = iprot.readFieldBegin()
13476 
      if ftype == TType.STOP:
13477 
        break
13478 
      if fid == 1:
13479 
        if ftype == TType.STRING:
13480 
          self.campaignName = iprot.readString();
13481 
        else:
13482 
          iprot.skip(ftype)
13483 
      else:
13484 
        iprot.skip(ftype)
13485 
      iprot.readFieldEnd()
13486 
    iprot.readStructEnd()
13487 
 
13488 
  def write(self, oprot):
13489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13491 
      return
13492 
    oprot.writeStructBegin('getCampaigns_args')
13493 
    if self.campaignName is not None:
13494 
      oprot.writeFieldBegin('campaignName', TType.STRING, 1)
13495 
      oprot.writeString(self.campaignName)
13496 
      oprot.writeFieldEnd()
13497 
    oprot.writeFieldStop()
13498 
    oprot.writeStructEnd()
13499 
 
13500 
  def validate(self):
13501 
    return
13502 
 
13503 
 
13504 
  def __repr__(self):
13505 
    L = ['%s=%r' % (key, value)
13506 
      for key, value in self.__dict__.iteritems()]
13507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13508 
 
13509 
  def __eq__(self, other):
13510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13511 
 
13512 
  def __ne__(self, other):
13513 
    return not (self == other)
13514 
 
13515 
class getCampaigns_result:
13516 
  """
13517 
  Attributes:
13518 
   - success
13519 
  """
13520 
 
13521 
  thrift_spec = (
13522 
    (0, TType.LIST, 'success', (TType.STRUCT,(Campaign, Campaign.thrift_spec)), None, ), # 0
13523 
  )
13524 
 
13525 
  def __init__(self, success=None,):
13526 
    self.success = success
13527 
 
13528 
  def read(self, iprot):
13529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13531 
      return
13532 
    iprot.readStructBegin()
13533 
    while True:
13534 
      (fname, ftype, fid) = iprot.readFieldBegin()
13535 
      if ftype == TType.STOP:
13536 
        break
13537 
      if fid == 0:
13538 
        if ftype == TType.LIST:
13539 
          self.success = []
8590 kshitij.so 13540 
          (_etype249, _size246) = iprot.readListBegin()
13541 
          for _i250 in xrange(_size246):
13542 
            _elem251 = Campaign()
13543 
            _elem251.read(iprot)
13544 
            self.success.append(_elem251)
8579 kshitij.so 13545 
          iprot.readListEnd()
13546 
        else:
13547 
          iprot.skip(ftype)
13548 
      else:
13549 
        iprot.skip(ftype)
13550 
      iprot.readFieldEnd()
13551 
    iprot.readStructEnd()
13552 
 
13553 
  def write(self, oprot):
13554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13556 
      return
13557 
    oprot.writeStructBegin('getCampaigns_result')
13558 
    if self.success is not None:
13559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 13561 
      for iter252 in self.success:
13562 
        iter252.write(oprot)
8579 kshitij.so 13563 
      oprot.writeListEnd()
13564 
      oprot.writeFieldEnd()
13565 
    oprot.writeFieldStop()
13566 
    oprot.writeStructEnd()
13567 
 
13568 
  def validate(self):
13569 
    return
13570 
 
13571 
 
13572 
  def __repr__(self):
13573 
    L = ['%s=%r' % (key, value)
13574 
      for key, value in self.__dict__.iteritems()]
13575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13576 
 
13577 
  def __eq__(self, other):
13578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13579 
 
13580 
  def __ne__(self, other):
13581 
    return not (self == other)
13582 
 
13583 
class deleteCampaign_args:
13584 
  """
13585 
  Attributes:
13586 
   - campaignId
13587 
  """
13588 
 
13589 
  thrift_spec = (
13590 
    None, # 0
13591 
    (1, TType.I64, 'campaignId', None, None, ), # 1
13592 
  )
13593 
 
13594 
  def __init__(self, campaignId=None,):
13595 
    self.campaignId = campaignId
13596 
 
13597 
  def read(self, iprot):
13598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13600 
      return
13601 
    iprot.readStructBegin()
13602 
    while True:
13603 
      (fname, ftype, fid) = iprot.readFieldBegin()
13604 
      if ftype == TType.STOP:
13605 
        break
13606 
      if fid == 1:
13607 
        if ftype == TType.I64:
13608 
          self.campaignId = iprot.readI64();
13609 
        else:
13610 
          iprot.skip(ftype)
13611 
      else:
13612 
        iprot.skip(ftype)
13613 
      iprot.readFieldEnd()
13614 
    iprot.readStructEnd()
13615 
 
13616 
  def write(self, oprot):
13617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13619 
      return
13620 
    oprot.writeStructBegin('deleteCampaign_args')
13621 
    if self.campaignId is not None:
13622 
      oprot.writeFieldBegin('campaignId', TType.I64, 1)
13623 
      oprot.writeI64(self.campaignId)
13624 
      oprot.writeFieldEnd()
13625 
    oprot.writeFieldStop()
13626 
    oprot.writeStructEnd()
13627 
 
13628 
  def validate(self):
13629 
    return
13630 
 
13631 
 
13632 
  def __repr__(self):
13633 
    L = ['%s=%r' % (key, value)
13634 
      for key, value in self.__dict__.iteritems()]
13635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13636 
 
13637 
  def __eq__(self, other):
13638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13639 
 
13640 
  def __ne__(self, other):
13641 
    return not (self == other)
13642 
 
13643 
class deleteCampaign_result:
13644 
 
13645 
  thrift_spec = (
13646 
  )
13647 
 
13648 
  def read(self, iprot):
13649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13651 
      return
13652 
    iprot.readStructBegin()
13653 
    while True:
13654 
      (fname, ftype, fid) = iprot.readFieldBegin()
13655 
      if ftype == TType.STOP:
13656 
        break
13657 
      else:
13658 
        iprot.skip(ftype)
13659 
      iprot.readFieldEnd()
13660 
    iprot.readStructEnd()
13661 
 
13662 
  def write(self, oprot):
13663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13665 
      return
13666 
    oprot.writeStructBegin('deleteCampaign_result')
13667 
    oprot.writeFieldStop()
13668 
    oprot.writeStructEnd()
13669 
 
13670 
  def validate(self):
13671 
    return
13672 
 
13673 
 
13674 
  def __repr__(self):
13675 
    L = ['%s=%r' % (key, value)
13676 
      for key, value in self.__dict__.iteritems()]
13677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13678 
 
13679 
  def __eq__(self, other):
13680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13681 
 
13682 
  def __ne__(self, other):
13683 
    return not (self == other)
13684 
 
13685 
class getAllCampaigns_args:
13686 
 
13687 
  thrift_spec = (
13688 
  )
13689 
 
13690 
  def read(self, iprot):
13691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13693 
      return
13694 
    iprot.readStructBegin()
13695 
    while True:
13696 
      (fname, ftype, fid) = iprot.readFieldBegin()
13697 
      if ftype == TType.STOP:
13698 
        break
13699 
      else:
13700 
        iprot.skip(ftype)
13701 
      iprot.readFieldEnd()
13702 
    iprot.readStructEnd()
13703 
 
13704 
  def write(self, oprot):
13705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13707 
      return
13708 
    oprot.writeStructBegin('getAllCampaigns_args')
13709 
    oprot.writeFieldStop()
13710 
    oprot.writeStructEnd()
13711 
 
13712 
  def validate(self):
13713 
    return
13714 
 
13715 
 
13716 
  def __repr__(self):
13717 
    L = ['%s=%r' % (key, value)
13718 
      for key, value in self.__dict__.iteritems()]
13719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13720 
 
13721 
  def __eq__(self, other):
13722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13723 
 
13724 
  def __ne__(self, other):
13725 
    return not (self == other)
13726 
 
13727 
class getAllCampaigns_result:
13728 
  """
13729 
  Attributes:
13730 
   - success
13731 
  """
13732 
 
13733 
  thrift_spec = (
13734 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13735 
  )
13736 
 
13737 
  def __init__(self, success=None,):
13738 
    self.success = success
13739 
 
13740 
  def read(self, iprot):
13741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13743 
      return
13744 
    iprot.readStructBegin()
13745 
    while True:
13746 
      (fname, ftype, fid) = iprot.readFieldBegin()
13747 
      if ftype == TType.STOP:
13748 
        break
13749 
      if fid == 0:
13750 
        if ftype == TType.LIST:
13751 
          self.success = []
8590 kshitij.so 13752 
          (_etype256, _size253) = iprot.readListBegin()
13753 
          for _i257 in xrange(_size253):
13754 
            _elem258 = iprot.readString();
13755 
            self.success.append(_elem258)
8579 kshitij.so 13756 
          iprot.readListEnd()
13757 
        else:
13758 
          iprot.skip(ftype)
13759 
      else:
13760 
        iprot.skip(ftype)
13761 
      iprot.readFieldEnd()
13762 
    iprot.readStructEnd()
13763 
 
13764 
  def write(self, oprot):
13765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13767 
      return
13768 
    oprot.writeStructBegin('getAllCampaigns_result')
13769 
    if self.success is not None:
13770 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13771 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 13772 
      for iter259 in self.success:
13773 
        oprot.writeString(iter259)
8579 kshitij.so 13774 
      oprot.writeListEnd()
13775 
      oprot.writeFieldEnd()
13776 
    oprot.writeFieldStop()
13777 
    oprot.writeStructEnd()
13778 
 
13779 
  def validate(self):
13780 
    return
13781 
 
13782 
 
13783 
  def __repr__(self):
13784 
    L = ['%s=%r' % (key, value)
13785 
      for key, value in self.__dict__.iteritems()]
13786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13787 
 
13788 
  def __eq__(self, other):
13789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13790 
 
13791 
  def __ne__(self, other):
13792 
    return not (self == other)
13793 
 
5944 mandeep.dh 13794 
class deleteSimilarItem_args:
13795 
  """
13796 
  Attributes:
13797 
   - itemId
13798 
   - catalogItemId
13799 
  """
13800 
 
13801 
  thrift_spec = (
13802 
    None, # 0
13803 
    (1, TType.I64, 'itemId', None, None, ), # 1
13804 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
13805 
  )
13806 
 
13807 
  def __init__(self, itemId=None, catalogItemId=None,):
13808 
    self.itemId = itemId
13809 
    self.catalogItemId = catalogItemId
13810 
 
13811 
  def read(self, iprot):
13812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13814 
      return
13815 
    iprot.readStructBegin()
13816 
    while True:
13817 
      (fname, ftype, fid) = iprot.readFieldBegin()
13818 
      if ftype == TType.STOP:
13819 
        break
13820 
      if fid == 1:
13821 
        if ftype == TType.I64:
13822 
          self.itemId = iprot.readI64();
13823 
        else:
13824 
          iprot.skip(ftype)
13825 
      elif fid == 2:
13826 
        if ftype == TType.I64:
13827 
          self.catalogItemId = iprot.readI64();
13828 
        else:
13829 
          iprot.skip(ftype)
13830 
      else:
13831 
        iprot.skip(ftype)
13832 
      iprot.readFieldEnd()
13833 
    iprot.readStructEnd()
13834 
 
13835 
  def write(self, oprot):
13836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13838 
      return
13839 
    oprot.writeStructBegin('deleteSimilarItem_args')
13840 
    if self.itemId is not None:
13841 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13842 
      oprot.writeI64(self.itemId)
13843 
      oprot.writeFieldEnd()
13844 
    if self.catalogItemId is not None:
13845 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
13846 
      oprot.writeI64(self.catalogItemId)
13847 
      oprot.writeFieldEnd()
13848 
    oprot.writeFieldStop()
13849 
    oprot.writeStructEnd()
13850 
 
13851 
  def validate(self):
13852 
    return
13853 
 
13854 
 
13855 
  def __repr__(self):
13856 
    L = ['%s=%r' % (key, value)
13857 
      for key, value in self.__dict__.iteritems()]
13858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13859 
 
13860 
  def __eq__(self, other):
13861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13862 
 
13863 
  def __ne__(self, other):
13864 
    return not (self == other)
13865 
 
13866 
class deleteSimilarItem_result:
13867 
  """
13868 
  Attributes:
13869 
   - success
13870 
   - cex
13871 
  """
13872 
 
13873 
  thrift_spec = (
13874 
    (0, TType.BOOL, 'success', None, None, ), # 0
13875 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13876 
  )
13877 
 
13878 
  def __init__(self, success=None, cex=None,):
13879 
    self.success = success
13880 
    self.cex = cex
13881 
 
13882 
  def read(self, iprot):
13883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13885 
      return
13886 
    iprot.readStructBegin()
13887 
    while True:
13888 
      (fname, ftype, fid) = iprot.readFieldBegin()
13889 
      if ftype == TType.STOP:
13890 
        break
13891 
      if fid == 0:
13892 
        if ftype == TType.BOOL:
13893 
          self.success = iprot.readBool();
13894 
        else:
13895 
          iprot.skip(ftype)
13896 
      elif fid == 1:
13897 
        if ftype == TType.STRUCT:
13898 
          self.cex = CatalogServiceException()
13899 
          self.cex.read(iprot)
13900 
        else:
13901 
          iprot.skip(ftype)
13902 
      else:
13903 
        iprot.skip(ftype)
13904 
      iprot.readFieldEnd()
13905 
    iprot.readStructEnd()
13906 
 
13907 
  def write(self, oprot):
13908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13910 
      return
13911 
    oprot.writeStructBegin('deleteSimilarItem_result')
13912 
    if self.success is not None:
13913 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13914 
      oprot.writeBool(self.success)
13915 
      oprot.writeFieldEnd()
13916 
    if self.cex is not None:
13917 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13918 
      self.cex.write(oprot)
13919 
      oprot.writeFieldEnd()
13920 
    oprot.writeFieldStop()
13921 
    oprot.writeStructEnd()
13922 
 
13923 
  def validate(self):
13924 
    return
13925 
 
13926 
 
13927 
  def __repr__(self):
13928 
    L = ['%s=%r' % (key, value)
13929 
      for key, value in self.__dict__.iteritems()]
13930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13931 
 
13932 
  def __eq__(self, other):
13933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13934 
 
13935 
  def __ne__(self, other):
13936 
    return not (self == other)
13937 
 
13938 
class checkSimilarItem_args:
13939 
  """
13940 
  Attributes:
13941 
   - brand
13942 
   - modelNumber
13943 
   - modelName
13944 
   - color
13945 
  """
13946 
 
13947 
  thrift_spec = (
13948 
    None, # 0
13949 
    (1, TType.STRING, 'brand', None, None, ), # 1
13950 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
13951 
    (3, TType.STRING, 'modelName', None, None, ), # 3
13952 
    (4, TType.STRING, 'color', None, None, ), # 4
13953 
  )
13954 
 
13955 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
13956 
    self.brand = brand
13957 
    self.modelNumber = modelNumber
13958 
    self.modelName = modelName
13959 
    self.color = color
13960 
 
13961 
  def read(self, iprot):
13962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13964 
      return
13965 
    iprot.readStructBegin()
13966 
    while True:
13967 
      (fname, ftype, fid) = iprot.readFieldBegin()
13968 
      if ftype == TType.STOP:
13969 
        break
13970 
      if fid == 1:
13971 
        if ftype == TType.STRING:
13972 
          self.brand = iprot.readString();
13973 
        else:
13974 
          iprot.skip(ftype)
13975 
      elif fid == 2:
13976 
        if ftype == TType.STRING:
13977 
          self.modelNumber = iprot.readString();
13978 
        else:
13979 
          iprot.skip(ftype)
13980 
      elif fid == 3:
13981 
        if ftype == TType.STRING:
13982 
          self.modelName = iprot.readString();
13983 
        else:
13984 
          iprot.skip(ftype)
13985 
      elif fid == 4:
13986 
        if ftype == TType.STRING:
13987 
          self.color = iprot.readString();
13988 
        else:
13989 
          iprot.skip(ftype)
13990 
      else:
13991 
        iprot.skip(ftype)
13992 
      iprot.readFieldEnd()
13993 
    iprot.readStructEnd()
13994 
 
13995 
  def write(self, oprot):
13996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13998 
      return
13999 
    oprot.writeStructBegin('checkSimilarItem_args')
14000 
    if self.brand is not None:
14001 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
14002 
      oprot.writeString(self.brand)
14003 
      oprot.writeFieldEnd()
14004 
    if self.modelNumber is not None:
14005 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
14006 
      oprot.writeString(self.modelNumber)
14007 
      oprot.writeFieldEnd()
14008 
    if self.modelName is not None:
14009 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
14010 
      oprot.writeString(self.modelName)
14011 
      oprot.writeFieldEnd()
14012 
    if self.color is not None:
14013 
      oprot.writeFieldBegin('color', TType.STRING, 4)
14014 
      oprot.writeString(self.color)
14015 
      oprot.writeFieldEnd()
14016 
    oprot.writeFieldStop()
14017 
    oprot.writeStructEnd()
14018 
 
14019 
  def validate(self):
14020 
    return
14021 
 
14022 
 
14023 
  def __repr__(self):
14024 
    L = ['%s=%r' % (key, value)
14025 
      for key, value in self.__dict__.iteritems()]
14026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14027 
 
14028 
  def __eq__(self, other):
14029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14030 
 
14031 
  def __ne__(self, other):
14032 
    return not (self == other)
14033 
 
14034 
class checkSimilarItem_result:
14035 
  """
14036 
  Attributes:
14037 
   - success
14038 
  """
14039 
 
14040 
  thrift_spec = (
14041 
    (0, TType.I64, 'success', None, None, ), # 0
14042 
  )
14043 
 
14044 
  def __init__(self, success=None,):
14045 
    self.success = success
14046 
 
14047 
  def read(self, iprot):
14048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14050 
      return
14051 
    iprot.readStructBegin()
14052 
    while True:
14053 
      (fname, ftype, fid) = iprot.readFieldBegin()
14054 
      if ftype == TType.STOP:
14055 
        break
14056 
      if fid == 0:
14057 
        if ftype == TType.I64:
14058 
          self.success = iprot.readI64();
14059 
        else:
14060 
          iprot.skip(ftype)
14061 
      else:
14062 
        iprot.skip(ftype)
14063 
      iprot.readFieldEnd()
14064 
    iprot.readStructEnd()
14065 
 
14066 
  def write(self, oprot):
14067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14069 
      return
14070 
    oprot.writeStructBegin('checkSimilarItem_result')
14071 
    if self.success is not None:
14072 
      oprot.writeFieldBegin('success', TType.I64, 0)
14073 
      oprot.writeI64(self.success)
14074 
      oprot.writeFieldEnd()
14075 
    oprot.writeFieldStop()
14076 
    oprot.writeStructEnd()
14077 
 
14078 
  def validate(self):
14079 
    return
14080 
 
14081 
 
14082 
  def __repr__(self):
14083 
    L = ['%s=%r' % (key, value)
14084 
      for key, value in self.__dict__.iteritems()]
14085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14086 
 
14087 
  def __eq__(self, other):
14088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14089 
 
14090 
  def __ne__(self, other):
14091 
    return not (self == other)
14092 
 
14093 
class validateRiskyStatus_args:
14094 
  """
14095 
  Attributes:
14096 
   - itemId
14097 
  """
14098 
 
14099 
  thrift_spec = (
14100 
    None, # 0
14101 
    (1, TType.I64, 'itemId', None, None, ), # 1
14102 
  )
14103 
 
14104 
  def __init__(self, itemId=None,):
14105 
    self.itemId = itemId
14106 
 
14107 
  def read(self, iprot):
14108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14110 
      return
14111 
    iprot.readStructBegin()
14112 
    while True:
14113 
      (fname, ftype, fid) = iprot.readFieldBegin()
14114 
      if ftype == TType.STOP:
14115 
        break
14116 
      if fid == 1:
14117 
        if ftype == TType.I64:
14118 
          self.itemId = iprot.readI64();
14119 
        else:
14120 
          iprot.skip(ftype)
14121 
      else:
14122 
        iprot.skip(ftype)
14123 
      iprot.readFieldEnd()
14124 
    iprot.readStructEnd()
14125 
 
14126 
  def write(self, oprot):
14127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14129 
      return
14130 
    oprot.writeStructBegin('validateRiskyStatus_args')
14131 
    if self.itemId is not None:
14132 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14133 
      oprot.writeI64(self.itemId)
14134 
      oprot.writeFieldEnd()
14135 
    oprot.writeFieldStop()
14136 
    oprot.writeStructEnd()
14137 
 
14138 
  def validate(self):
14139 
    return
14140 
 
14141 
 
14142 
  def __repr__(self):
14143 
    L = ['%s=%r' % (key, value)
14144 
      for key, value in self.__dict__.iteritems()]
14145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14146 
 
14147 
  def __eq__(self, other):
14148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14149 
 
14150 
  def __ne__(self, other):
14151 
    return not (self == other)
14152 
 
14153 
class validateRiskyStatus_result:
14154 
 
14155 
  thrift_spec = (
14156 
  )
14157 
 
14158 
  def read(self, iprot):
14159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14161 
      return
14162 
    iprot.readStructBegin()
14163 
    while True:
14164 
      (fname, ftype, fid) = iprot.readFieldBegin()
14165 
      if ftype == TType.STOP:
14166 
        break
14167 
      else:
14168 
        iprot.skip(ftype)
14169 
      iprot.readFieldEnd()
14170 
    iprot.readStructEnd()
14171 
 
14172 
  def write(self, oprot):
14173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14175 
      return
14176 
    oprot.writeStructBegin('validateRiskyStatus_result')
14177 
    oprot.writeFieldStop()
14178 
    oprot.writeStructEnd()
14179 
 
14180 
  def validate(self):
14181 
    return
14182 
 
14183 
 
14184 
  def __repr__(self):
14185 
    L = ['%s=%r' % (key, value)
14186 
      for key, value in self.__dict__.iteritems()]
14187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14188 
 
14189 
  def __eq__(self, other):
14190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14191 
 
14192 
  def __ne__(self, other):
14193 
    return not (self == other)
14194 
 
14195 
class changeItemRiskyFlag_args:
14196 
  """
14197 
  Attributes:
14198 
   - itemId
14199 
   - risky
14200 
  """
14201 
 
14202 
  thrift_spec = (
14203 
    None, # 0
14204 
    (1, TType.I64, 'itemId', None, None, ), # 1
14205 
    (2, TType.BOOL, 'risky', None, None, ), # 2
14206 
  )
14207 
 
14208 
  def __init__(self, itemId=None, risky=None,):
14209 
    self.itemId = itemId
14210 
    self.risky = risky
14211 
 
14212 
  def read(self, iprot):
14213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14215 
      return
14216 
    iprot.readStructBegin()
14217 
    while True:
14218 
      (fname, ftype, fid) = iprot.readFieldBegin()
14219 
      if ftype == TType.STOP:
14220 
        break
14221 
      if fid == 1:
14222 
        if ftype == TType.I64:
14223 
          self.itemId = iprot.readI64();
14224 
        else:
14225 
          iprot.skip(ftype)
14226 
      elif fid == 2:
14227 
        if ftype == TType.BOOL:
14228 
          self.risky = iprot.readBool();
14229 
        else:
14230 
          iprot.skip(ftype)
14231 
      else:
14232 
        iprot.skip(ftype)
14233 
      iprot.readFieldEnd()
14234 
    iprot.readStructEnd()
14235 
 
14236 
  def write(self, oprot):
14237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14239 
      return
14240 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
14241 
    if self.itemId is not None:
14242 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14243 
      oprot.writeI64(self.itemId)
14244 
      oprot.writeFieldEnd()
14245 
    if self.risky is not None:
14246 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
14247 
      oprot.writeBool(self.risky)
14248 
      oprot.writeFieldEnd()
14249 
    oprot.writeFieldStop()
14250 
    oprot.writeStructEnd()
14251 
 
14252 
  def validate(self):
14253 
    return
14254 
 
14255 
 
14256 
  def __repr__(self):
14257 
    L = ['%s=%r' % (key, value)
14258 
      for key, value in self.__dict__.iteritems()]
14259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14260 
 
14261 
  def __eq__(self, other):
14262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14263 
 
14264 
  def __ne__(self, other):
14265 
    return not (self == other)
14266 
 
14267 
class changeItemRiskyFlag_result:
14268 
 
14269 
  thrift_spec = (
14270 
  )
14271 
 
14272 
  def read(self, iprot):
14273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14275 
      return
14276 
    iprot.readStructBegin()
14277 
    while True:
14278 
      (fname, ftype, fid) = iprot.readFieldBegin()
14279 
      if ftype == TType.STOP:
14280 
        break
14281 
      else:
14282 
        iprot.skip(ftype)
14283 
      iprot.readFieldEnd()
14284 
    iprot.readStructEnd()
14285 
 
14286 
  def write(self, oprot):
14287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14289 
      return
14290 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
14291 
    oprot.writeFieldStop()
14292 
    oprot.writeStructEnd()
14293 
 
14294 
  def validate(self):
14295 
    return
14296 
 
14297 
 
14298 
  def __repr__(self):
14299 
    L = ['%s=%r' % (key, value)
14300 
      for key, value in self.__dict__.iteritems()]
14301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14302 
 
14303 
  def __eq__(self, other):
14304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14305 
 
14306 
  def __ne__(self, other):
14307 
    return not (self == other)
14308 
 
14309 
class getItemsByRiskyFlag_args:
14310 
 
14311 
  thrift_spec = (
14312 
  )
14313 
 
14314 
  def read(self, iprot):
14315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14317 
      return
14318 
    iprot.readStructBegin()
14319 
    while True:
14320 
      (fname, ftype, fid) = iprot.readFieldBegin()
14321 
      if ftype == TType.STOP:
14322 
        break
14323 
      else:
14324 
        iprot.skip(ftype)
14325 
      iprot.readFieldEnd()
14326 
    iprot.readStructEnd()
14327 
 
14328 
  def write(self, oprot):
14329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14331 
      return
14332 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
14333 
    oprot.writeFieldStop()
14334 
    oprot.writeStructEnd()
14335 
 
14336 
  def validate(self):
14337 
    return
14338 
 
14339 
 
14340 
  def __repr__(self):
14341 
    L = ['%s=%r' % (key, value)
14342 
      for key, value in self.__dict__.iteritems()]
14343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14344 
 
14345 
  def __eq__(self, other):
14346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14347 
 
14348 
  def __ne__(self, other):
14349 
    return not (self == other)
14350 
 
14351 
class getItemsByRiskyFlag_result:
14352 
  """
14353 
  Attributes:
14354 
   - success
14355 
  """
14356 
 
14357 
  thrift_spec = (
14358 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14359 
  )
14360 
 
14361 
  def __init__(self, success=None,):
14362 
    self.success = success
14363 
 
14364 
  def read(self, iprot):
14365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14367 
      return
14368 
    iprot.readStructBegin()
14369 
    while True:
14370 
      (fname, ftype, fid) = iprot.readFieldBegin()
14371 
      if ftype == TType.STOP:
14372 
        break
14373 
      if fid == 0:
14374 
        if ftype == TType.LIST:
14375 
          self.success = []
8590 kshitij.so 14376 
          (_etype263, _size260) = iprot.readListBegin()
14377 
          for _i264 in xrange(_size260):
14378 
            _elem265 = Item()
14379 
            _elem265.read(iprot)
14380 
            self.success.append(_elem265)
5944 mandeep.dh 14381 
          iprot.readListEnd()
14382 
        else:
14383 
          iprot.skip(ftype)
14384 
      else:
14385 
        iprot.skip(ftype)
14386 
      iprot.readFieldEnd()
14387 
    iprot.readStructEnd()
14388 
 
14389 
  def write(self, oprot):
14390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14392 
      return
14393 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
14394 
    if self.success is not None:
14395 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14396 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14397 
      for iter266 in self.success:
14398 
        iter266.write(oprot)
5944 mandeep.dh 14399 
      oprot.writeListEnd()
14400 
      oprot.writeFieldEnd()
14401 
    oprot.writeFieldStop()
14402 
    oprot.writeStructEnd()
14403 
 
14404 
  def validate(self):
14405 
    return
14406 
 
14407 
 
14408 
  def __repr__(self):
14409 
    L = ['%s=%r' % (key, value)
14410 
      for key, value in self.__dict__.iteritems()]
14411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14412 
 
14413 
  def __eq__(self, other):
14414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14415 
 
14416 
  def __ne__(self, other):
14417 
    return not (self == other)
14418 
 
14419 
class getItemsForMasterSheet_args:
14420 
  """
14421 
  Attributes:
14422 
   - category
14423 
   - brand
14424 
  """
14425 
 
14426 
  thrift_spec = (
14427 
    None, # 0
14428 
    (1, TType.STRING, 'category', None, None, ), # 1
14429 
    (2, TType.STRING, 'brand', None, None, ), # 2
14430 
  )
14431 
 
14432 
  def __init__(self, category=None, brand=None,):
14433 
    self.category = category
14434 
    self.brand = brand
14435 
 
14436 
  def read(self, iprot):
14437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14439 
      return
14440 
    iprot.readStructBegin()
14441 
    while True:
14442 
      (fname, ftype, fid) = iprot.readFieldBegin()
14443 
      if ftype == TType.STOP:
14444 
        break
14445 
      if fid == 1:
14446 
        if ftype == TType.STRING:
14447 
          self.category = iprot.readString();
14448 
        else:
14449 
          iprot.skip(ftype)
14450 
      elif fid == 2:
14451 
        if ftype == TType.STRING:
14452 
          self.brand = iprot.readString();
14453 
        else:
14454 
          iprot.skip(ftype)
14455 
      else:
14456 
        iprot.skip(ftype)
14457 
      iprot.readFieldEnd()
14458 
    iprot.readStructEnd()
14459 
 
14460 
  def write(self, oprot):
14461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14463 
      return
14464 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
14465 
    if self.category is not None:
14466 
      oprot.writeFieldBegin('category', TType.STRING, 1)
14467 
      oprot.writeString(self.category)
14468 
      oprot.writeFieldEnd()
14469 
    if self.brand is not None:
14470 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
14471 
      oprot.writeString(self.brand)
14472 
      oprot.writeFieldEnd()
14473 
    oprot.writeFieldStop()
14474 
    oprot.writeStructEnd()
14475 
 
14476 
  def validate(self):
14477 
    return
14478 
 
14479 
 
14480 
  def __repr__(self):
14481 
    L = ['%s=%r' % (key, value)
14482 
      for key, value in self.__dict__.iteritems()]
14483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14484 
 
14485 
  def __eq__(self, other):
14486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14487 
 
14488 
  def __ne__(self, other):
14489 
    return not (self == other)
14490 
 
14491 
class getItemsForMasterSheet_result:
14492 
  """
14493 
  Attributes:
14494 
   - success
14495 
  """
14496 
 
14497 
  thrift_spec = (
14498 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
14499 
  )
14500 
 
14501 
  def __init__(self, success=None,):
14502 
    self.success = success
14503 
 
14504 
  def read(self, iprot):
14505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14507 
      return
14508 
    iprot.readStructBegin()
14509 
    while True:
14510 
      (fname, ftype, fid) = iprot.readFieldBegin()
14511 
      if ftype == TType.STOP:
14512 
        break
14513 
      if fid == 0:
14514 
        if ftype == TType.LIST:
14515 
          self.success = []
8590 kshitij.so 14516 
          (_etype270, _size267) = iprot.readListBegin()
14517 
          for _i271 in xrange(_size267):
14518 
            _elem272 = Item()
14519 
            _elem272.read(iprot)
14520 
            self.success.append(_elem272)
5944 mandeep.dh 14521 
          iprot.readListEnd()
14522 
        else:
14523 
          iprot.skip(ftype)
14524 
      else:
14525 
        iprot.skip(ftype)
14526 
      iprot.readFieldEnd()
14527 
    iprot.readStructEnd()
14528 
 
14529 
  def write(self, oprot):
14530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14532 
      return
14533 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
14534 
    if self.success is not None:
14535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 14537 
      for iter273 in self.success:
14538 
        iter273.write(oprot)
5944 mandeep.dh 14539 
      oprot.writeListEnd()
14540 
      oprot.writeFieldEnd()
14541 
    oprot.writeFieldStop()
14542 
    oprot.writeStructEnd()
14543 
 
14544 
  def validate(self):
14545 
    return
14546 
 
14547 
 
14548 
  def __repr__(self):
14549 
    L = ['%s=%r' % (key, value)
14550 
      for key, value in self.__dict__.iteritems()]
14551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14552 
 
14553 
  def __eq__(self, other):
14554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14555 
 
14556 
  def __ne__(self, other):
14557 
    return not (self == other)
14558 
 
14559 
class getSimilarItemsCatalogIds_args:
14560 
  """
14561 
  Attributes:
14562 
   - beginIndex
14563 
   - totalItems
14564 
   - itemId
14565 
  """
14566 
 
14567 
  thrift_spec = (
14568 
    None, # 0
14569 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
14570 
    (2, TType.I64, 'totalItems', None, None, ), # 2
14571 
    (3, TType.I64, 'itemId', None, None, ), # 3
14572 
  )
14573 
 
14574 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
14575 
    self.beginIndex = beginIndex
14576 
    self.totalItems = totalItems
14577 
    self.itemId = itemId
14578 
 
14579 
  def read(self, iprot):
14580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14582 
      return
14583 
    iprot.readStructBegin()
14584 
    while True:
14585 
      (fname, ftype, fid) = iprot.readFieldBegin()
14586 
      if ftype == TType.STOP:
14587 
        break
14588 
      if fid == 1:
14589 
        if ftype == TType.I64:
14590 
          self.beginIndex = iprot.readI64();
14591 
        else:
14592 
          iprot.skip(ftype)
14593 
      elif fid == 2:
14594 
        if ftype == TType.I64:
14595 
          self.totalItems = iprot.readI64();
14596 
        else:
14597 
          iprot.skip(ftype)
14598 
      elif fid == 3:
14599 
        if ftype == TType.I64:
14600 
          self.itemId = iprot.readI64();
14601 
        else:
14602 
          iprot.skip(ftype)
14603 
      else:
14604 
        iprot.skip(ftype)
14605 
      iprot.readFieldEnd()
14606 
    iprot.readStructEnd()
14607 
 
14608 
  def write(self, oprot):
14609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14611 
      return
14612 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
14613 
    if self.beginIndex is not None:
14614 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
14615 
      oprot.writeI64(self.beginIndex)
14616 
      oprot.writeFieldEnd()
14617 
    if self.totalItems is not None:
14618 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
14619 
      oprot.writeI64(self.totalItems)
14620 
      oprot.writeFieldEnd()
14621 
    if self.itemId is not None:
14622 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
14623 
      oprot.writeI64(self.itemId)
14624 
      oprot.writeFieldEnd()
14625 
    oprot.writeFieldStop()
14626 
    oprot.writeStructEnd()
14627 
 
14628 
  def validate(self):
14629 
    return
14630 
 
14631 
 
14632 
  def __repr__(self):
14633 
    L = ['%s=%r' % (key, value)
14634 
      for key, value in self.__dict__.iteritems()]
14635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14636 
 
14637 
  def __eq__(self, other):
14638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14639 
 
14640 
  def __ne__(self, other):
14641 
    return not (self == other)
14642 
 
14643 
class getSimilarItemsCatalogIds_result:
14644 
  """
14645 
  Attributes:
14646 
   - success
14647 
  """
14648 
 
14649 
  thrift_spec = (
14650 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
14651 
  )
14652 
 
14653 
  def __init__(self, success=None,):
14654 
    self.success = success
14655 
 
14656 
  def read(self, iprot):
14657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14659 
      return
14660 
    iprot.readStructBegin()
14661 
    while True:
14662 
      (fname, ftype, fid) = iprot.readFieldBegin()
14663 
      if ftype == TType.STOP:
14664 
        break
14665 
      if fid == 0:
14666 
        if ftype == TType.LIST:
14667 
          self.success = []
8590 kshitij.so 14668 
          (_etype277, _size274) = iprot.readListBegin()
14669 
          for _i278 in xrange(_size274):
14670 
            _elem279 = iprot.readI64();
14671 
            self.success.append(_elem279)
5944 mandeep.dh 14672 
          iprot.readListEnd()
14673 
        else:
14674 
          iprot.skip(ftype)
14675 
      else:
14676 
        iprot.skip(ftype)
14677 
      iprot.readFieldEnd()
14678 
    iprot.readStructEnd()
14679 
 
14680 
  def write(self, oprot):
14681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14683 
      return
14684 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
14685 
    if self.success is not None:
14686 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14687 
      oprot.writeListBegin(TType.I64, len(self.success))
8590 kshitij.so 14688 
      for iter280 in self.success:
14689 
        oprot.writeI64(iter280)
5944 mandeep.dh 14690 
      oprot.writeListEnd()
14691 
      oprot.writeFieldEnd()
14692 
    oprot.writeFieldStop()
14693 
    oprot.writeStructEnd()
14694 
 
14695 
  def validate(self):
14696 
    return
14697 
 
14698 
 
14699 
  def __repr__(self):
14700 
    L = ['%s=%r' % (key, value)
14701 
      for key, value in self.__dict__.iteritems()]
14702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14703 
 
14704 
  def __eq__(self, other):
14705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14706 
 
14707 
  def __ne__(self, other):
14708 
    return not (self == other)
14709 
 
14710 
class addProductNotification_args:
14711 
  """
14712 
  Attributes:
14713 
   - itemId
14714 
   - email
14715 
  """
14716 
 
14717 
  thrift_spec = None
14718 
  def __init__(self, itemId=None, email=None,):
14719 
    self.itemId = itemId
14720 
    self.email = email
14721 
 
14722 
  def read(self, iprot):
14723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14725 
      return
14726 
    iprot.readStructBegin()
14727 
    while True:
14728 
      (fname, ftype, fid) = iprot.readFieldBegin()
14729 
      if ftype == TType.STOP:
14730 
        break
14731 
      if fid == -1:
14732 
        if ftype == TType.I64:
14733 
          self.itemId = iprot.readI64();
14734 
        else:
14735 
          iprot.skip(ftype)
14736 
      elif fid == -2:
14737 
        if ftype == TType.STRING:
14738 
          self.email = iprot.readString();
14739 
        else:
14740 
          iprot.skip(ftype)
14741 
      else:
14742 
        iprot.skip(ftype)
14743 
      iprot.readFieldEnd()
14744 
    iprot.readStructEnd()
14745 
 
14746 
  def write(self, oprot):
14747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14749 
      return
14750 
    oprot.writeStructBegin('addProductNotification_args')
14751 
    if self.email is not None:
14752 
      oprot.writeFieldBegin('email', TType.STRING, -2)
14753 
      oprot.writeString(self.email)
14754 
      oprot.writeFieldEnd()
14755 
    if self.itemId is not None:
14756 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
14757 
      oprot.writeI64(self.itemId)
14758 
      oprot.writeFieldEnd()
14759 
    oprot.writeFieldStop()
14760 
    oprot.writeStructEnd()
14761 
 
14762 
  def validate(self):
14763 
    return
14764 
 
14765 
 
14766 
  def __repr__(self):
14767 
    L = ['%s=%r' % (key, value)
14768 
      for key, value in self.__dict__.iteritems()]
14769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14770 
 
14771 
  def __eq__(self, other):
14772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14773 
 
14774 
  def __ne__(self, other):
14775 
    return not (self == other)
14776 
 
14777 
class addProductNotification_result:
14778 
  """
14779 
  Attributes:
14780 
   - success
14781 
  """
14782 
 
14783 
  thrift_spec = (
14784 
    (0, TType.BOOL, 'success', None, None, ), # 0
14785 
  )
14786 
 
14787 
  def __init__(self, success=None,):
14788 
    self.success = success
14789 
 
14790 
  def read(self, iprot):
14791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14793 
      return
14794 
    iprot.readStructBegin()
14795 
    while True:
14796 
      (fname, ftype, fid) = iprot.readFieldBegin()
14797 
      if ftype == TType.STOP:
14798 
        break
14799 
      if fid == 0:
14800 
        if ftype == TType.BOOL:
14801 
          self.success = iprot.readBool();
14802 
        else:
14803 
          iprot.skip(ftype)
14804 
      else:
14805 
        iprot.skip(ftype)
14806 
      iprot.readFieldEnd()
14807 
    iprot.readStructEnd()
14808 
 
14809 
  def write(self, oprot):
14810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14812 
      return
14813 
    oprot.writeStructBegin('addProductNotification_result')
14814 
    if self.success is not None:
14815 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14816 
      oprot.writeBool(self.success)
14817 
      oprot.writeFieldEnd()
14818 
    oprot.writeFieldStop()
14819 
    oprot.writeStructEnd()
14820 
 
14821 
  def validate(self):
14822 
    return
14823 
 
14824 
 
14825 
  def __repr__(self):
14826 
    L = ['%s=%r' % (key, value)
14827 
      for key, value in self.__dict__.iteritems()]
14828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14829 
 
14830 
  def __eq__(self, other):
14831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14832 
 
14833 
  def __ne__(self, other):
14834 
    return not (self == other)
14835 
 
14836 
class sendProductNotifications_args:
14837 
 
14838 
  thrift_spec = (
14839 
  )
14840 
 
14841 
  def read(self, iprot):
14842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14844 
      return
14845 
    iprot.readStructBegin()
14846 
    while True:
14847 
      (fname, ftype, fid) = iprot.readFieldBegin()
14848 
      if ftype == TType.STOP:
14849 
        break
14850 
      else:
14851 
        iprot.skip(ftype)
14852 
      iprot.readFieldEnd()
14853 
    iprot.readStructEnd()
14854 
 
14855 
  def write(self, oprot):
14856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14858 
      return
14859 
    oprot.writeStructBegin('sendProductNotifications_args')
14860 
    oprot.writeFieldStop()
14861 
    oprot.writeStructEnd()
14862 
 
14863 
  def validate(self):
14864 
    return
14865 
 
14866 
 
14867 
  def __repr__(self):
14868 
    L = ['%s=%r' % (key, value)
14869 
      for key, value in self.__dict__.iteritems()]
14870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14871 
 
14872 
  def __eq__(self, other):
14873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14874 
 
14875 
  def __ne__(self, other):
14876 
    return not (self == other)
14877 
 
14878 
class sendProductNotifications_result:
14879 
  """
14880 
  Attributes:
14881 
   - success
14882 
  """
14883 
 
14884 
  thrift_spec = (
14885 
    (0, TType.BOOL, 'success', None, None, ), # 0
14886 
  )
14887 
 
14888 
  def __init__(self, success=None,):
14889 
    self.success = success
14890 
 
14891 
  def read(self, iprot):
14892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14894 
      return
14895 
    iprot.readStructBegin()
14896 
    while True:
14897 
      (fname, ftype, fid) = iprot.readFieldBegin()
14898 
      if ftype == TType.STOP:
14899 
        break
14900 
      if fid == 0:
14901 
        if ftype == TType.BOOL:
14902 
          self.success = iprot.readBool();
14903 
        else:
14904 
          iprot.skip(ftype)
14905 
      else:
14906 
        iprot.skip(ftype)
14907 
      iprot.readFieldEnd()
14908 
    iprot.readStructEnd()
14909 
 
14910 
  def write(self, oprot):
14911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14913 
      return
14914 
    oprot.writeStructBegin('sendProductNotifications_result')
14915 
    if self.success is not None:
14916 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14917 
      oprot.writeBool(self.success)
14918 
      oprot.writeFieldEnd()
14919 
    oprot.writeFieldStop()
14920 
    oprot.writeStructEnd()
14921 
 
14922 
  def validate(self):
14923 
    return
14924 
 
14925 
 
14926 
  def __repr__(self):
14927 
    L = ['%s=%r' % (key, value)
14928 
      for key, value in self.__dict__.iteritems()]
14929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14930 
 
14931 
  def __eq__(self, other):
14932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14933 
 
14934 
  def __ne__(self, other):
14935 
    return not (self == other)
14936 
 
14937 
class getAllBrandsByCategory_args:
14938 
  """
14939 
  Attributes:
14940 
   - categoryId
14941 
  """
14942 
 
14943 
  thrift_spec = (
14944 
    None, # 0
14945 
    (1, TType.I64, 'categoryId', None, None, ), # 1
14946 
  )
14947 
 
14948 
  def __init__(self, categoryId=None,):
14949 
    self.categoryId = categoryId
14950 
 
14951 
  def read(self, iprot):
14952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14954 
      return
14955 
    iprot.readStructBegin()
14956 
    while True:
14957 
      (fname, ftype, fid) = iprot.readFieldBegin()
14958 
      if ftype == TType.STOP:
14959 
        break
14960 
      if fid == 1:
14961 
        if ftype == TType.I64:
14962 
          self.categoryId = iprot.readI64();
14963 
        else:
14964 
          iprot.skip(ftype)
14965 
      else:
14966 
        iprot.skip(ftype)
14967 
      iprot.readFieldEnd()
14968 
    iprot.readStructEnd()
14969 
 
14970 
  def write(self, oprot):
14971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14973 
      return
14974 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
14975 
    if self.categoryId is not None:
14976 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
14977 
      oprot.writeI64(self.categoryId)
14978 
      oprot.writeFieldEnd()
14979 
    oprot.writeFieldStop()
14980 
    oprot.writeStructEnd()
14981 
 
14982 
  def validate(self):
14983 
    return
14984 
 
14985 
 
14986 
  def __repr__(self):
14987 
    L = ['%s=%r' % (key, value)
14988 
      for key, value in self.__dict__.iteritems()]
14989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14990 
 
14991 
  def __eq__(self, other):
14992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14993 
 
14994 
  def __ne__(self, other):
14995 
    return not (self == other)
14996 
 
14997 
class getAllBrandsByCategory_result:
14998 
  """
14999 
  Attributes:
15000 
   - success
15001 
  """
15002 
 
15003 
  thrift_spec = (
15004 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15005 
  )
15006 
 
15007 
  def __init__(self, success=None,):
15008 
    self.success = success
15009 
 
15010 
  def read(self, iprot):
15011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15013 
      return
15014 
    iprot.readStructBegin()
15015 
    while True:
15016 
      (fname, ftype, fid) = iprot.readFieldBegin()
15017 
      if ftype == TType.STOP:
15018 
        break
15019 
      if fid == 0:
15020 
        if ftype == TType.LIST:
15021 
          self.success = []
8590 kshitij.so 15022 
          (_etype284, _size281) = iprot.readListBegin()
15023 
          for _i285 in xrange(_size281):
15024 
            _elem286 = iprot.readString();
15025 
            self.success.append(_elem286)
5944 mandeep.dh 15026 
          iprot.readListEnd()
15027 
        else:
15028 
          iprot.skip(ftype)
15029 
      else:
15030 
        iprot.skip(ftype)
15031 
      iprot.readFieldEnd()
15032 
    iprot.readStructEnd()
15033 
 
15034 
  def write(self, oprot):
15035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15037 
      return
15038 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
15039 
    if self.success is not None:
15040 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15041 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15042 
      for iter287 in self.success:
15043 
        oprot.writeString(iter287)
5944 mandeep.dh 15044 
      oprot.writeListEnd()
15045 
      oprot.writeFieldEnd()
15046 
    oprot.writeFieldStop()
15047 
    oprot.writeStructEnd()
15048 
 
15049 
  def validate(self):
15050 
    return
15051 
 
15052 
 
15053 
  def __repr__(self):
15054 
    L = ['%s=%r' % (key, value)
15055 
      for key, value in self.__dict__.iteritems()]
15056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15057 
 
15058 
  def __eq__(self, other):
15059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15060 
 
15061 
  def __ne__(self, other):
15062 
    return not (self == other)
15063 
 
15064 
class getAllBrands_args:
15065 
 
15066 
  thrift_spec = (
15067 
  )
15068 
 
15069 
  def read(self, iprot):
15070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15072 
      return
15073 
    iprot.readStructBegin()
15074 
    while True:
15075 
      (fname, ftype, fid) = iprot.readFieldBegin()
15076 
      if ftype == TType.STOP:
15077 
        break
15078 
      else:
15079 
        iprot.skip(ftype)
15080 
      iprot.readFieldEnd()
15081 
    iprot.readStructEnd()
15082 
 
15083 
  def write(self, oprot):
15084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15086 
      return
15087 
    oprot.writeStructBegin('getAllBrands_args')
15088 
    oprot.writeFieldStop()
15089 
    oprot.writeStructEnd()
15090 
 
15091 
  def validate(self):
15092 
    return
15093 
 
15094 
 
15095 
  def __repr__(self):
15096 
    L = ['%s=%r' % (key, value)
15097 
      for key, value in self.__dict__.iteritems()]
15098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15099 
 
15100 
  def __eq__(self, other):
15101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15102 
 
15103 
  def __ne__(self, other):
15104 
    return not (self == other)
15105 
 
15106 
class getAllBrands_result:
15107 
  """
15108 
  Attributes:
15109 
   - success
15110 
  """
15111 
 
15112 
  thrift_spec = (
15113 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
15114 
  )
15115 
 
15116 
  def __init__(self, success=None,):
15117 
    self.success = success
15118 
 
15119 
  def read(self, iprot):
15120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15122 
      return
15123 
    iprot.readStructBegin()
15124 
    while True:
15125 
      (fname, ftype, fid) = iprot.readFieldBegin()
15126 
      if ftype == TType.STOP:
15127 
        break
15128 
      if fid == 0:
15129 
        if ftype == TType.LIST:
15130 
          self.success = []
8590 kshitij.so 15131 
          (_etype291, _size288) = iprot.readListBegin()
15132 
          for _i292 in xrange(_size288):
15133 
            _elem293 = iprot.readString();
15134 
            self.success.append(_elem293)
5944 mandeep.dh 15135 
          iprot.readListEnd()
15136 
        else:
15137 
          iprot.skip(ftype)
15138 
      else:
15139 
        iprot.skip(ftype)
15140 
      iprot.readFieldEnd()
15141 
    iprot.readStructEnd()
15142 
 
15143 
  def write(self, oprot):
15144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15146 
      return
15147 
    oprot.writeStructBegin('getAllBrands_result')
15148 
    if self.success is not None:
15149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15150 
      oprot.writeListBegin(TType.STRING, len(self.success))
8590 kshitij.so 15151 
      for iter294 in self.success:
15152 
        oprot.writeString(iter294)
5944 mandeep.dh 15153 
      oprot.writeListEnd()
15154 
      oprot.writeFieldEnd()
15155 
    oprot.writeFieldStop()
15156 
    oprot.writeStructEnd()
15157 
 
15158 
  def validate(self):
15159 
    return
15160 
 
15161 
 
15162 
  def __repr__(self):
15163 
    L = ['%s=%r' % (key, value)
15164 
      for key, value in self.__dict__.iteritems()]
15165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15166 
 
15167 
  def __eq__(self, other):
15168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15169 
 
15170 
  def __ne__(self, other):
15171 
    return not (self == other)
15172 
 
15173 
class getAllSources_args:
15174 
 
15175 
  thrift_spec = (
15176 
  )
15177 
 
15178 
  def read(self, iprot):
15179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15181 
      return
15182 
    iprot.readStructBegin()
15183 
    while True:
15184 
      (fname, ftype, fid) = iprot.readFieldBegin()
15185 
      if ftype == TType.STOP:
15186 
        break
15187 
      else:
15188 
        iprot.skip(ftype)
15189 
      iprot.readFieldEnd()
15190 
    iprot.readStructEnd()
15191 
 
15192 
  def write(self, oprot):
15193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15195 
      return
15196 
    oprot.writeStructBegin('getAllSources_args')
15197 
    oprot.writeFieldStop()
15198 
    oprot.writeStructEnd()
15199 
 
15200 
  def validate(self):
15201 
    return
15202 
 
15203 
 
15204 
  def __repr__(self):
15205 
    L = ['%s=%r' % (key, value)
15206 
      for key, value in self.__dict__.iteritems()]
15207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15208 
 
15209 
  def __eq__(self, other):
15210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15211 
 
15212 
  def __ne__(self, other):
15213 
    return not (self == other)
15214 
 
15215 
class getAllSources_result:
15216 
  """
15217 
  Attributes:
15218 
   - success
15219 
  """
15220 
 
15221 
  thrift_spec = (
15222 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
15223 
  )
15224 
 
15225 
  def __init__(self, success=None,):
15226 
    self.success = success
15227 
 
15228 
  def read(self, iprot):
15229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15231 
      return
15232 
    iprot.readStructBegin()
15233 
    while True:
15234 
      (fname, ftype, fid) = iprot.readFieldBegin()
15235 
      if ftype == TType.STOP:
15236 
        break
15237 
      if fid == 0:
15238 
        if ftype == TType.LIST:
15239 
          self.success = []
8590 kshitij.so 15240 
          (_etype298, _size295) = iprot.readListBegin()
15241 
          for _i299 in xrange(_size295):
15242 
            _elem300 = Source()
15243 
            _elem300.read(iprot)
15244 
            self.success.append(_elem300)
5944 mandeep.dh 15245 
          iprot.readListEnd()
15246 
        else:
15247 
          iprot.skip(ftype)
15248 
      else:
15249 
        iprot.skip(ftype)
15250 
      iprot.readFieldEnd()
15251 
    iprot.readStructEnd()
15252 
 
15253 
  def write(self, oprot):
15254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15256 
      return
15257 
    oprot.writeStructBegin('getAllSources_result')
15258 
    if self.success is not None:
15259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15261 
      for iter301 in self.success:
15262 
        iter301.write(oprot)
5944 mandeep.dh 15263 
      oprot.writeListEnd()
15264 
      oprot.writeFieldEnd()
15265 
    oprot.writeFieldStop()
15266 
    oprot.writeStructEnd()
15267 
 
15268 
  def validate(self):
15269 
    return
15270 
 
15271 
 
15272 
  def __repr__(self):
15273 
    L = ['%s=%r' % (key, value)
15274 
      for key, value in self.__dict__.iteritems()]
15275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15276 
 
15277 
  def __eq__(self, other):
15278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15279 
 
15280 
  def __ne__(self, other):
15281 
    return not (self == other)
15282 
 
15283 
class getItemPricingBySource_args:
15284 
  """
15285 
  Attributes:
15286 
   - itemId
15287 
   - sourceId
15288 
  """
15289 
 
15290 
  thrift_spec = (
15291 
    None, # 0
15292 
    (1, TType.I64, 'itemId', None, None, ), # 1
15293 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15294 
  )
15295 
 
15296 
  def __init__(self, itemId=None, sourceId=None,):
15297 
    self.itemId = itemId
15298 
    self.sourceId = sourceId
15299 
 
15300 
  def read(self, iprot):
15301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15303 
      return
15304 
    iprot.readStructBegin()
15305 
    while True:
15306 
      (fname, ftype, fid) = iprot.readFieldBegin()
15307 
      if ftype == TType.STOP:
15308 
        break
15309 
      if fid == 1:
15310 
        if ftype == TType.I64:
15311 
          self.itemId = iprot.readI64();
15312 
        else:
15313 
          iprot.skip(ftype)
15314 
      elif fid == 2:
15315 
        if ftype == TType.I64:
15316 
          self.sourceId = iprot.readI64();
15317 
        else:
15318 
          iprot.skip(ftype)
15319 
      else:
15320 
        iprot.skip(ftype)
15321 
      iprot.readFieldEnd()
15322 
    iprot.readStructEnd()
15323 
 
15324 
  def write(self, oprot):
15325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15327 
      return
15328 
    oprot.writeStructBegin('getItemPricingBySource_args')
15329 
    if self.itemId is not None:
15330 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15331 
      oprot.writeI64(self.itemId)
15332 
      oprot.writeFieldEnd()
15333 
    if self.sourceId is not None:
15334 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15335 
      oprot.writeI64(self.sourceId)
15336 
      oprot.writeFieldEnd()
15337 
    oprot.writeFieldStop()
15338 
    oprot.writeStructEnd()
15339 
 
15340 
  def validate(self):
15341 
    return
15342 
 
15343 
 
15344 
  def __repr__(self):
15345 
    L = ['%s=%r' % (key, value)
15346 
      for key, value in self.__dict__.iteritems()]
15347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15348 
 
15349 
  def __eq__(self, other):
15350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15351 
 
15352 
  def __ne__(self, other):
15353 
    return not (self == other)
15354 
 
15355 
class getItemPricingBySource_result:
15356 
  """
15357 
  Attributes:
15358 
   - success
15359 
   - cex
15360 
  """
15361 
 
15362 
  thrift_spec = (
15363 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
15364 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15365 
  )
15366 
 
15367 
  def __init__(self, success=None, cex=None,):
15368 
    self.success = success
15369 
    self.cex = cex
15370 
 
15371 
  def read(self, iprot):
15372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15374 
      return
15375 
    iprot.readStructBegin()
15376 
    while True:
15377 
      (fname, ftype, fid) = iprot.readFieldBegin()
15378 
      if ftype == TType.STOP:
15379 
        break
15380 
      if fid == 0:
15381 
        if ftype == TType.STRUCT:
15382 
          self.success = SourceItemPricing()
15383 
          self.success.read(iprot)
15384 
        else:
15385 
          iprot.skip(ftype)
15386 
      elif fid == 1:
15387 
        if ftype == TType.STRUCT:
15388 
          self.cex = CatalogServiceException()
15389 
          self.cex.read(iprot)
15390 
        else:
15391 
          iprot.skip(ftype)
15392 
      else:
15393 
        iprot.skip(ftype)
15394 
      iprot.readFieldEnd()
15395 
    iprot.readStructEnd()
15396 
 
15397 
  def write(self, oprot):
15398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15400 
      return
15401 
    oprot.writeStructBegin('getItemPricingBySource_result')
15402 
    if self.success is not None:
15403 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15404 
      self.success.write(oprot)
15405 
      oprot.writeFieldEnd()
15406 
    if self.cex is not None:
15407 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15408 
      self.cex.write(oprot)
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 
 
15428 
class addSourceItemPricing_args:
15429 
  """
15430 
  Attributes:
15431 
   - sourceItemPricing
15432 
  """
15433 
 
15434 
  thrift_spec = (
15435 
    None, # 0
15436 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
15437 
  )
15438 
 
15439 
  def __init__(self, sourceItemPricing=None,):
15440 
    self.sourceItemPricing = sourceItemPricing
15441 
 
15442 
  def read(self, iprot):
15443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15445 
      return
15446 
    iprot.readStructBegin()
15447 
    while True:
15448 
      (fname, ftype, fid) = iprot.readFieldBegin()
15449 
      if ftype == TType.STOP:
15450 
        break
15451 
      if fid == 1:
15452 
        if ftype == TType.STRUCT:
15453 
          self.sourceItemPricing = SourceItemPricing()
15454 
          self.sourceItemPricing.read(iprot)
15455 
        else:
15456 
          iprot.skip(ftype)
15457 
      else:
15458 
        iprot.skip(ftype)
15459 
      iprot.readFieldEnd()
15460 
    iprot.readStructEnd()
15461 
 
15462 
  def write(self, oprot):
15463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15465 
      return
15466 
    oprot.writeStructBegin('addSourceItemPricing_args')
15467 
    if self.sourceItemPricing is not None:
15468 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
15469 
      self.sourceItemPricing.write(oprot)
15470 
      oprot.writeFieldEnd()
15471 
    oprot.writeFieldStop()
15472 
    oprot.writeStructEnd()
15473 
 
15474 
  def validate(self):
15475 
    return
15476 
 
15477 
 
15478 
  def __repr__(self):
15479 
    L = ['%s=%r' % (key, value)
15480 
      for key, value in self.__dict__.iteritems()]
15481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15482 
 
15483 
  def __eq__(self, other):
15484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15485 
 
15486 
  def __ne__(self, other):
15487 
    return not (self == other)
15488 
 
15489 
class addSourceItemPricing_result:
15490 
  """
15491 
  Attributes:
15492 
   - cex
15493 
  """
15494 
 
15495 
  thrift_spec = (
15496 
    None, # 0
15497 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15498 
  )
15499 
 
15500 
  def __init__(self, cex=None,):
15501 
    self.cex = cex
15502 
 
15503 
  def read(self, iprot):
15504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15506 
      return
15507 
    iprot.readStructBegin()
15508 
    while True:
15509 
      (fname, ftype, fid) = iprot.readFieldBegin()
15510 
      if ftype == TType.STOP:
15511 
        break
15512 
      if fid == 1:
15513 
        if ftype == TType.STRUCT:
15514 
          self.cex = CatalogServiceException()
15515 
          self.cex.read(iprot)
15516 
        else:
15517 
          iprot.skip(ftype)
15518 
      else:
15519 
        iprot.skip(ftype)
15520 
      iprot.readFieldEnd()
15521 
    iprot.readStructEnd()
15522 
 
15523 
  def write(self, oprot):
15524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15526 
      return
15527 
    oprot.writeStructBegin('addSourceItemPricing_result')
15528 
    if self.cex is not None:
15529 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15530 
      self.cex.write(oprot)
15531 
      oprot.writeFieldEnd()
15532 
    oprot.writeFieldStop()
15533 
    oprot.writeStructEnd()
15534 
 
15535 
  def validate(self):
15536 
    return
15537 
 
15538 
 
15539 
  def __repr__(self):
15540 
    L = ['%s=%r' % (key, value)
15541 
      for key, value in self.__dict__.iteritems()]
15542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15543 
 
15544 
  def __eq__(self, other):
15545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15546 
 
15547 
  def __ne__(self, other):
15548 
    return not (self == other)
15549 
 
15550 
class getAllSourcePricing_args:
15551 
  """
15552 
  Attributes:
15553 
   - itemId
15554 
  """
15555 
 
15556 
  thrift_spec = (
15557 
    None, # 0
15558 
    (1, TType.I64, 'itemId', None, None, ), # 1
15559 
  )
15560 
 
15561 
  def __init__(self, itemId=None,):
15562 
    self.itemId = itemId
15563 
 
15564 
  def read(self, iprot):
15565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15567 
      return
15568 
    iprot.readStructBegin()
15569 
    while True:
15570 
      (fname, ftype, fid) = iprot.readFieldBegin()
15571 
      if ftype == TType.STOP:
15572 
        break
15573 
      if fid == 1:
15574 
        if ftype == TType.I64:
15575 
          self.itemId = iprot.readI64();
15576 
        else:
15577 
          iprot.skip(ftype)
15578 
      else:
15579 
        iprot.skip(ftype)
15580 
      iprot.readFieldEnd()
15581 
    iprot.readStructEnd()
15582 
 
15583 
  def write(self, oprot):
15584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15586 
      return
15587 
    oprot.writeStructBegin('getAllSourcePricing_args')
15588 
    if self.itemId is not None:
15589 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15590 
      oprot.writeI64(self.itemId)
15591 
      oprot.writeFieldEnd()
15592 
    oprot.writeFieldStop()
15593 
    oprot.writeStructEnd()
15594 
 
15595 
  def validate(self):
15596 
    return
15597 
 
15598 
 
15599 
  def __repr__(self):
15600 
    L = ['%s=%r' % (key, value)
15601 
      for key, value in self.__dict__.iteritems()]
15602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15603 
 
15604 
  def __eq__(self, other):
15605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15606 
 
15607 
  def __ne__(self, other):
15608 
    return not (self == other)
15609 
 
15610 
class getAllSourcePricing_result:
15611 
  """
15612 
  Attributes:
15613 
   - success
15614 
   - cex
15615 
  """
15616 
 
15617 
  thrift_spec = (
15618 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
15619 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15620 
  )
15621 
 
15622 
  def __init__(self, success=None, cex=None,):
15623 
    self.success = success
15624 
    self.cex = cex
15625 
 
15626 
  def read(self, iprot):
15627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15629 
      return
15630 
    iprot.readStructBegin()
15631 
    while True:
15632 
      (fname, ftype, fid) = iprot.readFieldBegin()
15633 
      if ftype == TType.STOP:
15634 
        break
15635 
      if fid == 0:
15636 
        if ftype == TType.LIST:
15637 
          self.success = []
8590 kshitij.so 15638 
          (_etype305, _size302) = iprot.readListBegin()
15639 
          for _i306 in xrange(_size302):
15640 
            _elem307 = SourceItemPricing()
15641 
            _elem307.read(iprot)
15642 
            self.success.append(_elem307)
5944 mandeep.dh 15643 
          iprot.readListEnd()
15644 
        else:
15645 
          iprot.skip(ftype)
15646 
      elif fid == 1:
15647 
        if ftype == TType.STRUCT:
15648 
          self.cex = CatalogServiceException()
15649 
          self.cex.read(iprot)
15650 
        else:
15651 
          iprot.skip(ftype)
15652 
      else:
15653 
        iprot.skip(ftype)
15654 
      iprot.readFieldEnd()
15655 
    iprot.readStructEnd()
15656 
 
15657 
  def write(self, oprot):
15658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15660 
      return
15661 
    oprot.writeStructBegin('getAllSourcePricing_result')
15662 
    if self.success is not None:
15663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15664 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15665 
      for iter308 in self.success:
15666 
        iter308.write(oprot)
5944 mandeep.dh 15667 
      oprot.writeListEnd()
15668 
      oprot.writeFieldEnd()
15669 
    if self.cex is not None:
15670 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15671 
      self.cex.write(oprot)
15672 
      oprot.writeFieldEnd()
15673 
    oprot.writeFieldStop()
15674 
    oprot.writeStructEnd()
15675 
 
15676 
  def validate(self):
15677 
    return
15678 
 
15679 
 
15680 
  def __repr__(self):
15681 
    L = ['%s=%r' % (key, value)
15682 
      for key, value in self.__dict__.iteritems()]
15683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15684 
 
15685 
  def __eq__(self, other):
15686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15687 
 
15688 
  def __ne__(self, other):
15689 
    return not (self == other)
15690 
 
15691 
class getItemForSource_args:
15692 
  """
15693 
  Attributes:
15694 
   - item_id
15695 
   - sourceId
15696 
  """
15697 
 
15698 
  thrift_spec = (
15699 
    None, # 0
15700 
    (1, TType.I64, 'item_id', None, None, ), # 1
15701 
    (2, TType.I64, 'sourceId', None, None, ), # 2
15702 
  )
15703 
 
15704 
  def __init__(self, item_id=None, sourceId=None,):
15705 
    self.item_id = item_id
15706 
    self.sourceId = sourceId
15707 
 
15708 
  def read(self, iprot):
15709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15711 
      return
15712 
    iprot.readStructBegin()
15713 
    while True:
15714 
      (fname, ftype, fid) = iprot.readFieldBegin()
15715 
      if ftype == TType.STOP:
15716 
        break
15717 
      if fid == 1:
15718 
        if ftype == TType.I64:
15719 
          self.item_id = iprot.readI64();
15720 
        else:
15721 
          iprot.skip(ftype)
15722 
      elif fid == 2:
15723 
        if ftype == TType.I64:
15724 
          self.sourceId = iprot.readI64();
15725 
        else:
15726 
          iprot.skip(ftype)
15727 
      else:
15728 
        iprot.skip(ftype)
15729 
      iprot.readFieldEnd()
15730 
    iprot.readStructEnd()
15731 
 
15732 
  def write(self, oprot):
15733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15735 
      return
15736 
    oprot.writeStructBegin('getItemForSource_args')
15737 
    if self.item_id is not None:
15738 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
15739 
      oprot.writeI64(self.item_id)
15740 
      oprot.writeFieldEnd()
15741 
    if self.sourceId is not None:
15742 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
15743 
      oprot.writeI64(self.sourceId)
15744 
      oprot.writeFieldEnd()
15745 
    oprot.writeFieldStop()
15746 
    oprot.writeStructEnd()
15747 
 
15748 
  def validate(self):
15749 
    return
15750 
 
15751 
 
15752 
  def __repr__(self):
15753 
    L = ['%s=%r' % (key, value)
15754 
      for key, value in self.__dict__.iteritems()]
15755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15756 
 
15757 
  def __eq__(self, other):
15758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15759 
 
15760 
  def __ne__(self, other):
15761 
    return not (self == other)
15762 
 
15763 
class getItemForSource_result:
15764 
  """
15765 
  Attributes:
15766 
   - success
15767 
   - cex
15768 
  """
15769 
 
15770 
  thrift_spec = (
15771 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
15772 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
15773 
  )
15774 
 
15775 
  def __init__(self, success=None, cex=None,):
15776 
    self.success = success
15777 
    self.cex = cex
15778 
 
15779 
  def read(self, iprot):
15780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15782 
      return
15783 
    iprot.readStructBegin()
15784 
    while True:
15785 
      (fname, ftype, fid) = iprot.readFieldBegin()
15786 
      if ftype == TType.STOP:
15787 
        break
15788 
      if fid == 0:
15789 
        if ftype == TType.STRUCT:
15790 
          self.success = Item()
15791 
          self.success.read(iprot)
15792 
        else:
15793 
          iprot.skip(ftype)
15794 
      elif fid == 1:
15795 
        if ftype == TType.STRUCT:
15796 
          self.cex = CatalogServiceException()
15797 
          self.cex.read(iprot)
15798 
        else:
15799 
          iprot.skip(ftype)
15800 
      else:
15801 
        iprot.skip(ftype)
15802 
      iprot.readFieldEnd()
15803 
    iprot.readStructEnd()
15804 
 
15805 
  def write(self, oprot):
15806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15808 
      return
15809 
    oprot.writeStructBegin('getItemForSource_result')
15810 
    if self.success is not None:
15811 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15812 
      self.success.write(oprot)
15813 
      oprot.writeFieldEnd()
15814 
    if self.cex is not None:
15815 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15816 
      self.cex.write(oprot)
15817 
      oprot.writeFieldEnd()
15818 
    oprot.writeFieldStop()
15819 
    oprot.writeStructEnd()
15820 
 
15821 
  def validate(self):
15822 
    return
15823 
 
15824 
 
15825 
  def __repr__(self):
15826 
    L = ['%s=%r' % (key, value)
15827 
      for key, value in self.__dict__.iteritems()]
15828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15829 
 
15830 
  def __eq__(self, other):
15831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15832 
 
15833 
  def __ne__(self, other):
15834 
    return not (self == other)
15835 
 
15836 
class searchItemsInRange_args:
15837 
  """
15838 
  Attributes:
15839 
   - searchTerms
15840 
   - offset
15841 
   - limit
15842 
  """
15843 
 
15844 
  thrift_spec = (
15845 
    None, # 0
15846 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
15847 
    (2, TType.I64, 'offset', None, None, ), # 2
15848 
    (3, TType.I64, 'limit', None, None, ), # 3
15849 
  )
15850 
 
15851 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
15852 
    self.searchTerms = searchTerms
15853 
    self.offset = offset
15854 
    self.limit = limit
15855 
 
15856 
  def read(self, iprot):
15857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15859 
      return
15860 
    iprot.readStructBegin()
15861 
    while True:
15862 
      (fname, ftype, fid) = iprot.readFieldBegin()
15863 
      if ftype == TType.STOP:
15864 
        break
15865 
      if fid == 1:
15866 
        if ftype == TType.LIST:
15867 
          self.searchTerms = []
8590 kshitij.so 15868 
          (_etype312, _size309) = iprot.readListBegin()
15869 
          for _i313 in xrange(_size309):
15870 
            _elem314 = iprot.readString();
15871 
            self.searchTerms.append(_elem314)
5944 mandeep.dh 15872 
          iprot.readListEnd()
15873 
        else:
15874 
          iprot.skip(ftype)
15875 
      elif fid == 2:
15876 
        if ftype == TType.I64:
15877 
          self.offset = iprot.readI64();
15878 
        else:
15879 
          iprot.skip(ftype)
15880 
      elif fid == 3:
15881 
        if ftype == TType.I64:
15882 
          self.limit = iprot.readI64();
15883 
        else:
15884 
          iprot.skip(ftype)
15885 
      else:
15886 
        iprot.skip(ftype)
15887 
      iprot.readFieldEnd()
15888 
    iprot.readStructEnd()
15889 
 
15890 
  def write(self, oprot):
15891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15893 
      return
15894 
    oprot.writeStructBegin('searchItemsInRange_args')
15895 
    if self.searchTerms is not None:
15896 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
15897 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 15898 
      for iter315 in self.searchTerms:
15899 
        oprot.writeString(iter315)
5944 mandeep.dh 15900 
      oprot.writeListEnd()
15901 
      oprot.writeFieldEnd()
15902 
    if self.offset is not None:
15903 
      oprot.writeFieldBegin('offset', TType.I64, 2)
15904 
      oprot.writeI64(self.offset)
15905 
      oprot.writeFieldEnd()
15906 
    if self.limit is not None:
15907 
      oprot.writeFieldBegin('limit', TType.I64, 3)
15908 
      oprot.writeI64(self.limit)
15909 
      oprot.writeFieldEnd()
15910 
    oprot.writeFieldStop()
15911 
    oprot.writeStructEnd()
15912 
 
15913 
  def validate(self):
15914 
    return
15915 
 
15916 
 
15917 
  def __repr__(self):
15918 
    L = ['%s=%r' % (key, value)
15919 
      for key, value in self.__dict__.iteritems()]
15920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15921 
 
15922 
  def __eq__(self, other):
15923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15924 
 
15925 
  def __ne__(self, other):
15926 
    return not (self == other)
15927 
 
15928 
class searchItemsInRange_result:
15929 
  """
15930 
  Attributes:
15931 
   - success
15932 
  """
15933 
 
15934 
  thrift_spec = (
15935 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15936 
  )
15937 
 
15938 
  def __init__(self, success=None,):
15939 
    self.success = success
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 == 0:
15951 
        if ftype == TType.LIST:
15952 
          self.success = []
8590 kshitij.so 15953 
          (_etype319, _size316) = iprot.readListBegin()
15954 
          for _i320 in xrange(_size316):
15955 
            _elem321 = Item()
15956 
            _elem321.read(iprot)
15957 
            self.success.append(_elem321)
5944 mandeep.dh 15958 
          iprot.readListEnd()
15959 
        else:
15960 
          iprot.skip(ftype)
15961 
      else:
15962 
        iprot.skip(ftype)
15963 
      iprot.readFieldEnd()
15964 
    iprot.readStructEnd()
15965 
 
15966 
  def write(self, oprot):
15967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15969 
      return
15970 
    oprot.writeStructBegin('searchItemsInRange_result')
15971 
    if self.success is not None:
15972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 15974 
      for iter322 in self.success:
15975 
        iter322.write(oprot)
5944 mandeep.dh 15976 
      oprot.writeListEnd()
15977 
      oprot.writeFieldEnd()
15978 
    oprot.writeFieldStop()
15979 
    oprot.writeStructEnd()
15980 
 
15981 
  def validate(self):
15982 
    return
15983 
 
15984 
 
15985 
  def __repr__(self):
15986 
    L = ['%s=%r' % (key, value)
15987 
      for key, value in self.__dict__.iteritems()]
15988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15989 
 
15990 
  def __eq__(self, other):
15991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15992 
 
15993 
  def __ne__(self, other):
15994 
    return not (self == other)
15995 
 
15996 
class getSearchResultCount_args:
15997 
  """
15998 
  Attributes:
15999 
   - searchTerms
16000 
  """
16001 
 
16002 
  thrift_spec = (
16003 
    None, # 0
16004 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
16005 
  )
16006 
 
16007 
  def __init__(self, searchTerms=None,):
16008 
    self.searchTerms = searchTerms
16009 
 
16010 
  def read(self, iprot):
16011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16013 
      return
16014 
    iprot.readStructBegin()
16015 
    while True:
16016 
      (fname, ftype, fid) = iprot.readFieldBegin()
16017 
      if ftype == TType.STOP:
16018 
        break
16019 
      if fid == 1:
16020 
        if ftype == TType.LIST:
16021 
          self.searchTerms = []
8590 kshitij.so 16022 
          (_etype326, _size323) = iprot.readListBegin()
16023 
          for _i327 in xrange(_size323):
16024 
            _elem328 = iprot.readString();
16025 
            self.searchTerms.append(_elem328)
5944 mandeep.dh 16026 
          iprot.readListEnd()
16027 
        else:
16028 
          iprot.skip(ftype)
16029 
      else:
16030 
        iprot.skip(ftype)
16031 
      iprot.readFieldEnd()
16032 
    iprot.readStructEnd()
16033 
 
16034 
  def write(self, oprot):
16035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16037 
      return
16038 
    oprot.writeStructBegin('getSearchResultCount_args')
16039 
    if self.searchTerms is not None:
16040 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
16041 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
8590 kshitij.so 16042 
      for iter329 in self.searchTerms:
16043 
        oprot.writeString(iter329)
5944 mandeep.dh 16044 
      oprot.writeListEnd()
16045 
      oprot.writeFieldEnd()
16046 
    oprot.writeFieldStop()
16047 
    oprot.writeStructEnd()
16048 
 
16049 
  def validate(self):
16050 
    return
16051 
 
16052 
 
16053 
  def __repr__(self):
16054 
    L = ['%s=%r' % (key, value)
16055 
      for key, value in self.__dict__.iteritems()]
16056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16057 
 
16058 
  def __eq__(self, other):
16059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16060 
 
16061 
  def __ne__(self, other):
16062 
    return not (self == other)
16063 
 
16064 
class getSearchResultCount_result:
16065 
  """
16066 
  Attributes:
16067 
   - success
16068 
  """
16069 
 
16070 
  thrift_spec = (
16071 
    (0, TType.I32, 'success', None, None, ), # 0
16072 
  )
16073 
 
16074 
  def __init__(self, success=None,):
16075 
    self.success = success
16076 
 
16077 
  def read(self, iprot):
16078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16080 
      return
16081 
    iprot.readStructBegin()
16082 
    while True:
16083 
      (fname, ftype, fid) = iprot.readFieldBegin()
16084 
      if ftype == TType.STOP:
16085 
        break
16086 
      if fid == 0:
16087 
        if ftype == TType.I32:
16088 
          self.success = iprot.readI32();
16089 
        else:
16090 
          iprot.skip(ftype)
16091 
      else:
16092 
        iprot.skip(ftype)
16093 
      iprot.readFieldEnd()
16094 
    iprot.readStructEnd()
16095 
 
16096 
  def write(self, oprot):
16097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16099 
      return
16100 
    oprot.writeStructBegin('getSearchResultCount_result')
16101 
    if self.success is not None:
16102 
      oprot.writeFieldBegin('success', TType.I32, 0)
16103 
      oprot.writeI32(self.success)
16104 
      oprot.writeFieldEnd()
16105 
    oprot.writeFieldStop()
16106 
    oprot.writeStructEnd()
16107 
 
16108 
  def validate(self):
16109 
    return
16110 
 
16111 
 
16112 
  def __repr__(self):
16113 
    L = ['%s=%r' % (key, value)
16114 
      for key, value in self.__dict__.iteritems()]
16115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16116 
 
16117 
  def __eq__(self, other):
16118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16119 
 
16120 
  def __ne__(self, other):
16121 
    return not (self == other)
16122 
 
16123 
class getProductNotifications_args:
16124 
  """
16125 
  Attributes:
16126 
   - startDateTime
16127 
  """
16128 
 
16129 
  thrift_spec = (
16130 
    None, # 0
16131 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
16132 
  )
16133 
 
16134 
  def __init__(self, startDateTime=None,):
16135 
    self.startDateTime = startDateTime
16136 
 
16137 
  def read(self, iprot):
16138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16140 
      return
16141 
    iprot.readStructBegin()
16142 
    while True:
16143 
      (fname, ftype, fid) = iprot.readFieldBegin()
16144 
      if ftype == TType.STOP:
16145 
        break
16146 
      if fid == 1:
16147 
        if ftype == TType.I64:
16148 
          self.startDateTime = iprot.readI64();
16149 
        else:
16150 
          iprot.skip(ftype)
16151 
      else:
16152 
        iprot.skip(ftype)
16153 
      iprot.readFieldEnd()
16154 
    iprot.readStructEnd()
16155 
 
16156 
  def write(self, oprot):
16157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16159 
      return
16160 
    oprot.writeStructBegin('getProductNotifications_args')
16161 
    if self.startDateTime is not None:
16162 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16163 
      oprot.writeI64(self.startDateTime)
16164 
      oprot.writeFieldEnd()
16165 
    oprot.writeFieldStop()
16166 
    oprot.writeStructEnd()
16167 
 
16168 
  def validate(self):
16169 
    return
16170 
 
16171 
 
16172 
  def __repr__(self):
16173 
    L = ['%s=%r' % (key, value)
16174 
      for key, value in self.__dict__.iteritems()]
16175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16176 
 
16177 
  def __eq__(self, other):
16178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16179 
 
16180 
  def __ne__(self, other):
16181 
    return not (self == other)
16182 
 
16183 
class getProductNotifications_result:
16184 
  """
16185 
  Attributes:
16186 
   - success
16187 
  """
16188 
 
16189 
  thrift_spec = (
16190 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
16191 
  )
16192 
 
16193 
  def __init__(self, success=None,):
16194 
    self.success = success
16195 
 
16196 
  def read(self, iprot):
16197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16199 
      return
16200 
    iprot.readStructBegin()
16201 
    while True:
16202 
      (fname, ftype, fid) = iprot.readFieldBegin()
16203 
      if ftype == TType.STOP:
16204 
        break
16205 
      if fid == 0:
16206 
        if ftype == TType.LIST:
16207 
          self.success = []
8590 kshitij.so 16208 
          (_etype333, _size330) = iprot.readListBegin()
16209 
          for _i334 in xrange(_size330):
16210 
            _elem335 = ProductNotificationRequest()
16211 
            _elem335.read(iprot)
16212 
            self.success.append(_elem335)
5944 mandeep.dh 16213 
          iprot.readListEnd()
16214 
        else:
16215 
          iprot.skip(ftype)
16216 
      else:
16217 
        iprot.skip(ftype)
16218 
      iprot.readFieldEnd()
16219 
    iprot.readStructEnd()
16220 
 
16221 
  def write(self, oprot):
16222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16224 
      return
16225 
    oprot.writeStructBegin('getProductNotifications_result')
16226 
    if self.success is not None:
16227 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16228 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16229 
      for iter336 in self.success:
16230 
        iter336.write(oprot)
5944 mandeep.dh 16231 
      oprot.writeListEnd()
16232 
      oprot.writeFieldEnd()
16233 
    oprot.writeFieldStop()
16234 
    oprot.writeStructEnd()
16235 
 
16236 
  def validate(self):
16237 
    return
16238 
 
16239 
 
16240 
  def __repr__(self):
16241 
    L = ['%s=%r' % (key, value)
16242 
      for key, value in self.__dict__.iteritems()]
16243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16244 
 
16245 
  def __eq__(self, other):
16246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16247 
 
16248 
  def __ne__(self, other):
16249 
    return not (self == other)
16250 
 
16251 
class getProductNotificationRequestCount_args:
16252 
  """
16253 
  Attributes:
16254 
   - startDateTime
7897 amar.kumar 16255 
   - categoryId
5944 mandeep.dh 16256 
  """
16257 
 
16258 
  thrift_spec = (
16259 
    None, # 0
16260 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
7897 amar.kumar 16261 
    (2, TType.I64, 'categoryId', None, None, ), # 2
5944 mandeep.dh 16262 
  )
16263 
 
7897 amar.kumar 16264 
  def __init__(self, startDateTime=None, categoryId=None,):
5944 mandeep.dh 16265 
    self.startDateTime = startDateTime
7897 amar.kumar 16266 
    self.categoryId = categoryId
5944 mandeep.dh 16267 
 
16268 
  def read(self, iprot):
16269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16271 
      return
16272 
    iprot.readStructBegin()
16273 
    while True:
16274 
      (fname, ftype, fid) = iprot.readFieldBegin()
16275 
      if ftype == TType.STOP:
16276 
        break
16277 
      if fid == 1:
16278 
        if ftype == TType.I64:
16279 
          self.startDateTime = iprot.readI64();
16280 
        else:
16281 
          iprot.skip(ftype)
7897 amar.kumar 16282 
      elif fid == 2:
16283 
        if ftype == TType.I64:
16284 
          self.categoryId = iprot.readI64();
16285 
        else:
16286 
          iprot.skip(ftype)
5944 mandeep.dh 16287 
      else:
16288 
        iprot.skip(ftype)
16289 
      iprot.readFieldEnd()
16290 
    iprot.readStructEnd()
16291 
 
16292 
  def write(self, oprot):
16293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16295 
      return
16296 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
16297 
    if self.startDateTime is not None:
16298 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
16299 
      oprot.writeI64(self.startDateTime)
16300 
      oprot.writeFieldEnd()
7897 amar.kumar 16301 
    if self.categoryId is not None:
16302 
      oprot.writeFieldBegin('categoryId', TType.I64, 2)
16303 
      oprot.writeI64(self.categoryId)
16304 
      oprot.writeFieldEnd()
5944 mandeep.dh 16305 
    oprot.writeFieldStop()
16306 
    oprot.writeStructEnd()
16307 
 
16308 
  def validate(self):
16309 
    return
16310 
 
16311 
 
16312 
  def __repr__(self):
16313 
    L = ['%s=%r' % (key, value)
16314 
      for key, value in self.__dict__.iteritems()]
16315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16316 
 
16317 
  def __eq__(self, other):
16318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16319 
 
16320 
  def __ne__(self, other):
16321 
    return not (self == other)
16322 
 
16323 
class getProductNotificationRequestCount_result:
16324 
  """
16325 
  Attributes:
16326 
   - success
16327 
  """
16328 
 
16329 
  thrift_spec = (
16330 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
16331 
  )
16332 
 
16333 
  def __init__(self, success=None,):
16334 
    self.success = success
16335 
 
16336 
  def read(self, iprot):
16337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16339 
      return
16340 
    iprot.readStructBegin()
16341 
    while True:
16342 
      (fname, ftype, fid) = iprot.readFieldBegin()
16343 
      if ftype == TType.STOP:
16344 
        break
16345 
      if fid == 0:
16346 
        if ftype == TType.LIST:
16347 
          self.success = []
8590 kshitij.so 16348 
          (_etype340, _size337) = iprot.readListBegin()
16349 
          for _i341 in xrange(_size337):
16350 
            _elem342 = ProductNotificationRequestCount()
16351 
            _elem342.read(iprot)
16352 
            self.success.append(_elem342)
5944 mandeep.dh 16353 
          iprot.readListEnd()
16354 
        else:
16355 
          iprot.skip(ftype)
16356 
      else:
16357 
        iprot.skip(ftype)
16358 
      iprot.readFieldEnd()
16359 
    iprot.readStructEnd()
16360 
 
16361 
  def write(self, oprot):
16362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16364 
      return
16365 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
16366 
    if self.success is not None:
16367 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16368 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 16369 
      for iter343 in self.success:
16370 
        iter343.write(oprot)
5944 mandeep.dh 16371 
      oprot.writeListEnd()
16372 
      oprot.writeFieldEnd()
16373 
    oprot.writeFieldStop()
16374 
    oprot.writeStructEnd()
16375 
 
16376 
  def validate(self):
16377 
    return
16378 
 
16379 
 
16380 
  def __repr__(self):
16381 
    L = ['%s=%r' % (key, value)
16382 
      for key, value in self.__dict__.iteritems()]
16383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16384 
 
16385 
  def __eq__(self, other):
16386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16387 
 
16388 
  def __ne__(self, other):
16389 
    return not (self == other)
16390 
 
16391 
class addAuthorizationLog_args:
16392 
  """
16393 
  Attributes:
16394 
   - itemId
16395 
   - username
16396 
   - reason
16397 
  """
16398 
 
16399 
  thrift_spec = (
16400 
    None, # 0
16401 
    (1, TType.I64, 'itemId', None, None, ), # 1
16402 
    (2, TType.STRING, 'username', None, None, ), # 2
16403 
    (3, TType.STRING, 'reason', None, None, ), # 3
16404 
  )
16405 
 
16406 
  def __init__(self, itemId=None, username=None, reason=None,):
16407 
    self.itemId = itemId
16408 
    self.username = username
16409 
    self.reason = reason
16410 
 
16411 
  def read(self, iprot):
16412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16414 
      return
16415 
    iprot.readStructBegin()
16416 
    while True:
16417 
      (fname, ftype, fid) = iprot.readFieldBegin()
16418 
      if ftype == TType.STOP:
16419 
        break
16420 
      if fid == 1:
16421 
        if ftype == TType.I64:
16422 
          self.itemId = iprot.readI64();
16423 
        else:
16424 
          iprot.skip(ftype)
16425 
      elif fid == 2:
16426 
        if ftype == TType.STRING:
16427 
          self.username = iprot.readString();
16428 
        else:
16429 
          iprot.skip(ftype)
16430 
      elif fid == 3:
16431 
        if ftype == TType.STRING:
16432 
          self.reason = iprot.readString();
16433 
        else:
16434 
          iprot.skip(ftype)
16435 
      else:
16436 
        iprot.skip(ftype)
16437 
      iprot.readFieldEnd()
16438 
    iprot.readStructEnd()
16439 
 
16440 
  def write(self, oprot):
16441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16443 
      return
16444 
    oprot.writeStructBegin('addAuthorizationLog_args')
16445 
    if self.itemId is not None:
16446 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16447 
      oprot.writeI64(self.itemId)
16448 
      oprot.writeFieldEnd()
16449 
    if self.username is not None:
16450 
      oprot.writeFieldBegin('username', TType.STRING, 2)
16451 
      oprot.writeString(self.username)
16452 
      oprot.writeFieldEnd()
16453 
    if self.reason is not None:
16454 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
16455 
      oprot.writeString(self.reason)
16456 
      oprot.writeFieldEnd()
16457 
    oprot.writeFieldStop()
16458 
    oprot.writeStructEnd()
16459 
 
16460 
  def validate(self):
16461 
    return
16462 
 
16463 
 
16464 
  def __repr__(self):
16465 
    L = ['%s=%r' % (key, value)
16466 
      for key, value in self.__dict__.iteritems()]
16467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16468 
 
16469 
  def __eq__(self, other):
16470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16471 
 
16472 
  def __ne__(self, other):
16473 
    return not (self == other)
16474 
 
16475 
class addAuthorizationLog_result:
16476 
  """
16477 
  Attributes:
16478 
   - success
16479 
   - cex
16480 
  """
16481 
 
16482 
  thrift_spec = (
16483 
    (0, TType.BOOL, 'success', None, None, ), # 0
16484 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16485 
  )
16486 
 
16487 
  def __init__(self, success=None, cex=None,):
16488 
    self.success = success
16489 
    self.cex = cex
16490 
 
16491 
  def read(self, iprot):
16492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16494 
      return
16495 
    iprot.readStructBegin()
16496 
    while True:
16497 
      (fname, ftype, fid) = iprot.readFieldBegin()
16498 
      if ftype == TType.STOP:
16499 
        break
16500 
      if fid == 0:
16501 
        if ftype == TType.BOOL:
16502 
          self.success = iprot.readBool();
16503 
        else:
16504 
          iprot.skip(ftype)
16505 
      elif fid == 1:
16506 
        if ftype == TType.STRUCT:
16507 
          self.cex = CatalogServiceException()
16508 
          self.cex.read(iprot)
16509 
        else:
16510 
          iprot.skip(ftype)
16511 
      else:
16512 
        iprot.skip(ftype)
16513 
      iprot.readFieldEnd()
16514 
    iprot.readStructEnd()
16515 
 
16516 
  def write(self, oprot):
16517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16519 
      return
16520 
    oprot.writeStructBegin('addAuthorizationLog_result')
16521 
    if self.success is not None:
16522 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16523 
      oprot.writeBool(self.success)
16524 
      oprot.writeFieldEnd()
16525 
    if self.cex is not None:
16526 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16527 
      self.cex.write(oprot)
16528 
      oprot.writeFieldEnd()
16529 
    oprot.writeFieldStop()
16530 
    oprot.writeStructEnd()
16531 
 
16532 
  def validate(self):
16533 
    return
16534 
 
16535 
 
16536 
  def __repr__(self):
16537 
    L = ['%s=%r' % (key, value)
16538 
      for key, value in self.__dict__.iteritems()]
16539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16540 
 
16541 
  def __eq__(self, other):
16542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16543 
 
16544 
  def __ne__(self, other):
16545 
    return not (self == other)
16546 
 
16547 
class addupdateVoucherForItem_args:
16548 
  """
16549 
  Attributes:
16550 
   - catalog_item_id
16551 
   - voucherType
16552 
   - voucherAmount
16553 
  """
16554 
 
16555 
  thrift_spec = (
16556 
    None, # 0
16557 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16558 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16559 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
16560 
  )
16561 
 
16562 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
16563 
    self.catalog_item_id = catalog_item_id
16564 
    self.voucherType = voucherType
16565 
    self.voucherAmount = voucherAmount
16566 
 
16567 
  def read(self, iprot):
16568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16570 
      return
16571 
    iprot.readStructBegin()
16572 
    while True:
16573 
      (fname, ftype, fid) = iprot.readFieldBegin()
16574 
      if ftype == TType.STOP:
16575 
        break
16576 
      if fid == 1:
16577 
        if ftype == TType.I64:
16578 
          self.catalog_item_id = iprot.readI64();
16579 
        else:
16580 
          iprot.skip(ftype)
16581 
      elif fid == 2:
16582 
        if ftype == TType.I64:
16583 
          self.voucherType = iprot.readI64();
16584 
        else:
16585 
          iprot.skip(ftype)
16586 
      elif fid == 3:
16587 
        if ftype == TType.I64:
16588 
          self.voucherAmount = iprot.readI64();
16589 
        else:
16590 
          iprot.skip(ftype)
16591 
      else:
16592 
        iprot.skip(ftype)
16593 
      iprot.readFieldEnd()
16594 
    iprot.readStructEnd()
16595 
 
16596 
  def write(self, oprot):
16597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16599 
      return
16600 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
16601 
    if self.catalog_item_id is not None:
16602 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16603 
      oprot.writeI64(self.catalog_item_id)
16604 
      oprot.writeFieldEnd()
16605 
    if self.voucherType is not None:
16606 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16607 
      oprot.writeI64(self.voucherType)
16608 
      oprot.writeFieldEnd()
16609 
    if self.voucherAmount is not None:
16610 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
16611 
      oprot.writeI64(self.voucherAmount)
16612 
      oprot.writeFieldEnd()
16613 
    oprot.writeFieldStop()
16614 
    oprot.writeStructEnd()
16615 
 
16616 
  def validate(self):
16617 
    return
16618 
 
16619 
 
16620 
  def __repr__(self):
16621 
    L = ['%s=%r' % (key, value)
16622 
      for key, value in self.__dict__.iteritems()]
16623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16624 
 
16625 
  def __eq__(self, other):
16626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16627 
 
16628 
  def __ne__(self, other):
16629 
    return not (self == other)
16630 
 
16631 
class addupdateVoucherForItem_result:
16632 
  """
16633 
  Attributes:
16634 
   - success
16635 
   - cex
16636 
  """
16637 
 
16638 
  thrift_spec = (
16639 
    (0, TType.BOOL, 'success', None, None, ), # 0
16640 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16641 
  )
16642 
 
16643 
  def __init__(self, success=None, cex=None,):
16644 
    self.success = success
16645 
    self.cex = cex
16646 
 
16647 
  def read(self, iprot):
16648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16650 
      return
16651 
    iprot.readStructBegin()
16652 
    while True:
16653 
      (fname, ftype, fid) = iprot.readFieldBegin()
16654 
      if ftype == TType.STOP:
16655 
        break
16656 
      if fid == 0:
16657 
        if ftype == TType.BOOL:
16658 
          self.success = iprot.readBool();
16659 
        else:
16660 
          iprot.skip(ftype)
16661 
      elif fid == 1:
16662 
        if ftype == TType.STRUCT:
16663 
          self.cex = CatalogServiceException()
16664 
          self.cex.read(iprot)
16665 
        else:
16666 
          iprot.skip(ftype)
16667 
      else:
16668 
        iprot.skip(ftype)
16669 
      iprot.readFieldEnd()
16670 
    iprot.readStructEnd()
16671 
 
16672 
  def write(self, oprot):
16673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16675 
      return
16676 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
16677 
    if self.success is not None:
16678 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16679 
      oprot.writeBool(self.success)
16680 
      oprot.writeFieldEnd()
16681 
    if self.cex is not None:
16682 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16683 
      self.cex.write(oprot)
16684 
      oprot.writeFieldEnd()
16685 
    oprot.writeFieldStop()
16686 
    oprot.writeStructEnd()
16687 
 
16688 
  def validate(self):
16689 
    return
16690 
 
16691 
 
16692 
  def __repr__(self):
16693 
    L = ['%s=%r' % (key, value)
16694 
      for key, value in self.__dict__.iteritems()]
16695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16696 
 
16697 
  def __eq__(self, other):
16698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16699 
 
16700 
  def __ne__(self, other):
16701 
    return not (self == other)
16702 
 
16703 
class deleteVoucherForItem_args:
16704 
  """
16705 
  Attributes:
16706 
   - catalog_item_id
16707 
   - voucherType
16708 
  """
16709 
 
16710 
  thrift_spec = (
16711 
    None, # 0
16712 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
16713 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16714 
  )
16715 
 
16716 
  def __init__(self, catalog_item_id=None, voucherType=None,):
16717 
    self.catalog_item_id = catalog_item_id
16718 
    self.voucherType = voucherType
16719 
 
16720 
  def read(self, iprot):
16721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16723 
      return
16724 
    iprot.readStructBegin()
16725 
    while True:
16726 
      (fname, ftype, fid) = iprot.readFieldBegin()
16727 
      if ftype == TType.STOP:
16728 
        break
16729 
      if fid == 1:
16730 
        if ftype == TType.I64:
16731 
          self.catalog_item_id = iprot.readI64();
16732 
        else:
16733 
          iprot.skip(ftype)
16734 
      elif fid == 2:
16735 
        if ftype == TType.I64:
16736 
          self.voucherType = iprot.readI64();
16737 
        else:
16738 
          iprot.skip(ftype)
16739 
      else:
16740 
        iprot.skip(ftype)
16741 
      iprot.readFieldEnd()
16742 
    iprot.readStructEnd()
16743 
 
16744 
  def write(self, oprot):
16745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16747 
      return
16748 
    oprot.writeStructBegin('deleteVoucherForItem_args')
16749 
    if self.catalog_item_id is not None:
16750 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
16751 
      oprot.writeI64(self.catalog_item_id)
16752 
      oprot.writeFieldEnd()
16753 
    if self.voucherType is not None:
16754 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16755 
      oprot.writeI64(self.voucherType)
16756 
      oprot.writeFieldEnd()
16757 
    oprot.writeFieldStop()
16758 
    oprot.writeStructEnd()
16759 
 
16760 
  def validate(self):
16761 
    return
16762 
 
16763 
 
16764 
  def __repr__(self):
16765 
    L = ['%s=%r' % (key, value)
16766 
      for key, value in self.__dict__.iteritems()]
16767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16768 
 
16769 
  def __eq__(self, other):
16770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16771 
 
16772 
  def __ne__(self, other):
16773 
    return not (self == other)
16774 
 
16775 
class deleteVoucherForItem_result:
16776 
  """
16777 
  Attributes:
16778 
   - success
16779 
   - cex
16780 
  """
16781 
 
16782 
  thrift_spec = (
16783 
    (0, TType.BOOL, 'success', None, None, ), # 0
16784 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
16785 
  )
16786 
 
16787 
  def __init__(self, success=None, cex=None,):
16788 
    self.success = success
16789 
    self.cex = cex
16790 
 
16791 
  def read(self, iprot):
16792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16794 
      return
16795 
    iprot.readStructBegin()
16796 
    while True:
16797 
      (fname, ftype, fid) = iprot.readFieldBegin()
16798 
      if ftype == TType.STOP:
16799 
        break
16800 
      if fid == 0:
16801 
        if ftype == TType.BOOL:
16802 
          self.success = iprot.readBool();
16803 
        else:
16804 
          iprot.skip(ftype)
16805 
      elif fid == 1:
16806 
        if ftype == TType.STRUCT:
16807 
          self.cex = CatalogServiceException()
16808 
          self.cex.read(iprot)
16809 
        else:
16810 
          iprot.skip(ftype)
16811 
      else:
16812 
        iprot.skip(ftype)
16813 
      iprot.readFieldEnd()
16814 
    iprot.readStructEnd()
16815 
 
16816 
  def write(self, oprot):
16817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16819 
      return
16820 
    oprot.writeStructBegin('deleteVoucherForItem_result')
16821 
    if self.success is not None:
16822 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16823 
      oprot.writeBool(self.success)
16824 
      oprot.writeFieldEnd()
16825 
    if self.cex is not None:
16826 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
16827 
      self.cex.write(oprot)
16828 
      oprot.writeFieldEnd()
16829 
    oprot.writeFieldStop()
16830 
    oprot.writeStructEnd()
16831 
 
16832 
  def validate(self):
16833 
    return
16834 
 
16835 
 
16836 
  def __repr__(self):
16837 
    L = ['%s=%r' % (key, value)
16838 
      for key, value in self.__dict__.iteritems()]
16839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16840 
 
16841 
  def __eq__(self, other):
16842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16843 
 
16844 
  def __ne__(self, other):
16845 
    return not (self == other)
16846 
 
16847 
class getVoucherAmount_args:
16848 
  """
16849 
  Attributes:
16850 
   - itemId
16851 
   - voucherType
16852 
  """
16853 
 
16854 
  thrift_spec = (
16855 
    None, # 0
16856 
    (1, TType.I64, 'itemId', None, None, ), # 1
16857 
    (2, TType.I64, 'voucherType', None, None, ), # 2
16858 
  )
16859 
 
16860 
  def __init__(self, itemId=None, voucherType=None,):
16861 
    self.itemId = itemId
16862 
    self.voucherType = voucherType
16863 
 
16864 
  def read(self, iprot):
16865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16867 
      return
16868 
    iprot.readStructBegin()
16869 
    while True:
16870 
      (fname, ftype, fid) = iprot.readFieldBegin()
16871 
      if ftype == TType.STOP:
16872 
        break
16873 
      if fid == 1:
16874 
        if ftype == TType.I64:
16875 
          self.itemId = iprot.readI64();
16876 
        else:
16877 
          iprot.skip(ftype)
16878 
      elif fid == 2:
16879 
        if ftype == TType.I64:
16880 
          self.voucherType = iprot.readI64();
16881 
        else:
16882 
          iprot.skip(ftype)
16883 
      else:
16884 
        iprot.skip(ftype)
16885 
      iprot.readFieldEnd()
16886 
    iprot.readStructEnd()
16887 
 
16888 
  def write(self, oprot):
16889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16891 
      return
16892 
    oprot.writeStructBegin('getVoucherAmount_args')
16893 
    if self.itemId is not None:
16894 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16895 
      oprot.writeI64(self.itemId)
16896 
      oprot.writeFieldEnd()
16897 
    if self.voucherType is not None:
16898 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
16899 
      oprot.writeI64(self.voucherType)
16900 
      oprot.writeFieldEnd()
16901 
    oprot.writeFieldStop()
16902 
    oprot.writeStructEnd()
16903 
 
16904 
  def validate(self):
16905 
    return
16906 
 
16907 
 
16908 
  def __repr__(self):
16909 
    L = ['%s=%r' % (key, value)
16910 
      for key, value in self.__dict__.iteritems()]
16911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16912 
 
16913 
  def __eq__(self, other):
16914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16915 
 
16916 
  def __ne__(self, other):
16917 
    return not (self == other)
16918 
 
16919 
class getVoucherAmount_result:
16920 
  """
16921 
  Attributes:
16922 
   - success
16923 
  """
16924 
 
16925 
  thrift_spec = (
16926 
    (0, TType.I64, 'success', None, None, ), # 0
16927 
  )
16928 
 
16929 
  def __init__(self, success=None,):
16930 
    self.success = success
16931 
 
16932 
  def read(self, iprot):
16933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16935 
      return
16936 
    iprot.readStructBegin()
16937 
    while True:
16938 
      (fname, ftype, fid) = iprot.readFieldBegin()
16939 
      if ftype == TType.STOP:
16940 
        break
16941 
      if fid == 0:
16942 
        if ftype == TType.I64:
16943 
          self.success = iprot.readI64();
16944 
        else:
16945 
          iprot.skip(ftype)
16946 
      else:
16947 
        iprot.skip(ftype)
16948 
      iprot.readFieldEnd()
16949 
    iprot.readStructEnd()
16950 
 
16951 
  def write(self, oprot):
16952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16954 
      return
16955 
    oprot.writeStructBegin('getVoucherAmount_result')
16956 
    if self.success is not None:
16957 
      oprot.writeFieldBegin('success', TType.I64, 0)
16958 
      oprot.writeI64(self.success)
16959 
      oprot.writeFieldEnd()
16960 
    oprot.writeFieldStop()
16961 
    oprot.writeStructEnd()
16962 
 
16963 
  def validate(self):
16964 
    return
16965 
 
16966 
 
16967 
  def __repr__(self):
16968 
    L = ['%s=%r' % (key, value)
16969 
      for key, value in self.__dict__.iteritems()]
16970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16971 
 
16972 
  def __eq__(self, other):
16973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16974 
 
16975 
  def __ne__(self, other):
16976 
    return not (self == other)
16977 
 
16978 
class getAllItemVouchers_args:
16979 
  """
16980 
  Attributes:
16981 
   - itemId
16982 
  """
16983 
 
16984 
  thrift_spec = (
16985 
    None, # 0
16986 
    (1, TType.I64, 'itemId', None, None, ), # 1
16987 
  )
16988 
 
16989 
  def __init__(self, itemId=None,):
16990 
    self.itemId = itemId
16991 
 
16992 
  def read(self, iprot):
16993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16995 
      return
16996 
    iprot.readStructBegin()
16997 
    while True:
16998 
      (fname, ftype, fid) = iprot.readFieldBegin()
16999 
      if ftype == TType.STOP:
17000 
        break
17001 
      if fid == 1:
17002 
        if ftype == TType.I64:
17003 
          self.itemId = iprot.readI64();
17004 
        else:
17005 
          iprot.skip(ftype)
17006 
      else:
17007 
        iprot.skip(ftype)
17008 
      iprot.readFieldEnd()
17009 
    iprot.readStructEnd()
17010 
 
17011 
  def write(self, oprot):
17012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17014 
      return
17015 
    oprot.writeStructBegin('getAllItemVouchers_args')
17016 
    if self.itemId is not None:
17017 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17018 
      oprot.writeI64(self.itemId)
17019 
      oprot.writeFieldEnd()
17020 
    oprot.writeFieldStop()
17021 
    oprot.writeStructEnd()
17022 
 
17023 
  def validate(self):
17024 
    return
17025 
 
17026 
 
17027 
  def __repr__(self):
17028 
    L = ['%s=%r' % (key, value)
17029 
      for key, value in self.__dict__.iteritems()]
17030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17031 
 
17032 
  def __eq__(self, other):
17033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17034 
 
17035 
  def __ne__(self, other):
17036 
    return not (self == other)
17037 
 
17038 
class getAllItemVouchers_result:
17039 
  """
17040 
  Attributes:
17041 
   - success
17042 
  """
17043 
 
17044 
  thrift_spec = (
17045 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
17046 
  )
17047 
 
17048 
  def __init__(self, success=None,):
17049 
    self.success = success
17050 
 
17051 
  def read(self, iprot):
17052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17054 
      return
17055 
    iprot.readStructBegin()
17056 
    while True:
17057 
      (fname, ftype, fid) = iprot.readFieldBegin()
17058 
      if ftype == TType.STOP:
17059 
        break
17060 
      if fid == 0:
17061 
        if ftype == TType.LIST:
17062 
          self.success = []
8590 kshitij.so 17063 
          (_etype347, _size344) = iprot.readListBegin()
17064 
          for _i348 in xrange(_size344):
17065 
            _elem349 = VoucherItemMapping()
17066 
            _elem349.read(iprot)
17067 
            self.success.append(_elem349)
5944 mandeep.dh 17068 
          iprot.readListEnd()
17069 
        else:
17070 
          iprot.skip(ftype)
17071 
      else:
17072 
        iprot.skip(ftype)
17073 
      iprot.readFieldEnd()
17074 
    iprot.readStructEnd()
17075 
 
17076 
  def write(self, oprot):
17077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17079 
      return
17080 
    oprot.writeStructBegin('getAllItemVouchers_result')
17081 
    if self.success is not None:
17082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17083 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17084 
      for iter350 in self.success:
17085 
        iter350.write(oprot)
5944 mandeep.dh 17086 
      oprot.writeListEnd()
17087 
      oprot.writeFieldEnd()
17088 
    oprot.writeFieldStop()
17089 
    oprot.writeStructEnd()
17090 
 
17091 
  def validate(self):
17092 
    return
17093 
 
17094 
 
17095 
  def __repr__(self):
17096 
    L = ['%s=%r' % (key, value)
17097 
      for key, value in self.__dict__.iteritems()]
17098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17099 
 
17100 
  def __eq__(self, other):
17101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17102 
 
17103 
  def __ne__(self, other):
17104 
    return not (self == other)
17105 
 
17106 
class isValidCatalogItemId_args:
17107 
  """
17108 
  Attributes:
17109 
   - catalog_item_id
17110 
  """
17111 
 
17112 
  thrift_spec = (
17113 
    None, # 0
17114 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
17115 
  )
17116 
 
17117 
  def __init__(self, catalog_item_id=None,):
17118 
    self.catalog_item_id = catalog_item_id
17119 
 
17120 
  def read(self, iprot):
17121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17123 
      return
17124 
    iprot.readStructBegin()
17125 
    while True:
17126 
      (fname, ftype, fid) = iprot.readFieldBegin()
17127 
      if ftype == TType.STOP:
17128 
        break
17129 
      if fid == 1:
17130 
        if ftype == TType.I64:
17131 
          self.catalog_item_id = iprot.readI64();
17132 
        else:
17133 
          iprot.skip(ftype)
17134 
      else:
17135 
        iprot.skip(ftype)
17136 
      iprot.readFieldEnd()
17137 
    iprot.readStructEnd()
17138 
 
17139 
  def write(self, oprot):
17140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17142 
      return
17143 
    oprot.writeStructBegin('isValidCatalogItemId_args')
17144 
    if self.catalog_item_id is not None:
17145 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
17146 
      oprot.writeI64(self.catalog_item_id)
17147 
      oprot.writeFieldEnd()
17148 
    oprot.writeFieldStop()
17149 
    oprot.writeStructEnd()
17150 
 
17151 
  def validate(self):
17152 
    return
17153 
 
17154 
 
17155 
  def __repr__(self):
17156 
    L = ['%s=%r' % (key, value)
17157 
      for key, value in self.__dict__.iteritems()]
17158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17159 
 
17160 
  def __eq__(self, other):
17161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17162 
 
17163 
  def __ne__(self, other):
17164 
    return not (self == other)
17165 
 
17166 
class isValidCatalogItemId_result:
17167 
  """
17168 
  Attributes:
17169 
   - success
17170 
  """
17171 
 
17172 
  thrift_spec = (
17173 
    (0, TType.BOOL, 'success', None, None, ), # 0
17174 
  )
17175 
 
17176 
  def __init__(self, success=None,):
17177 
    self.success = success
17178 
 
17179 
  def read(self, iprot):
17180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17182 
      return
17183 
    iprot.readStructBegin()
17184 
    while True:
17185 
      (fname, ftype, fid) = iprot.readFieldBegin()
17186 
      if ftype == TType.STOP:
17187 
        break
17188 
      if fid == 0:
17189 
        if ftype == TType.BOOL:
17190 
          self.success = iprot.readBool();
17191 
        else:
17192 
          iprot.skip(ftype)
17193 
      else:
17194 
        iprot.skip(ftype)
17195 
      iprot.readFieldEnd()
17196 
    iprot.readStructEnd()
17197 
 
17198 
  def write(self, oprot):
17199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17201 
      return
17202 
    oprot.writeStructBegin('isValidCatalogItemId_result')
17203 
    if self.success is not None:
17204 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17205 
      oprot.writeBool(self.success)
17206 
      oprot.writeFieldEnd()
17207 
    oprot.writeFieldStop()
17208 
    oprot.writeStructEnd()
17209 
 
17210 
  def validate(self):
17211 
    return
17212 
 
17213 
 
17214 
  def __repr__(self):
17215 
    L = ['%s=%r' % (key, value)
17216 
      for key, value in self.__dict__.iteritems()]
17217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17218 
 
17219 
  def __eq__(self, other):
17220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17221 
 
17222 
  def __ne__(self, other):
17223 
    return not (self == other)
6039 amit.gupta 17224 
 
17225 
class getVatPercentageForItem_args:
17226 
  """
17227 
  Attributes:
17228 
   - itemId
7330 amit.gupta 17229 
   - stateId
6039 amit.gupta 17230 
   - price
17231 
  """
17232 
 
17233 
  thrift_spec = (
17234 
    None, # 0
17235 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 17236 
    (2, TType.I64, 'stateId', None, None, ), # 2
17237 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 17238 
  )
17239 
 
7330 amit.gupta 17240 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 17241 
    self.itemId = itemId
7330 amit.gupta 17242 
    self.stateId = stateId
6039 amit.gupta 17243 
    self.price = price
17244 
 
17245 
  def read(self, iprot):
17246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17248 
      return
17249 
    iprot.readStructBegin()
17250 
    while True:
17251 
      (fname, ftype, fid) = iprot.readFieldBegin()
17252 
      if ftype == TType.STOP:
17253 
        break
17254 
      if fid == 1:
17255 
        if ftype == TType.I64:
17256 
          self.itemId = iprot.readI64();
17257 
        else:
17258 
          iprot.skip(ftype)
17259 
      elif fid == 2:
7330 amit.gupta 17260 
        if ftype == TType.I64:
17261 
          self.stateId = iprot.readI64();
17262 
        else:
17263 
          iprot.skip(ftype)
17264 
      elif fid == 3:
6039 amit.gupta 17265 
        if ftype == TType.DOUBLE:
17266 
          self.price = iprot.readDouble();
17267 
        else:
17268 
          iprot.skip(ftype)
17269 
      else:
17270 
        iprot.skip(ftype)
17271 
      iprot.readFieldEnd()
17272 
    iprot.readStructEnd()
17273 
 
17274 
  def write(self, oprot):
17275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17277 
      return
17278 
    oprot.writeStructBegin('getVatPercentageForItem_args')
17279 
    if self.itemId is not None:
17280 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17281 
      oprot.writeI64(self.itemId)
17282 
      oprot.writeFieldEnd()
7330 amit.gupta 17283 
    if self.stateId is not None:
17284 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
17285 
      oprot.writeI64(self.stateId)
17286 
      oprot.writeFieldEnd()
6039 amit.gupta 17287 
    if self.price is not None:
7330 amit.gupta 17288 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 17289 
      oprot.writeDouble(self.price)
17290 
      oprot.writeFieldEnd()
17291 
    oprot.writeFieldStop()
17292 
    oprot.writeStructEnd()
17293 
 
17294 
  def validate(self):
17295 
    return
17296 
 
17297 
 
17298 
  def __repr__(self):
17299 
    L = ['%s=%r' % (key, value)
17300 
      for key, value in self.__dict__.iteritems()]
17301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17302 
 
17303 
  def __eq__(self, other):
17304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17305 
 
17306 
  def __ne__(self, other):
17307 
    return not (self == other)
17308 
 
17309 
class getVatPercentageForItem_result:
17310 
  """
17311 
  Attributes:
17312 
   - success
7340 amit.gupta 17313 
   - cex
6039 amit.gupta 17314 
  """
17315 
 
17316 
  thrift_spec = (
17317 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 17318 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 17319 
  )
17320 
 
7340 amit.gupta 17321 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 17322 
    self.success = success
7340 amit.gupta 17323 
    self.cex = cex
6039 amit.gupta 17324 
 
17325 
  def read(self, iprot):
17326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17328 
      return
17329 
    iprot.readStructBegin()
17330 
    while True:
17331 
      (fname, ftype, fid) = iprot.readFieldBegin()
17332 
      if ftype == TType.STOP:
17333 
        break
17334 
      if fid == 0:
17335 
        if ftype == TType.DOUBLE:
17336 
          self.success = iprot.readDouble();
17337 
        else:
17338 
          iprot.skip(ftype)
7340 amit.gupta 17339 
      elif fid == 1:
17340 
        if ftype == TType.STRUCT:
17341 
          self.cex = CatalogServiceException()
17342 
          self.cex.read(iprot)
17343 
        else:
17344 
          iprot.skip(ftype)
6039 amit.gupta 17345 
      else:
17346 
        iprot.skip(ftype)
17347 
      iprot.readFieldEnd()
17348 
    iprot.readStructEnd()
17349 
 
17350 
  def write(self, oprot):
17351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17353 
      return
17354 
    oprot.writeStructBegin('getVatPercentageForItem_result')
17355 
    if self.success is not None:
17356 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17357 
      oprot.writeDouble(self.success)
17358 
      oprot.writeFieldEnd()
7340 amit.gupta 17359 
    if self.cex is not None:
17360 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
17361 
      self.cex.write(oprot)
17362 
      oprot.writeFieldEnd()
6039 amit.gupta 17363 
    oprot.writeFieldStop()
17364 
    oprot.writeStructEnd()
17365 
 
17366 
  def validate(self):
17367 
    return
17368 
 
17369 
 
17370 
  def __repr__(self):
17371 
    L = ['%s=%r' % (key, value)
17372 
      for key, value in self.__dict__.iteritems()]
17373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17374 
 
17375 
  def __eq__(self, other):
17376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17377 
 
17378 
  def __ne__(self, other):
17379 
    return not (self == other)
17380 
 
17381 
class getVatAmountForItem_args:
17382 
  """
17383 
  Attributes:
17384 
   - itemId
17385 
   - price
17386 
  """
17387 
 
17388 
  thrift_spec = (
17389 
    None, # 0
17390 
    (1, TType.I64, 'itemId', None, None, ), # 1
17391 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17392 
  )
17393 
 
17394 
  def __init__(self, itemId=None, price=None,):
17395 
    self.itemId = itemId
17396 
    self.price = price
17397 
 
17398 
  def read(self, iprot):
17399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17401 
      return
17402 
    iprot.readStructBegin()
17403 
    while True:
17404 
      (fname, ftype, fid) = iprot.readFieldBegin()
17405 
      if ftype == TType.STOP:
17406 
        break
17407 
      if fid == 1:
17408 
        if ftype == TType.I64:
17409 
          self.itemId = iprot.readI64();
17410 
        else:
17411 
          iprot.skip(ftype)
17412 
      elif fid == 2:
17413 
        if ftype == TType.DOUBLE:
17414 
          self.price = iprot.readDouble();
17415 
        else:
17416 
          iprot.skip(ftype)
17417 
      else:
17418 
        iprot.skip(ftype)
17419 
      iprot.readFieldEnd()
17420 
    iprot.readStructEnd()
17421 
 
17422 
  def write(self, oprot):
17423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17425 
      return
17426 
    oprot.writeStructBegin('getVatAmountForItem_args')
17427 
    if self.itemId is not None:
17428 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17429 
      oprot.writeI64(self.itemId)
17430 
      oprot.writeFieldEnd()
17431 
    if self.price is not None:
17432 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17433 
      oprot.writeDouble(self.price)
17434 
      oprot.writeFieldEnd()
17435 
    oprot.writeFieldStop()
17436 
    oprot.writeStructEnd()
17437 
 
17438 
  def validate(self):
17439 
    return
17440 
 
17441 
 
17442 
  def __repr__(self):
17443 
    L = ['%s=%r' % (key, value)
17444 
      for key, value in self.__dict__.iteritems()]
17445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17446 
 
17447 
  def __eq__(self, other):
17448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17449 
 
17450 
  def __ne__(self, other):
17451 
    return not (self == other)
17452 
 
17453 
class getVatAmountForItem_result:
17454 
  """
17455 
  Attributes:
17456 
   - success
17457 
  """
17458 
 
17459 
  thrift_spec = (
17460 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
17461 
  )
17462 
 
17463 
  def __init__(self, success=None,):
17464 
    self.success = success
17465 
 
17466 
  def read(self, iprot):
17467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17469 
      return
17470 
    iprot.readStructBegin()
17471 
    while True:
17472 
      (fname, ftype, fid) = iprot.readFieldBegin()
17473 
      if ftype == TType.STOP:
17474 
        break
17475 
      if fid == 0:
17476 
        if ftype == TType.DOUBLE:
17477 
          self.success = iprot.readDouble();
17478 
        else:
17479 
          iprot.skip(ftype)
17480 
      else:
17481 
        iprot.skip(ftype)
17482 
      iprot.readFieldEnd()
17483 
    iprot.readStructEnd()
17484 
 
17485 
  def write(self, oprot):
17486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17488 
      return
17489 
    oprot.writeStructBegin('getVatAmountForItem_result')
17490 
    if self.success is not None:
17491 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
17492 
      oprot.writeDouble(self.success)
17493 
      oprot.writeFieldEnd()
17494 
    oprot.writeFieldStop()
17495 
    oprot.writeStructEnd()
17496 
 
17497 
  def validate(self):
17498 
    return
17499 
 
17500 
 
17501 
  def __repr__(self):
17502 
    L = ['%s=%r' % (key, value)
17503 
      for key, value in self.__dict__.iteritems()]
17504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17505 
 
17506 
  def __eq__(self, other):
17507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17508 
 
17509 
  def __ne__(self, other):
17510 
    return not (self == other)
6531 vikram.rag 17511 
 
17512 
class getAllIgnoredInventoryUpdateItemsList_args:
17513 
  """
17514 
  Attributes:
17515 
   - offset
17516 
   - limit
17517 
  """
17518 
 
17519 
  thrift_spec = (
17520 
    None, # 0
17521 
    (1, TType.I32, 'offset', None, None, ), # 1
17522 
    (2, TType.I32, 'limit', None, None, ), # 2
17523 
  )
17524 
 
17525 
  def __init__(self, offset=None, limit=None,):
17526 
    self.offset = offset
17527 
    self.limit = limit
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 == 1:
17539 
        if ftype == TType.I32:
17540 
          self.offset = iprot.readI32();
17541 
        else:
17542 
          iprot.skip(ftype)
17543 
      elif fid == 2:
17544 
        if ftype == TType.I32:
17545 
          self.limit = iprot.readI32();
17546 
        else:
17547 
          iprot.skip(ftype)
17548 
      else:
17549 
        iprot.skip(ftype)
17550 
      iprot.readFieldEnd()
17551 
    iprot.readStructEnd()
17552 
 
17553 
  def write(self, oprot):
17554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17556 
      return
17557 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
17558 
    if self.offset is not None:
17559 
      oprot.writeFieldBegin('offset', TType.I32, 1)
17560 
      oprot.writeI32(self.offset)
17561 
      oprot.writeFieldEnd()
17562 
    if self.limit is not None:
17563 
      oprot.writeFieldBegin('limit', TType.I32, 2)
17564 
      oprot.writeI32(self.limit)
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)
17583 
 
17584 
class getAllIgnoredInventoryUpdateItemsList_result:
17585 
  """
17586 
  Attributes:
17587 
   - success
17588 
  """
17589 
 
17590 
  thrift_spec = (
17591 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17592 
  )
17593 
 
17594 
  def __init__(self, success=None,):
17595 
    self.success = success
17596 
 
17597 
  def read(self, iprot):
17598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17600 
      return
17601 
    iprot.readStructBegin()
17602 
    while True:
17603 
      (fname, ftype, fid) = iprot.readFieldBegin()
17604 
      if ftype == TType.STOP:
17605 
        break
17606 
      if fid == 0:
17607 
        if ftype == TType.LIST:
17608 
          self.success = []
8590 kshitij.so 17609 
          (_etype354, _size351) = iprot.readListBegin()
17610 
          for _i355 in xrange(_size351):
17611 
            _elem356 = Item()
17612 
            _elem356.read(iprot)
17613 
            self.success.append(_elem356)
6531 vikram.rag 17614 
          iprot.readListEnd()
17615 
        else:
17616 
          iprot.skip(ftype)
17617 
      else:
17618 
        iprot.skip(ftype)
17619 
      iprot.readFieldEnd()
17620 
    iprot.readStructEnd()
17621 
 
17622 
  def write(self, oprot):
17623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17625 
      return
17626 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
17627 
    if self.success is not None:
17628 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17629 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17630 
      for iter357 in self.success:
17631 
        iter357.write(oprot)
6531 vikram.rag 17632 
      oprot.writeListEnd()
17633 
      oprot.writeFieldEnd()
17634 
    oprot.writeFieldStop()
17635 
    oprot.writeStructEnd()
17636 
 
17637 
  def validate(self):
17638 
    return
17639 
 
17640 
 
17641 
  def __repr__(self):
17642 
    L = ['%s=%r' % (key, value)
17643 
      for key, value in self.__dict__.iteritems()]
17644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17645 
 
17646 
  def __eq__(self, other):
17647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17648 
 
17649 
  def __ne__(self, other):
17650 
    return not (self == other)
6805 anupam.sin 17651 
 
6821 amar.kumar 17652 
class getAllAliveItems_args:
17653 
 
17654 
  thrift_spec = (
17655 
  )
17656 
 
17657 
  def read(self, iprot):
17658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17660 
      return
17661 
    iprot.readStructBegin()
17662 
    while True:
17663 
      (fname, ftype, fid) = iprot.readFieldBegin()
17664 
      if ftype == TType.STOP:
17665 
        break
17666 
      else:
17667 
        iprot.skip(ftype)
17668 
      iprot.readFieldEnd()
17669 
    iprot.readStructEnd()
17670 
 
17671 
  def write(self, oprot):
17672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17674 
      return
17675 
    oprot.writeStructBegin('getAllAliveItems_args')
17676 
    oprot.writeFieldStop()
17677 
    oprot.writeStructEnd()
17678 
 
17679 
  def validate(self):
17680 
    return
17681 
 
17682 
 
17683 
  def __repr__(self):
17684 
    L = ['%s=%r' % (key, value)
17685 
      for key, value in self.__dict__.iteritems()]
17686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17687 
 
17688 
  def __eq__(self, other):
17689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17690 
 
17691 
  def __ne__(self, other):
17692 
    return not (self == other)
17693 
 
17694 
class getAllAliveItems_result:
17695 
  """
17696 
  Attributes:
17697 
   - success
17698 
  """
17699 
 
17700 
  thrift_spec = (
17701 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17702 
  )
17703 
 
17704 
  def __init__(self, success=None,):
17705 
    self.success = success
17706 
 
17707 
  def read(self, iprot):
17708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17710 
      return
17711 
    iprot.readStructBegin()
17712 
    while True:
17713 
      (fname, ftype, fid) = iprot.readFieldBegin()
17714 
      if ftype == TType.STOP:
17715 
        break
17716 
      if fid == 0:
17717 
        if ftype == TType.LIST:
17718 
          self.success = []
8590 kshitij.so 17719 
          (_etype361, _size358) = iprot.readListBegin()
17720 
          for _i362 in xrange(_size358):
17721 
            _elem363 = Item()
17722 
            _elem363.read(iprot)
17723 
            self.success.append(_elem363)
6821 amar.kumar 17724 
          iprot.readListEnd()
17725 
        else:
17726 
          iprot.skip(ftype)
17727 
      else:
17728 
        iprot.skip(ftype)
17729 
      iprot.readFieldEnd()
17730 
    iprot.readStructEnd()
17731 
 
17732 
  def write(self, oprot):
17733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17735 
      return
17736 
    oprot.writeStructBegin('getAllAliveItems_result')
17737 
    if self.success is not None:
17738 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17739 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 17740 
      for iter364 in self.success:
17741 
        iter364.write(oprot)
6821 amar.kumar 17742 
      oprot.writeListEnd()
17743 
      oprot.writeFieldEnd()
17744 
    oprot.writeFieldStop()
17745 
    oprot.writeStructEnd()
17746 
 
17747 
  def validate(self):
17748 
    return
17749 
 
17750 
 
17751 
  def __repr__(self):
17752 
    L = ['%s=%r' % (key, value)
17753 
      for key, value in self.__dict__.iteritems()]
17754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17755 
 
17756 
  def __eq__(self, other):
17757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17758 
 
17759 
  def __ne__(self, other):
17760 
    return not (self == other)
17761 
 
6805 anupam.sin 17762 
class getInsuranceAmount_args:
17763 
  """
17764 
  Attributes:
17765 
   - itemId
6921 anupam.sin 17766 
   - price
6805 anupam.sin 17767 
   - insurerId
17768 
   - quantity
17769 
  """
17770 
 
17771 
  thrift_spec = (
17772 
    None, # 0
17773 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 17774 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
17775 
    (3, TType.I64, 'insurerId', None, None, ), # 3
17776 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 17777 
  )
17778 
 
6921 anupam.sin 17779 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 17780 
    self.itemId = itemId
6921 anupam.sin 17781 
    self.price = price
6805 anupam.sin 17782 
    self.insurerId = insurerId
17783 
    self.quantity = quantity
17784 
 
17785 
  def read(self, iprot):
17786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17788 
      return
17789 
    iprot.readStructBegin()
17790 
    while True:
17791 
      (fname, ftype, fid) = iprot.readFieldBegin()
17792 
      if ftype == TType.STOP:
17793 
        break
17794 
      if fid == 1:
17795 
        if ftype == TType.I64:
17796 
          self.itemId = iprot.readI64();
17797 
        else:
17798 
          iprot.skip(ftype)
17799 
      elif fid == 2:
6921 anupam.sin 17800 
        if ftype == TType.DOUBLE:
17801 
          self.price = iprot.readDouble();
17802 
        else:
17803 
          iprot.skip(ftype)
17804 
      elif fid == 3:
6805 anupam.sin 17805 
        if ftype == TType.I64:
17806 
          self.insurerId = iprot.readI64();
17807 
        else:
17808 
          iprot.skip(ftype)
6921 anupam.sin 17809 
      elif fid == 4:
6805 anupam.sin 17810 
        if ftype == TType.I64:
17811 
          self.quantity = iprot.readI64();
17812 
        else:
17813 
          iprot.skip(ftype)
17814 
      else:
17815 
        iprot.skip(ftype)
17816 
      iprot.readFieldEnd()
17817 
    iprot.readStructEnd()
17818 
 
17819 
  def write(self, oprot):
17820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17822 
      return
17823 
    oprot.writeStructBegin('getInsuranceAmount_args')
17824 
    if self.itemId is not None:
17825 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17826 
      oprot.writeI64(self.itemId)
17827 
      oprot.writeFieldEnd()
6921 anupam.sin 17828 
    if self.price is not None:
17829 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
17830 
      oprot.writeDouble(self.price)
17831 
      oprot.writeFieldEnd()
6805 anupam.sin 17832 
    if self.insurerId is not None:
6921 anupam.sin 17833 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 17834 
      oprot.writeI64(self.insurerId)
17835 
      oprot.writeFieldEnd()
17836 
    if self.quantity is not None:
6921 anupam.sin 17837 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 17838 
      oprot.writeI64(self.quantity)
17839 
      oprot.writeFieldEnd()
17840 
    oprot.writeFieldStop()
17841 
    oprot.writeStructEnd()
17842 
 
17843 
  def validate(self):
17844 
    return
17845 
 
17846 
 
17847 
  def __repr__(self):
17848 
    L = ['%s=%r' % (key, value)
17849 
      for key, value in self.__dict__.iteritems()]
17850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17851 
 
17852 
  def __eq__(self, other):
17853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17854 
 
17855 
  def __ne__(self, other):
17856 
    return not (self == other)
17857 
 
17858 
class getInsuranceAmount_result:
17859 
  """
17860 
  Attributes:
17861 
   - success
17862 
  """
17863 
 
17864 
  thrift_spec = (
17865 
    (0, TType.I64, 'success', None, None, ), # 0
17866 
  )
17867 
 
17868 
  def __init__(self, success=None,):
17869 
    self.success = success
17870 
 
17871 
  def read(self, iprot):
17872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17874 
      return
17875 
    iprot.readStructBegin()
17876 
    while True:
17877 
      (fname, ftype, fid) = iprot.readFieldBegin()
17878 
      if ftype == TType.STOP:
17879 
        break
17880 
      if fid == 0:
17881 
        if ftype == TType.I64:
17882 
          self.success = iprot.readI64();
17883 
        else:
17884 
          iprot.skip(ftype)
17885 
      else:
17886 
        iprot.skip(ftype)
17887 
      iprot.readFieldEnd()
17888 
    iprot.readStructEnd()
17889 
 
17890 
  def write(self, oprot):
17891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17893 
      return
17894 
    oprot.writeStructBegin('getInsuranceAmount_result')
17895 
    if self.success is not None:
17896 
      oprot.writeFieldBegin('success', TType.I64, 0)
17897 
      oprot.writeI64(self.success)
17898 
      oprot.writeFieldEnd()
17899 
    oprot.writeFieldStop()
17900 
    oprot.writeStructEnd()
17901 
 
17902 
  def validate(self):
17903 
    return
17904 
 
17905 
 
17906 
  def __repr__(self):
17907 
    L = ['%s=%r' % (key, value)
17908 
      for key, value in self.__dict__.iteritems()]
17909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17910 
 
17911 
  def __eq__(self, other):
17912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17913 
 
17914 
  def __ne__(self, other):
17915 
    return not (self == other)
17916 
 
17917 
class getInsurer_args:
17918 
  """
17919 
  Attributes:
17920 
   - insurerId
17921 
  """
17922 
 
17923 
  thrift_spec = (
17924 
    None, # 0
17925 
    (1, TType.I64, 'insurerId', None, None, ), # 1
17926 
  )
17927 
 
17928 
  def __init__(self, insurerId=None,):
17929 
    self.insurerId = insurerId
17930 
 
17931 
  def read(self, iprot):
17932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17934 
      return
17935 
    iprot.readStructBegin()
17936 
    while True:
17937 
      (fname, ftype, fid) = iprot.readFieldBegin()
17938 
      if ftype == TType.STOP:
17939 
        break
17940 
      if fid == 1:
17941 
        if ftype == TType.I64:
17942 
          self.insurerId = iprot.readI64();
17943 
        else:
17944 
          iprot.skip(ftype)
17945 
      else:
17946 
        iprot.skip(ftype)
17947 
      iprot.readFieldEnd()
17948 
    iprot.readStructEnd()
17949 
 
17950 
  def write(self, oprot):
17951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17953 
      return
17954 
    oprot.writeStructBegin('getInsurer_args')
17955 
    if self.insurerId is not None:
17956 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
17957 
      oprot.writeI64(self.insurerId)
17958 
      oprot.writeFieldEnd()
17959 
    oprot.writeFieldStop()
17960 
    oprot.writeStructEnd()
17961 
 
17962 
  def validate(self):
17963 
    return
17964 
 
17965 
 
17966 
  def __repr__(self):
17967 
    L = ['%s=%r' % (key, value)
17968 
      for key, value in self.__dict__.iteritems()]
17969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17970 
 
17971 
  def __eq__(self, other):
17972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17973 
 
17974 
  def __ne__(self, other):
17975 
    return not (self == other)
17976 
 
17977 
class getInsurer_result:
17978 
  """
17979 
  Attributes:
17980 
   - success
17981 
  """
17982 
 
17983 
  thrift_spec = (
17984 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
17985 
  )
17986 
 
17987 
  def __init__(self, success=None,):
17988 
    self.success = success
17989 
 
17990 
  def read(self, iprot):
17991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17993 
      return
17994 
    iprot.readStructBegin()
17995 
    while True:
17996 
      (fname, ftype, fid) = iprot.readFieldBegin()
17997 
      if ftype == TType.STOP:
17998 
        break
17999 
      if fid == 0:
18000 
        if ftype == TType.STRUCT:
18001 
          self.success = Insurer()
18002 
          self.success.read(iprot)
18003 
        else:
18004 
          iprot.skip(ftype)
18005 
      else:
18006 
        iprot.skip(ftype)
18007 
      iprot.readFieldEnd()
18008 
    iprot.readStructEnd()
18009 
 
18010 
  def write(self, oprot):
18011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18013 
      return
18014 
    oprot.writeStructBegin('getInsurer_result')
18015 
    if self.success is not None:
18016 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18017 
      self.success.write(oprot)
18018 
      oprot.writeFieldEnd()
18019 
    oprot.writeFieldStop()
18020 
    oprot.writeStructEnd()
18021 
 
18022 
  def validate(self):
18023 
    return
18024 
 
18025 
 
18026 
  def __repr__(self):
18027 
    L = ['%s=%r' % (key, value)
18028 
      for key, value in self.__dict__.iteritems()]
18029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18030 
 
18031 
  def __eq__(self, other):
18032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18033 
 
18034 
  def __ne__(self, other):
18035 
    return not (self == other)
6838 vikram.rag 18036 
 
18037 
class getAllInsurers_args:
18038 
 
18039 
  thrift_spec = (
18040 
  )
18041 
 
18042 
  def read(self, iprot):
18043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18045 
      return
18046 
    iprot.readStructBegin()
18047 
    while True:
18048 
      (fname, ftype, fid) = iprot.readFieldBegin()
18049 
      if ftype == TType.STOP:
18050 
        break
18051 
      else:
18052 
        iprot.skip(ftype)
18053 
      iprot.readFieldEnd()
18054 
    iprot.readStructEnd()
18055 
 
18056 
  def write(self, oprot):
18057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18059 
      return
18060 
    oprot.writeStructBegin('getAllInsurers_args')
18061 
    oprot.writeFieldStop()
18062 
    oprot.writeStructEnd()
18063 
 
18064 
  def validate(self):
18065 
    return
18066 
 
18067 
 
18068 
  def __repr__(self):
18069 
    L = ['%s=%r' % (key, value)
18070 
      for key, value in self.__dict__.iteritems()]
18071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18072 
 
18073 
  def __eq__(self, other):
18074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18075 
 
18076 
  def __ne__(self, other):
18077 
    return not (self == other)
18078 
 
18079 
class getAllInsurers_result:
18080 
  """
18081 
  Attributes:
18082 
   - success
18083 
  """
18084 
 
18085 
  thrift_spec = (
18086 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
18087 
  )
18088 
 
18089 
  def __init__(self, success=None,):
18090 
    self.success = success
18091 
 
18092 
  def read(self, iprot):
18093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18095 
      return
18096 
    iprot.readStructBegin()
18097 
    while True:
18098 
      (fname, ftype, fid) = iprot.readFieldBegin()
18099 
      if ftype == TType.STOP:
18100 
        break
18101 
      if fid == 0:
18102 
        if ftype == TType.LIST:
18103 
          self.success = []
8590 kshitij.so 18104 
          (_etype368, _size365) = iprot.readListBegin()
18105 
          for _i369 in xrange(_size365):
18106 
            _elem370 = Insurer()
18107 
            _elem370.read(iprot)
18108 
            self.success.append(_elem370)
6838 vikram.rag 18109 
          iprot.readListEnd()
18110 
        else:
18111 
          iprot.skip(ftype)
18112 
      else:
18113 
        iprot.skip(ftype)
18114 
      iprot.readFieldEnd()
18115 
    iprot.readStructEnd()
18116 
 
18117 
  def write(self, oprot):
18118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18120 
      return
18121 
    oprot.writeStructBegin('getAllInsurers_result')
18122 
    if self.success is not None:
18123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 18125 
      for iter371 in self.success:
18126 
        iter371.write(oprot)
6838 vikram.rag 18127 
      oprot.writeListEnd()
18128 
      oprot.writeFieldEnd()
18129 
    oprot.writeFieldStop()
18130 
    oprot.writeStructEnd()
18131 
 
18132 
  def validate(self):
18133 
    return
18134 
 
18135 
 
18136 
  def __repr__(self):
18137 
    L = ['%s=%r' % (key, value)
18138 
      for key, value in self.__dict__.iteritems()]
18139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18140 
 
18141 
  def __eq__(self, other):
18142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18143 
 
18144 
  def __ne__(self, other):
18145 
    return not (self == other)
6962 rajveer 18146 
 
18147 
class updateInsuranceDeclaredAmount_args:
18148 
  """
18149 
  Attributes:
18150 
   - insurerId
18151 
   - amount
18152 
  """
18153 
 
18154 
  thrift_spec = (
18155 
    None, # 0
18156 
    (1, TType.I64, 'insurerId', None, None, ), # 1
18157 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
18158 
  )
18159 
 
18160 
  def __init__(self, insurerId=None, amount=None,):
18161 
    self.insurerId = insurerId
18162 
    self.amount = amount
18163 
 
18164 
  def read(self, iprot):
18165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18167 
      return
18168 
    iprot.readStructBegin()
18169 
    while True:
18170 
      (fname, ftype, fid) = iprot.readFieldBegin()
18171 
      if ftype == TType.STOP:
18172 
        break
18173 
      if fid == 1:
18174 
        if ftype == TType.I64:
18175 
          self.insurerId = iprot.readI64();
18176 
        else:
18177 
          iprot.skip(ftype)
18178 
      elif fid == 2:
18179 
        if ftype == TType.DOUBLE:
18180 
          self.amount = iprot.readDouble();
18181 
        else:
18182 
          iprot.skip(ftype)
18183 
      else:
18184 
        iprot.skip(ftype)
18185 
      iprot.readFieldEnd()
18186 
    iprot.readStructEnd()
18187 
 
18188 
  def write(self, oprot):
18189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18191 
      return
18192 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
18193 
    if self.insurerId is not None:
18194 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
18195 
      oprot.writeI64(self.insurerId)
18196 
      oprot.writeFieldEnd()
18197 
    if self.amount is not None:
18198 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
18199 
      oprot.writeDouble(self.amount)
18200 
      oprot.writeFieldEnd()
18201 
    oprot.writeFieldStop()
18202 
    oprot.writeStructEnd()
18203 
 
18204 
  def validate(self):
18205 
    return
18206 
 
18207 
 
18208 
  def __repr__(self):
18209 
    L = ['%s=%r' % (key, value)
18210 
      for key, value in self.__dict__.iteritems()]
18211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18212 
 
18213 
  def __eq__(self, other):
18214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18215 
 
18216 
  def __ne__(self, other):
18217 
    return not (self == other)
18218 
 
18219 
class updateInsuranceDeclaredAmount_result:
18220 
 
18221 
  thrift_spec = (
18222 
  )
18223 
 
18224 
  def read(self, iprot):
18225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18227 
      return
18228 
    iprot.readStructBegin()
18229 
    while True:
18230 
      (fname, ftype, fid) = iprot.readFieldBegin()
18231 
      if ftype == TType.STOP:
18232 
        break
18233 
      else:
18234 
        iprot.skip(ftype)
18235 
      iprot.readFieldEnd()
18236 
    iprot.readStructEnd()
18237 
 
18238 
  def write(self, oprot):
18239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18241 
      return
18242 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
18243 
    oprot.writeFieldStop()
18244 
    oprot.writeStructEnd()
18245 
 
18246 
  def validate(self):
18247 
    return
18248 
 
18249 
 
18250 
  def __repr__(self):
18251 
    L = ['%s=%r' % (key, value)
18252 
      for key, value in self.__dict__.iteritems()]
18253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18254 
 
18255 
  def __eq__(self, other):
18256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18257 
 
18258 
  def __ne__(self, other):
18259 
    return not (self == other)
7190 amar.kumar 18260 
 
18261 
class getFreebieForItem_args:
18262 
  """
18263 
  Attributes:
18264 
   - itemId
18265 
  """
18266 
 
18267 
  thrift_spec = (
18268 
    None, # 0
18269 
    (1, TType.I64, 'itemId', None, None, ), # 1
18270 
  )
18271 
 
18272 
  def __init__(self, itemId=None,):
18273 
    self.itemId = itemId
18274 
 
18275 
  def read(self, iprot):
18276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18278 
      return
18279 
    iprot.readStructBegin()
18280 
    while True:
18281 
      (fname, ftype, fid) = iprot.readFieldBegin()
18282 
      if ftype == TType.STOP:
18283 
        break
18284 
      if fid == 1:
18285 
        if ftype == TType.I64:
18286 
          self.itemId = iprot.readI64();
18287 
        else:
18288 
          iprot.skip(ftype)
18289 
      else:
18290 
        iprot.skip(ftype)
18291 
      iprot.readFieldEnd()
18292 
    iprot.readStructEnd()
18293 
 
18294 
  def write(self, oprot):
18295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18297 
      return
18298 
    oprot.writeStructBegin('getFreebieForItem_args')
18299 
    if self.itemId is not None:
18300 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18301 
      oprot.writeI64(self.itemId)
18302 
      oprot.writeFieldEnd()
18303 
    oprot.writeFieldStop()
18304 
    oprot.writeStructEnd()
18305 
 
18306 
  def validate(self):
18307 
    return
18308 
 
18309 
 
18310 
  def __repr__(self):
18311 
    L = ['%s=%r' % (key, value)
18312 
      for key, value in self.__dict__.iteritems()]
18313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18314 
 
18315 
  def __eq__(self, other):
18316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18317 
 
18318 
  def __ne__(self, other):
18319 
    return not (self == other)
18320 
 
18321 
class getFreebieForItem_result:
18322 
  """
18323 
  Attributes:
18324 
   - success
18325 
  """
18326 
 
18327 
  thrift_spec = (
18328 
    (0, TType.I64, 'success', None, None, ), # 0
18329 
  )
18330 
 
18331 
  def __init__(self, success=None,):
18332 
    self.success = success
18333 
 
18334 
  def read(self, iprot):
18335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18337 
      return
18338 
    iprot.readStructBegin()
18339 
    while True:
18340 
      (fname, ftype, fid) = iprot.readFieldBegin()
18341 
      if ftype == TType.STOP:
18342 
        break
18343 
      if fid == 0:
18344 
        if ftype == TType.I64:
18345 
          self.success = iprot.readI64();
18346 
        else:
18347 
          iprot.skip(ftype)
18348 
      else:
18349 
        iprot.skip(ftype)
18350 
      iprot.readFieldEnd()
18351 
    iprot.readStructEnd()
18352 
 
18353 
  def write(self, oprot):
18354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18356 
      return
18357 
    oprot.writeStructBegin('getFreebieForItem_result')
18358 
    if self.success is not None:
18359 
      oprot.writeFieldBegin('success', TType.I64, 0)
18360 
      oprot.writeI64(self.success)
18361 
      oprot.writeFieldEnd()
18362 
    oprot.writeFieldStop()
18363 
    oprot.writeStructEnd()
18364 
 
18365 
  def validate(self):
18366 
    return
18367 
 
18368 
 
18369 
  def __repr__(self):
18370 
    L = ['%s=%r' % (key, value)
18371 
      for key, value in self.__dict__.iteritems()]
18372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18373 
 
18374 
  def __eq__(self, other):
18375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18376 
 
18377 
  def __ne__(self, other):
18378 
    return not (self == other)
18379 
 
18380 
class addOrUpdateFreebieForItem_args:
18381 
  """
18382 
  Attributes:
18383 
   - freebieItem
18384 
  """
18385 
 
18386 
  thrift_spec = (
18387 
    None, # 0
18388 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
18389 
  )
18390 
 
18391 
  def __init__(self, freebieItem=None,):
18392 
    self.freebieItem = freebieItem
18393 
 
18394 
  def read(self, iprot):
18395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18397 
      return
18398 
    iprot.readStructBegin()
18399 
    while True:
18400 
      (fname, ftype, fid) = iprot.readFieldBegin()
18401 
      if ftype == TType.STOP:
18402 
        break
18403 
      if fid == 1:
18404 
        if ftype == TType.STRUCT:
18405 
          self.freebieItem = FreebieItem()
18406 
          self.freebieItem.read(iprot)
18407 
        else:
18408 
          iprot.skip(ftype)
18409 
      else:
18410 
        iprot.skip(ftype)
18411 
      iprot.readFieldEnd()
18412 
    iprot.readStructEnd()
18413 
 
18414 
  def write(self, oprot):
18415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18417 
      return
18418 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
18419 
    if self.freebieItem is not None:
18420 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
18421 
      self.freebieItem.write(oprot)
18422 
      oprot.writeFieldEnd()
18423 
    oprot.writeFieldStop()
18424 
    oprot.writeStructEnd()
18425 
 
18426 
  def validate(self):
18427 
    return
18428 
 
18429 
 
18430 
  def __repr__(self):
18431 
    L = ['%s=%r' % (key, value)
18432 
      for key, value in self.__dict__.iteritems()]
18433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18434 
 
18435 
  def __eq__(self, other):
18436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18437 
 
18438 
  def __ne__(self, other):
18439 
    return not (self == other)
18440 
 
18441 
class addOrUpdateFreebieForItem_result:
18442 
 
18443 
  thrift_spec = (
18444 
  )
18445 
 
18446 
  def read(self, iprot):
18447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18449 
      return
18450 
    iprot.readStructBegin()
18451 
    while True:
18452 
      (fname, ftype, fid) = iprot.readFieldBegin()
18453 
      if ftype == TType.STOP:
18454 
        break
18455 
      else:
18456 
        iprot.skip(ftype)
18457 
      iprot.readFieldEnd()
18458 
    iprot.readStructEnd()
18459 
 
18460 
  def write(self, oprot):
18461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18463 
      return
18464 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
18465 
    oprot.writeFieldStop()
18466 
    oprot.writeStructEnd()
18467 
 
18468 
  def validate(self):
18469 
    return
18470 
 
18471 
 
18472 
  def __repr__(self):
18473 
    L = ['%s=%r' % (key, value)
18474 
      for key, value in self.__dict__.iteritems()]
18475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18476 
 
18477 
  def __eq__(self, other):
18478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18479 
 
18480 
  def __ne__(self, other):
18481 
    return not (self == other)
7256 rajveer 18482 
 
7272 amit.gupta 18483 
class addOrUpdateBrandInfo_args:
18484 
  """
18485 
  Attributes:
18486 
   - brandInfo
18487 
  """
18488 
 
18489 
  thrift_spec = (
18490 
    None, # 0
18491 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
18492 
  )
18493 
 
18494 
  def __init__(self, brandInfo=None,):
18495 
    self.brandInfo = brandInfo
18496 
 
18497 
  def read(self, iprot):
18498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18500 
      return
18501 
    iprot.readStructBegin()
18502 
    while True:
18503 
      (fname, ftype, fid) = iprot.readFieldBegin()
18504 
      if ftype == TType.STOP:
18505 
        break
18506 
      if fid == 1:
18507 
        if ftype == TType.STRUCT:
18508 
          self.brandInfo = BrandInfo()
18509 
          self.brandInfo.read(iprot)
18510 
        else:
18511 
          iprot.skip(ftype)
18512 
      else:
18513 
        iprot.skip(ftype)
18514 
      iprot.readFieldEnd()
18515 
    iprot.readStructEnd()
18516 
 
18517 
  def write(self, oprot):
18518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18520 
      return
18521 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
18522 
    if self.brandInfo is not None:
18523 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
18524 
      self.brandInfo.write(oprot)
18525 
      oprot.writeFieldEnd()
18526 
    oprot.writeFieldStop()
18527 
    oprot.writeStructEnd()
18528 
 
18529 
  def validate(self):
18530 
    return
18531 
 
18532 
 
18533 
  def __repr__(self):
18534 
    L = ['%s=%r' % (key, value)
18535 
      for key, value in self.__dict__.iteritems()]
18536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18537 
 
18538 
  def __eq__(self, other):
18539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18540 
 
18541 
  def __ne__(self, other):
18542 
    return not (self == other)
18543 
 
18544 
class addOrUpdateBrandInfo_result:
18545 
 
18546 
  thrift_spec = (
18547 
  )
18548 
 
18549 
  def read(self, iprot):
18550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18552 
      return
18553 
    iprot.readStructBegin()
18554 
    while True:
18555 
      (fname, ftype, fid) = iprot.readFieldBegin()
18556 
      if ftype == TType.STOP:
18557 
        break
18558 
      else:
18559 
        iprot.skip(ftype)
18560 
      iprot.readFieldEnd()
18561 
    iprot.readStructEnd()
18562 
 
18563 
  def write(self, oprot):
18564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18566 
      return
18567 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
18568 
    oprot.writeFieldStop()
18569 
    oprot.writeStructEnd()
18570 
 
18571 
  def validate(self):
18572 
    return
18573 
 
18574 
 
18575 
  def __repr__(self):
18576 
    L = ['%s=%r' % (key, value)
18577 
      for key, value in self.__dict__.iteritems()]
18578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18579 
 
18580 
  def __eq__(self, other):
18581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18582 
 
18583 
  def __ne__(self, other):
18584 
    return not (self == other)
18585 
 
18586 
class getBrandInfo_args:
18587 
 
18588 
  thrift_spec = (
18589 
  )
18590 
 
18591 
  def read(self, iprot):
18592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18594 
      return
18595 
    iprot.readStructBegin()
18596 
    while True:
18597 
      (fname, ftype, fid) = iprot.readFieldBegin()
18598 
      if ftype == TType.STOP:
18599 
        break
18600 
      else:
18601 
        iprot.skip(ftype)
18602 
      iprot.readFieldEnd()
18603 
    iprot.readStructEnd()
18604 
 
18605 
  def write(self, oprot):
18606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18608 
      return
18609 
    oprot.writeStructBegin('getBrandInfo_args')
18610 
    oprot.writeFieldStop()
18611 
    oprot.writeStructEnd()
18612 
 
18613 
  def validate(self):
18614 
    return
18615 
 
18616 
 
18617 
  def __repr__(self):
18618 
    L = ['%s=%r' % (key, value)
18619 
      for key, value in self.__dict__.iteritems()]
18620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18621 
 
18622 
  def __eq__(self, other):
18623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18624 
 
18625 
  def __ne__(self, other):
18626 
    return not (self == other)
18627 
 
18628 
class getBrandInfo_result:
18629 
  """
18630 
  Attributes:
18631 
   - success
18632 
  """
18633 
 
18634 
  thrift_spec = (
18635 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
18636 
  )
18637 
 
18638 
  def __init__(self, success=None,):
18639 
    self.success = success
18640 
 
18641 
  def read(self, iprot):
18642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18644 
      return
18645 
    iprot.readStructBegin()
18646 
    while True:
18647 
      (fname, ftype, fid) = iprot.readFieldBegin()
18648 
      if ftype == TType.STOP:
18649 
        break
18650 
      if fid == 0:
18651 
        if ftype == TType.MAP:
18652 
          self.success = {}
8590 kshitij.so 18653 
          (_ktype373, _vtype374, _size372 ) = iprot.readMapBegin()
18654 
          for _i376 in xrange(_size372):
18655 
            _key377 = iprot.readString();
18656 
            _val378 = BrandInfo()
18657 
            _val378.read(iprot)
18658 
            self.success[_key377] = _val378
7272 amit.gupta 18659 
          iprot.readMapEnd()
18660 
        else:
18661 
          iprot.skip(ftype)
18662 
      else:
18663 
        iprot.skip(ftype)
18664 
      iprot.readFieldEnd()
18665 
    iprot.readStructEnd()
18666 
 
18667 
  def write(self, oprot):
18668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18670 
      return
18671 
    oprot.writeStructBegin('getBrandInfo_result')
18672 
    if self.success is not None:
18673 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18674 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
8590 kshitij.so 18675 
      for kiter379,viter380 in self.success.items():
18676 
        oprot.writeString(kiter379)
18677 
        viter380.write(oprot)
7272 amit.gupta 18678 
      oprot.writeMapEnd()
18679 
      oprot.writeFieldEnd()
18680 
    oprot.writeFieldStop()
18681 
    oprot.writeStructEnd()
18682 
 
18683 
  def validate(self):
18684 
    return
18685 
 
18686 
 
18687 
  def __repr__(self):
18688 
    L = ['%s=%r' % (key, value)
18689 
      for key, value in self.__dict__.iteritems()]
18690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18691 
 
18692 
  def __eq__(self, other):
18693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18694 
 
18695 
  def __ne__(self, other):
18696 
    return not (self == other)
18697 
 
7256 rajveer 18698 
class getStorePricing_args:
18699 
  """
18700 
  Attributes:
18701 
   - itemId
18702 
  """
18703 
 
18704 
  thrift_spec = (
18705 
    None, # 0
18706 
    (1, TType.I64, 'itemId', None, None, ), # 1
18707 
  )
18708 
 
18709 
  def __init__(self, itemId=None,):
18710 
    self.itemId = itemId
18711 
 
18712 
  def read(self, iprot):
18713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18715 
      return
18716 
    iprot.readStructBegin()
18717 
    while True:
18718 
      (fname, ftype, fid) = iprot.readFieldBegin()
18719 
      if ftype == TType.STOP:
18720 
        break
18721 
      if fid == 1:
18722 
        if ftype == TType.I64:
18723 
          self.itemId = iprot.readI64();
18724 
        else:
18725 
          iprot.skip(ftype)
18726 
      else:
18727 
        iprot.skip(ftype)
18728 
      iprot.readFieldEnd()
18729 
    iprot.readStructEnd()
18730 
 
18731 
  def write(self, oprot):
18732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18734 
      return
18735 
    oprot.writeStructBegin('getStorePricing_args')
18736 
    if self.itemId is not None:
18737 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
18738 
      oprot.writeI64(self.itemId)
18739 
      oprot.writeFieldEnd()
18740 
    oprot.writeFieldStop()
18741 
    oprot.writeStructEnd()
18742 
 
18743 
  def validate(self):
18744 
    return
18745 
 
18746 
 
18747 
  def __repr__(self):
18748 
    L = ['%s=%r' % (key, value)
18749 
      for key, value in self.__dict__.iteritems()]
18750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18751 
 
18752 
  def __eq__(self, other):
18753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18754 
 
18755 
  def __ne__(self, other):
18756 
    return not (self == other)
18757 
 
18758 
class getStorePricing_result:
18759 
  """
18760 
  Attributes:
18761 
   - success
18762 
  """
18763 
 
18764 
  thrift_spec = (
18765 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
18766 
  )
18767 
 
18768 
  def __init__(self, success=None,):
18769 
    self.success = success
18770 
 
18771 
  def read(self, iprot):
18772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18774 
      return
18775 
    iprot.readStructBegin()
18776 
    while True:
18777 
      (fname, ftype, fid) = iprot.readFieldBegin()
18778 
      if ftype == TType.STOP:
18779 
        break
18780 
      if fid == 0:
18781 
        if ftype == TType.STRUCT:
18782 
          self.success = StorePricing()
18783 
          self.success.read(iprot)
18784 
        else:
18785 
          iprot.skip(ftype)
18786 
      else:
18787 
        iprot.skip(ftype)
18788 
      iprot.readFieldEnd()
18789 
    iprot.readStructEnd()
18790 
 
18791 
  def write(self, oprot):
18792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18794 
      return
18795 
    oprot.writeStructBegin('getStorePricing_result')
18796 
    if self.success is not None:
18797 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18798 
      self.success.write(oprot)
18799 
      oprot.writeFieldEnd()
18800 
    oprot.writeFieldStop()
18801 
    oprot.writeStructEnd()
18802 
 
18803 
  def validate(self):
18804 
    return
18805 
 
18806 
 
18807 
  def __repr__(self):
18808 
    L = ['%s=%r' % (key, value)
18809 
      for key, value in self.__dict__.iteritems()]
18810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18811 
 
18812 
  def __eq__(self, other):
18813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18814 
 
18815 
  def __ne__(self, other):
18816 
    return not (self == other)
7265 rajveer 18817 
 
7306 rajveer 18818 
class getStorePricings_args:
18819 
  """
18820 
  Attributes:
18821 
   - itemIds
18822 
  """
18823 
 
18824 
  thrift_spec = (
18825 
    None, # 0
18826 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
18827 
  )
18828 
 
18829 
  def __init__(self, itemIds=None,):
18830 
    self.itemIds = itemIds
18831 
 
18832 
  def read(self, iprot):
18833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18835 
      return
18836 
    iprot.readStructBegin()
18837 
    while True:
18838 
      (fname, ftype, fid) = iprot.readFieldBegin()
18839 
      if ftype == TType.STOP:
18840 
        break
18841 
      if fid == 1:
18842 
        if ftype == TType.LIST:
18843 
          self.itemIds = []
8590 kshitij.so 18844 
          (_etype384, _size381) = iprot.readListBegin()
18845 
          for _i385 in xrange(_size381):
18846 
            _elem386 = iprot.readI64();
18847 
            self.itemIds.append(_elem386)
7306 rajveer 18848 
          iprot.readListEnd()
18849 
        else:
18850 
          iprot.skip(ftype)
18851 
      else:
18852 
        iprot.skip(ftype)
18853 
      iprot.readFieldEnd()
18854 
    iprot.readStructEnd()
18855 
 
18856 
  def write(self, oprot):
18857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18859 
      return
18860 
    oprot.writeStructBegin('getStorePricings_args')
18861 
    if self.itemIds is not None:
18862 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
18863 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
8590 kshitij.so 18864 
      for iter387 in self.itemIds:
18865 
        oprot.writeI64(iter387)
7306 rajveer 18866 
      oprot.writeListEnd()
18867 
      oprot.writeFieldEnd()
18868 
    oprot.writeFieldStop()
18869 
    oprot.writeStructEnd()
18870 
 
18871 
  def validate(self):
18872 
    return
18873 
 
18874 
 
18875 
  def __repr__(self):
18876 
    L = ['%s=%r' % (key, value)
18877 
      for key, value in self.__dict__.iteritems()]
18878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18879 
 
18880 
  def __eq__(self, other):
18881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18882 
 
18883 
  def __ne__(self, other):
18884 
    return not (self == other)
18885 
 
18886 
class getStorePricings_result:
18887 
  """
18888 
  Attributes:
18889 
   - success
18890 
  """
18891 
 
18892 
  thrift_spec = (
18893 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
18894 
  )
18895 
 
18896 
  def __init__(self, success=None,):
18897 
    self.success = success
18898 
 
18899 
  def read(self, iprot):
18900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18902 
      return
18903 
    iprot.readStructBegin()
18904 
    while True:
18905 
      (fname, ftype, fid) = iprot.readFieldBegin()
18906 
      if ftype == TType.STOP:
18907 
        break
18908 
      if fid == 0:
18909 
        if ftype == TType.LIST:
18910 
          self.success = []
8590 kshitij.so 18911 
          (_etype391, _size388) = iprot.readListBegin()
18912 
          for _i392 in xrange(_size388):
18913 
            _elem393 = StorePricing()
18914 
            _elem393.read(iprot)
18915 
            self.success.append(_elem393)
7306 rajveer 18916 
          iprot.readListEnd()
18917 
        else:
18918 
          iprot.skip(ftype)
18919 
      else:
18920 
        iprot.skip(ftype)
18921 
      iprot.readFieldEnd()
18922 
    iprot.readStructEnd()
18923 
 
18924 
  def write(self, oprot):
18925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18927 
      return
18928 
    oprot.writeStructBegin('getStorePricings_result')
18929 
    if self.success is not None:
18930 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18931 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 18932 
      for iter394 in self.success:
18933 
        iter394.write(oprot)
7306 rajveer 18934 
      oprot.writeListEnd()
18935 
      oprot.writeFieldEnd()
18936 
    oprot.writeFieldStop()
18937 
    oprot.writeStructEnd()
18938 
 
18939 
  def validate(self):
18940 
    return
18941 
 
18942 
 
18943 
  def __repr__(self):
18944 
    L = ['%s=%r' % (key, value)
18945 
      for key, value in self.__dict__.iteritems()]
18946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18947 
 
18948 
  def __eq__(self, other):
18949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18950 
 
18951 
  def __ne__(self, other):
18952 
    return not (self == other)
18953 
 
7265 rajveer 18954 
class updateStorePricing_args:
18955 
  """
18956 
  Attributes:
18957 
   - sp
7382 rajveer 18958 
   - allColors
7265 rajveer 18959 
  """
18960 
 
18961 
  thrift_spec = (
18962 
    None, # 0
18963 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 18964 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 18965 
  )
18966 
 
7382 rajveer 18967 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 18968 
    self.sp = sp
7382 rajveer 18969 
    self.allColors = allColors
7265 rajveer 18970 
 
18971 
  def read(self, iprot):
18972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18974 
      return
18975 
    iprot.readStructBegin()
18976 
    while True:
18977 
      (fname, ftype, fid) = iprot.readFieldBegin()
18978 
      if ftype == TType.STOP:
18979 
        break
18980 
      if fid == 1:
18981 
        if ftype == TType.STRUCT:
18982 
          self.sp = StorePricing()
18983 
          self.sp.read(iprot)
18984 
        else:
18985 
          iprot.skip(ftype)
7382 rajveer 18986 
      elif fid == 2:
18987 
        if ftype == TType.BOOL:
18988 
          self.allColors = iprot.readBool();
18989 
        else:
18990 
          iprot.skip(ftype)
7265 rajveer 18991 
      else:
18992 
        iprot.skip(ftype)
18993 
      iprot.readFieldEnd()
18994 
    iprot.readStructEnd()
18995 
 
18996 
  def write(self, oprot):
18997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18999 
      return
19000 
    oprot.writeStructBegin('updateStorePricing_args')
19001 
    if self.sp is not None:
19002 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
19003 
      self.sp.write(oprot)
19004 
      oprot.writeFieldEnd()
7382 rajveer 19005 
    if self.allColors is not None:
19006 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
19007 
      oprot.writeBool(self.allColors)
19008 
      oprot.writeFieldEnd()
7265 rajveer 19009 
    oprot.writeFieldStop()
19010 
    oprot.writeStructEnd()
19011 
 
19012 
  def validate(self):
19013 
    return
19014 
 
19015 
 
19016 
  def __repr__(self):
19017 
    L = ['%s=%r' % (key, value)
19018 
      for key, value in self.__dict__.iteritems()]
19019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19020 
 
19021 
  def __eq__(self, other):
19022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19023 
 
19024 
  def __ne__(self, other):
19025 
    return not (self == other)
19026 
 
19027 
class updateStorePricing_result:
19028 
 
19029 
  thrift_spec = (
19030 
  )
19031 
 
19032 
  def read(self, iprot):
19033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19035 
      return
19036 
    iprot.readStructBegin()
19037 
    while True:
19038 
      (fname, ftype, fid) = iprot.readFieldBegin()
19039 
      if ftype == TType.STOP:
19040 
        break
19041 
      else:
19042 
        iprot.skip(ftype)
19043 
      iprot.readFieldEnd()
19044 
    iprot.readStructEnd()
19045 
 
19046 
  def write(self, oprot):
19047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19049 
      return
19050 
    oprot.writeStructBegin('updateStorePricing_result')
19051 
    oprot.writeFieldStop()
19052 
    oprot.writeStructEnd()
19053 
 
19054 
  def validate(self):
19055 
    return
19056 
 
19057 
 
19058 
  def __repr__(self):
19059 
    L = ['%s=%r' % (key, value)
19060 
      for key, value in self.__dict__.iteritems()]
19061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19062 
 
19063 
  def __eq__(self, other):
19064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19065 
 
19066 
  def __ne__(self, other):
19067 
    return not (self == other)
7281 kshitij.so 19068 
 
19069 
class getAllAmazonListedItems_args:
19070 
 
19071 
  thrift_spec = (
19072 
  )
19073 
 
19074 
  def read(self, iprot):
19075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19077 
      return
19078 
    iprot.readStructBegin()
19079 
    while True:
19080 
      (fname, ftype, fid) = iprot.readFieldBegin()
19081 
      if ftype == TType.STOP:
19082 
        break
19083 
      else:
19084 
        iprot.skip(ftype)
19085 
      iprot.readFieldEnd()
19086 
    iprot.readStructEnd()
19087 
 
19088 
  def write(self, oprot):
19089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19091 
      return
19092 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
19093 
    oprot.writeFieldStop()
19094 
    oprot.writeStructEnd()
19095 
 
19096 
  def validate(self):
19097 
    return
19098 
 
19099 
 
19100 
  def __repr__(self):
19101 
    L = ['%s=%r' % (key, value)
19102 
      for key, value in self.__dict__.iteritems()]
19103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19104 
 
19105 
  def __eq__(self, other):
19106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19107 
 
19108 
  def __ne__(self, other):
19109 
    return not (self == other)
19110 
 
19111 
class getAllAmazonListedItems_result:
19112 
  """
19113 
  Attributes:
19114 
   - success
19115 
  """
19116 
 
19117 
  thrift_spec = (
19118 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19119 
  )
19120 
 
19121 
  def __init__(self, success=None,):
19122 
    self.success = success
19123 
 
19124 
  def read(self, iprot):
19125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19127 
      return
19128 
    iprot.readStructBegin()
19129 
    while True:
19130 
      (fname, ftype, fid) = iprot.readFieldBegin()
19131 
      if ftype == TType.STOP:
19132 
        break
19133 
      if fid == 0:
19134 
        if ftype == TType.LIST:
19135 
          self.success = []
8590 kshitij.so 19136 
          (_etype398, _size395) = iprot.readListBegin()
19137 
          for _i399 in xrange(_size395):
19138 
            _elem400 = Amazonlisted()
19139 
            _elem400.read(iprot)
19140 
            self.success.append(_elem400)
7281 kshitij.so 19141 
          iprot.readListEnd()
19142 
        else:
19143 
          iprot.skip(ftype)
19144 
      else:
19145 
        iprot.skip(ftype)
19146 
      iprot.readFieldEnd()
19147 
    iprot.readStructEnd()
19148 
 
19149 
  def write(self, oprot):
19150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19152 
      return
19153 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
19154 
    if self.success is not None:
19155 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19156 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8590 kshitij.so 19157 
      for iter401 in self.success:
19158 
        iter401.write(oprot)
7281 kshitij.so 19159 
      oprot.writeListEnd()
19160 
      oprot.writeFieldEnd()
19161 
    oprot.writeFieldStop()
19162 
    oprot.writeStructEnd()
19163 
 
19164 
  def validate(self):
19165 
    return
19166 
 
19167 
 
19168 
  def __repr__(self):
19169 
    L = ['%s=%r' % (key, value)
19170 
      for key, value in self.__dict__.iteritems()]
19171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19172 
 
19173 
  def __eq__(self, other):
19174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19175 
 
19176 
  def __ne__(self, other):
19177 
    return not (self == other)
19178 
 
8619 kshitij.so 19179 
class searchAmazonItems_args:
19180 
  """
19181 
  Attributes:
19182 
   - searchTerm
19183 
   - offset
19184 
   - limit
19185 
  """
19186 
 
19187 
  thrift_spec = (
19188 
    None, # 0
19189 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19190 
    (2, TType.I64, 'offset', None, None, ), # 2
19191 
    (3, TType.I64, 'limit', None, None, ), # 3
19192 
  )
19193 
 
19194 
  def __init__(self, searchTerm=None, offset=None, limit=None,):
19195 
    self.searchTerm = searchTerm
19196 
    self.offset = offset
19197 
    self.limit = limit
19198 
 
19199 
  def read(self, iprot):
19200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19202 
      return
19203 
    iprot.readStructBegin()
19204 
    while True:
19205 
      (fname, ftype, fid) = iprot.readFieldBegin()
19206 
      if ftype == TType.STOP:
19207 
        break
19208 
      if fid == 1:
19209 
        if ftype == TType.LIST:
19210 
          self.searchTerm = []
19211 
          (_etype405, _size402) = iprot.readListBegin()
19212 
          for _i406 in xrange(_size402):
19213 
            _elem407 = iprot.readString();
19214 
            self.searchTerm.append(_elem407)
19215 
          iprot.readListEnd()
19216 
        else:
19217 
          iprot.skip(ftype)
19218 
      elif fid == 2:
19219 
        if ftype == TType.I64:
19220 
          self.offset = iprot.readI64();
19221 
        else:
19222 
          iprot.skip(ftype)
19223 
      elif fid == 3:
19224 
        if ftype == TType.I64:
19225 
          self.limit = iprot.readI64();
19226 
        else:
19227 
          iprot.skip(ftype)
19228 
      else:
19229 
        iprot.skip(ftype)
19230 
      iprot.readFieldEnd()
19231 
    iprot.readStructEnd()
19232 
 
19233 
  def write(self, oprot):
19234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19236 
      return
19237 
    oprot.writeStructBegin('searchAmazonItems_args')
19238 
    if self.searchTerm is not None:
19239 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19240 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
19241 
      for iter408 in self.searchTerm:
19242 
        oprot.writeString(iter408)
19243 
      oprot.writeListEnd()
19244 
      oprot.writeFieldEnd()
19245 
    if self.offset is not None:
19246 
      oprot.writeFieldBegin('offset', TType.I64, 2)
19247 
      oprot.writeI64(self.offset)
19248 
      oprot.writeFieldEnd()
19249 
    if self.limit is not None:
19250 
      oprot.writeFieldBegin('limit', TType.I64, 3)
19251 
      oprot.writeI64(self.limit)
19252 
      oprot.writeFieldEnd()
19253 
    oprot.writeFieldStop()
19254 
    oprot.writeStructEnd()
19255 
 
19256 
  def validate(self):
19257 
    return
19258 
 
19259 
 
19260 
  def __repr__(self):
19261 
    L = ['%s=%r' % (key, value)
19262 
      for key, value in self.__dict__.iteritems()]
19263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19264 
 
19265 
  def __eq__(self, other):
19266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19267 
 
19268 
  def __ne__(self, other):
19269 
    return not (self == other)
19270 
 
19271 
class searchAmazonItems_result:
19272 
  """
19273 
  Attributes:
19274 
   - success
19275 
  """
19276 
 
19277 
  thrift_spec = (
19278 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
19279 
  )
19280 
 
19281 
  def __init__(self, success=None,):
19282 
    self.success = success
19283 
 
19284 
  def read(self, iprot):
19285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19287 
      return
19288 
    iprot.readStructBegin()
19289 
    while True:
19290 
      (fname, ftype, fid) = iprot.readFieldBegin()
19291 
      if ftype == TType.STOP:
19292 
        break
19293 
      if fid == 0:
19294 
        if ftype == TType.LIST:
19295 
          self.success = []
19296 
          (_etype412, _size409) = iprot.readListBegin()
19297 
          for _i413 in xrange(_size409):
19298 
            _elem414 = Amazonlisted()
19299 
            _elem414.read(iprot)
19300 
            self.success.append(_elem414)
19301 
          iprot.readListEnd()
19302 
        else:
19303 
          iprot.skip(ftype)
19304 
      else:
19305 
        iprot.skip(ftype)
19306 
      iprot.readFieldEnd()
19307 
    iprot.readStructEnd()
19308 
 
19309 
  def write(self, oprot):
19310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19312 
      return
19313 
    oprot.writeStructBegin('searchAmazonItems_result')
19314 
    if self.success is not None:
19315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
19317 
      for iter415 in self.success:
19318 
        iter415.write(oprot)
19319 
      oprot.writeListEnd()
19320 
      oprot.writeFieldEnd()
19321 
    oprot.writeFieldStop()
19322 
    oprot.writeStructEnd()
19323 
 
19324 
  def validate(self):
19325 
    return
19326 
 
19327 
 
19328 
  def __repr__(self):
19329 
    L = ['%s=%r' % (key, value)
19330 
      for key, value in self.__dict__.iteritems()]
19331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19332 
 
19333 
  def __eq__(self, other):
19334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19335 
 
19336 
  def __ne__(self, other):
19337 
    return not (self == other)
19338 
 
19339 
class getAmazonSearchResultCount_args:
19340 
  """
19341 
  Attributes:
19342 
   - searchTerm
19343 
  """
19344 
 
19345 
  thrift_spec = (
19346 
    None, # 0
19347 
    (1, TType.LIST, 'searchTerm', (TType.STRING,None), None, ), # 1
19348 
  )
19349 
 
19350 
  def __init__(self, searchTerm=None,):
19351 
    self.searchTerm = searchTerm
19352 
 
19353 
  def read(self, iprot):
19354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19356 
      return
19357 
    iprot.readStructBegin()
19358 
    while True:
19359 
      (fname, ftype, fid) = iprot.readFieldBegin()
19360 
      if ftype == TType.STOP:
19361 
        break
19362 
      if fid == 1:
19363 
        if ftype == TType.LIST:
19364 
          self.searchTerm = []
19365 
          (_etype419, _size416) = iprot.readListBegin()
19366 
          for _i420 in xrange(_size416):
19367 
            _elem421 = iprot.readString();
19368 
            self.searchTerm.append(_elem421)
19369 
          iprot.readListEnd()
19370 
        else:
19371 
          iprot.skip(ftype)
19372 
      else:
19373 
        iprot.skip(ftype)
19374 
      iprot.readFieldEnd()
19375 
    iprot.readStructEnd()
19376 
 
19377 
  def write(self, oprot):
19378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19380 
      return
19381 
    oprot.writeStructBegin('getAmazonSearchResultCount_args')
19382 
    if self.searchTerm is not None:
19383 
      oprot.writeFieldBegin('searchTerm', TType.LIST, 1)
19384 
      oprot.writeListBegin(TType.STRING, len(self.searchTerm))
19385 
      for iter422 in self.searchTerm:
19386 
        oprot.writeString(iter422)
19387 
      oprot.writeListEnd()
19388 
      oprot.writeFieldEnd()
19389 
    oprot.writeFieldStop()
19390 
    oprot.writeStructEnd()
19391 
 
19392 
  def validate(self):
19393 
    return
19394 
 
19395 
 
19396 
  def __repr__(self):
19397 
    L = ['%s=%r' % (key, value)
19398 
      for key, value in self.__dict__.iteritems()]
19399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19400 
 
19401 
  def __eq__(self, other):
19402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19403 
 
19404 
  def __ne__(self, other):
19405 
    return not (self == other)
19406 
 
19407 
class getAmazonSearchResultCount_result:
19408 
  """
19409 
  Attributes:
19410 
   - success
19411 
  """
19412 
 
19413 
  thrift_spec = (
19414 
    (0, TType.I64, 'success', None, None, ), # 0
19415 
  )
19416 
 
19417 
  def __init__(self, success=None,):
19418 
    self.success = success
19419 
 
19420 
  def read(self, iprot):
19421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19423 
      return
19424 
    iprot.readStructBegin()
19425 
    while True:
19426 
      (fname, ftype, fid) = iprot.readFieldBegin()
19427 
      if ftype == TType.STOP:
19428 
        break
19429 
      if fid == 0:
19430 
        if ftype == TType.I64:
19431 
          self.success = iprot.readI64();
19432 
        else:
19433 
          iprot.skip(ftype)
19434 
      else:
19435 
        iprot.skip(ftype)
19436 
      iprot.readFieldEnd()
19437 
    iprot.readStructEnd()
19438 
 
19439 
  def write(self, oprot):
19440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19442 
      return
19443 
    oprot.writeStructBegin('getAmazonSearchResultCount_result')
19444 
    if self.success is not None:
19445 
      oprot.writeFieldBegin('success', TType.I64, 0)
19446 
      oprot.writeI64(self.success)
19447 
      oprot.writeFieldEnd()
19448 
    oprot.writeFieldStop()
19449 
    oprot.writeStructEnd()
19450 
 
19451 
  def validate(self):
19452 
    return
19453 
 
19454 
 
19455 
  def __repr__(self):
19456 
    L = ['%s=%r' % (key, value)
19457 
      for key, value in self.__dict__.iteritems()]
19458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19459 
 
19460 
  def __eq__(self, other):
19461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19462 
 
19463 
  def __ne__(self, other):
19464 
    return not (self == other)
19465 
 
19466 
class getCountForAmazonlistedItems_args:
19467 
 
19468 
  thrift_spec = (
19469 
  )
19470 
 
19471 
  def read(self, iprot):
19472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19474 
      return
19475 
    iprot.readStructBegin()
19476 
    while True:
19477 
      (fname, ftype, fid) = iprot.readFieldBegin()
19478 
      if ftype == TType.STOP:
19479 
        break
19480 
      else:
19481 
        iprot.skip(ftype)
19482 
      iprot.readFieldEnd()
19483 
    iprot.readStructEnd()
19484 
 
19485 
  def write(self, oprot):
19486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19488 
      return
19489 
    oprot.writeStructBegin('getCountForAmazonlistedItems_args')
19490 
    oprot.writeFieldStop()
19491 
    oprot.writeStructEnd()
19492 
 
19493 
  def validate(self):
19494 
    return
19495 
 
19496 
 
19497 
  def __repr__(self):
19498 
    L = ['%s=%r' % (key, value)
19499 
      for key, value in self.__dict__.iteritems()]
19500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19501 
 
19502 
  def __eq__(self, other):
19503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19504 
 
19505 
  def __ne__(self, other):
19506 
    return not (self == other)
19507 
 
19508 
class getCountForAmazonlistedItems_result:
19509 
  """
19510 
  Attributes:
19511 
   - success
19512 
  """
19513 
 
19514 
  thrift_spec = (
19515 
    (0, TType.I64, 'success', None, None, ), # 0
19516 
  )
19517 
 
19518 
  def __init__(self, success=None,):
19519 
    self.success = success
19520 
 
19521 
  def read(self, iprot):
19522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19524 
      return
19525 
    iprot.readStructBegin()
19526 
    while True:
19527 
      (fname, ftype, fid) = iprot.readFieldBegin()
19528 
      if ftype == TType.STOP:
19529 
        break
19530 
      if fid == 0:
19531 
        if ftype == TType.I64:
19532 
          self.success = iprot.readI64();
19533 
        else:
19534 
          iprot.skip(ftype)
19535 
      else:
19536 
        iprot.skip(ftype)
19537 
      iprot.readFieldEnd()
19538 
    iprot.readStructEnd()
19539 
 
19540 
  def write(self, oprot):
19541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19543 
      return
19544 
    oprot.writeStructBegin('getCountForAmazonlistedItems_result')
19545 
    if self.success is not None:
19546 
      oprot.writeFieldBegin('success', TType.I64, 0)
19547 
      oprot.writeI64(self.success)
19548 
      oprot.writeFieldEnd()
19549 
    oprot.writeFieldStop()
19550 
    oprot.writeStructEnd()
19551 
 
19552 
  def validate(self):
19553 
    return
19554 
 
19555 
 
19556 
  def __repr__(self):
19557 
    L = ['%s=%r' % (key, value)
19558 
      for key, value in self.__dict__.iteritems()]
19559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19560 
 
19561 
  def __eq__(self, other):
19562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19563 
 
19564 
  def __ne__(self, other):
19565 
    return not (self == other)
19566 
 
7281 kshitij.so 19567 
class getAmazonItemDetails_args:
19568 
  """
19569 
  Attributes:
19570 
   - itemId
19571 
  """
19572 
 
19573 
  thrift_spec = (
19574 
    None, # 0
19575 
    (1, TType.I64, 'itemId', None, None, ), # 1
19576 
  )
19577 
 
19578 
  def __init__(self, itemId=None,):
19579 
    self.itemId = itemId
19580 
 
19581 
  def read(self, iprot):
19582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19584 
      return
19585 
    iprot.readStructBegin()
19586 
    while True:
19587 
      (fname, ftype, fid) = iprot.readFieldBegin()
19588 
      if ftype == TType.STOP:
19589 
        break
19590 
      if fid == 1:
19591 
        if ftype == TType.I64:
19592 
          self.itemId = iprot.readI64();
19593 
        else:
19594 
          iprot.skip(ftype)
19595 
      else:
19596 
        iprot.skip(ftype)
19597 
      iprot.readFieldEnd()
19598 
    iprot.readStructEnd()
19599 
 
19600 
  def write(self, oprot):
19601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19603 
      return
19604 
    oprot.writeStructBegin('getAmazonItemDetails_args')
19605 
    if self.itemId is not None:
19606 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19607 
      oprot.writeI64(self.itemId)
19608 
      oprot.writeFieldEnd()
19609 
    oprot.writeFieldStop()
19610 
    oprot.writeStructEnd()
19611 
 
19612 
  def validate(self):
19613 
    return
19614 
 
19615 
 
19616 
  def __repr__(self):
19617 
    L = ['%s=%r' % (key, value)
19618 
      for key, value in self.__dict__.iteritems()]
19619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19620 
 
19621 
  def __eq__(self, other):
19622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19623 
 
19624 
  def __ne__(self, other):
19625 
    return not (self == other)
19626 
 
19627 
class getAmazonItemDetails_result:
19628 
  """
19629 
  Attributes:
19630 
   - success
19631 
  """
19632 
 
19633 
  thrift_spec = (
19634 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
19635 
  )
19636 
 
19637 
  def __init__(self, success=None,):
19638 
    self.success = success
19639 
 
19640 
  def read(self, iprot):
19641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19643 
      return
19644 
    iprot.readStructBegin()
19645 
    while True:
19646 
      (fname, ftype, fid) = iprot.readFieldBegin()
19647 
      if ftype == TType.STOP:
19648 
        break
19649 
      if fid == 0:
19650 
        if ftype == TType.STRUCT:
19651 
          self.success = Amazonlisted()
19652 
          self.success.read(iprot)
19653 
        else:
19654 
          iprot.skip(ftype)
19655 
      else:
19656 
        iprot.skip(ftype)
19657 
      iprot.readFieldEnd()
19658 
    iprot.readStructEnd()
19659 
 
19660 
  def write(self, oprot):
19661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19663 
      return
19664 
    oprot.writeStructBegin('getAmazonItemDetails_result')
19665 
    if self.success is not None:
19666 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19667 
      self.success.write(oprot)
19668 
      oprot.writeFieldEnd()
19669 
    oprot.writeFieldStop()
19670 
    oprot.writeStructEnd()
19671 
 
19672 
  def validate(self):
19673 
    return
19674 
 
19675 
 
19676 
  def __repr__(self):
19677 
    L = ['%s=%r' % (key, value)
19678 
      for key, value in self.__dict__.iteritems()]
19679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19680 
 
19681 
  def __eq__(self, other):
19682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19683 
 
19684 
  def __ne__(self, other):
19685 
    return not (self == other)
19686 
 
19687 
class updateAmazonItemDetails_args:
19688 
  """
19689 
  Attributes:
8168 kshitij.so 19690 
   - amazonlisted
7281 kshitij.so 19691 
  """
19692 
 
19693 
  thrift_spec = (
19694 
    None, # 0
8168 kshitij.so 19695 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
7281 kshitij.so 19696 
  )
19697 
 
8168 kshitij.so 19698 
  def __init__(self, amazonlisted=None,):
19699 
    self.amazonlisted = amazonlisted
7281 kshitij.so 19700 
 
19701 
  def read(self, iprot):
19702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19704 
      return
19705 
    iprot.readStructBegin()
19706 
    while True:
19707 
      (fname, ftype, fid) = iprot.readFieldBegin()
19708 
      if ftype == TType.STOP:
19709 
        break
19710 
      if fid == 1:
8168 kshitij.so 19711 
        if ftype == TType.STRUCT:
19712 
          self.amazonlisted = Amazonlisted()
19713 
          self.amazonlisted.read(iprot)
7281 kshitij.so 19714 
        else:
19715 
          iprot.skip(ftype)
19716 
      else:
19717 
        iprot.skip(ftype)
19718 
      iprot.readFieldEnd()
19719 
    iprot.readStructEnd()
19720 
 
19721 
  def write(self, oprot):
19722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19724 
      return
19725 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
8168 kshitij.so 19726 
    if self.amazonlisted is not None:
19727 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19728 
      self.amazonlisted.write(oprot)
7281 kshitij.so 19729 
      oprot.writeFieldEnd()
19730 
    oprot.writeFieldStop()
19731 
    oprot.writeStructEnd()
19732 
 
19733 
  def validate(self):
19734 
    return
19735 
 
19736 
 
19737 
  def __repr__(self):
19738 
    L = ['%s=%r' % (key, value)
19739 
      for key, value in self.__dict__.iteritems()]
19740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19741 
 
19742 
  def __eq__(self, other):
19743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19744 
 
19745 
  def __ne__(self, other):
19746 
    return not (self == other)
19747 
 
19748 
class updateAmazonItemDetails_result:
19749 
 
19750 
  thrift_spec = (
19751 
  )
19752 
 
19753 
  def read(self, iprot):
19754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19756 
      return
19757 
    iprot.readStructBegin()
19758 
    while True:
19759 
      (fname, ftype, fid) = iprot.readFieldBegin()
19760 
      if ftype == TType.STOP:
19761 
        break
19762 
      else:
19763 
        iprot.skip(ftype)
19764 
      iprot.readFieldEnd()
19765 
    iprot.readStructEnd()
19766 
 
19767 
  def write(self, oprot):
19768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19770 
      return
19771 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
19772 
    oprot.writeFieldStop()
19773 
    oprot.writeStructEnd()
19774 
 
19775 
  def validate(self):
19776 
    return
19777 
 
19778 
 
19779 
  def __repr__(self):
19780 
    L = ['%s=%r' % (key, value)
19781 
      for key, value in self.__dict__.iteritems()]
19782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19783 
 
19784 
  def __eq__(self, other):
19785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19786 
 
19787 
  def __ne__(self, other):
19788 
    return not (self == other)
19789 
 
19790 
class addAmazonItem_args:
19791 
  """
19792 
  Attributes:
19793 
   - amazonlisted
19794 
  """
19795 
 
19796 
  thrift_spec = (
19797 
    None, # 0
19798 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
19799 
  )
19800 
 
19801 
  def __init__(self, amazonlisted=None,):
19802 
    self.amazonlisted = amazonlisted
19803 
 
19804 
  def read(self, iprot):
19805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19807 
      return
19808 
    iprot.readStructBegin()
19809 
    while True:
19810 
      (fname, ftype, fid) = iprot.readFieldBegin()
19811 
      if ftype == TType.STOP:
19812 
        break
19813 
      if fid == 1:
19814 
        if ftype == TType.STRUCT:
19815 
          self.amazonlisted = Amazonlisted()
19816 
          self.amazonlisted.read(iprot)
19817 
        else:
19818 
          iprot.skip(ftype)
19819 
      else:
19820 
        iprot.skip(ftype)
19821 
      iprot.readFieldEnd()
19822 
    iprot.readStructEnd()
19823 
 
19824 
  def write(self, oprot):
19825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19827 
      return
19828 
    oprot.writeStructBegin('addAmazonItem_args')
19829 
    if self.amazonlisted is not None:
19830 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
19831 
      self.amazonlisted.write(oprot)
19832 
      oprot.writeFieldEnd()
19833 
    oprot.writeFieldStop()
19834 
    oprot.writeStructEnd()
19835 
 
19836 
  def validate(self):
19837 
    return
19838 
 
19839 
 
19840 
  def __repr__(self):
19841 
    L = ['%s=%r' % (key, value)
19842 
      for key, value in self.__dict__.iteritems()]
19843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19844 
 
19845 
  def __eq__(self, other):
19846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19847 
 
19848 
  def __ne__(self, other):
19849 
    return not (self == other)
19850 
 
19851 
class addAmazonItem_result:
19852 
 
19853 
  thrift_spec = (
19854 
  )
19855 
 
19856 
  def read(self, iprot):
19857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19859 
      return
19860 
    iprot.readStructBegin()
19861 
    while True:
19862 
      (fname, ftype, fid) = iprot.readFieldBegin()
19863 
      if ftype == TType.STOP:
19864 
        break
19865 
      else:
19866 
        iprot.skip(ftype)
19867 
      iprot.readFieldEnd()
19868 
    iprot.readStructEnd()
19869 
 
19870 
  def write(self, oprot):
19871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19873 
      return
19874 
    oprot.writeStructBegin('addAmazonItem_result')
19875 
    oprot.writeFieldStop()
19876 
    oprot.writeStructEnd()
19877 
 
19878 
  def validate(self):
19879 
    return
19880 
 
19881 
 
19882 
  def __repr__(self):
19883 
    L = ['%s=%r' % (key, value)
19884 
      for key, value in self.__dict__.iteritems()]
19885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19886 
 
19887 
  def __eq__(self, other):
19888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19889 
 
19890 
  def __ne__(self, other):
19891 
    return not (self == other)
7291 vikram.rag 19892 
 
19893 
class getAsinItems_args:
19894 
 
19895 
  thrift_spec = (
19896 
  )
19897 
 
19898 
  def read(self, iprot):
19899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19901 
      return
19902 
    iprot.readStructBegin()
19903 
    while True:
19904 
      (fname, ftype, fid) = iprot.readFieldBegin()
19905 
      if ftype == TType.STOP:
19906 
        break
19907 
      else:
19908 
        iprot.skip(ftype)
19909 
      iprot.readFieldEnd()
19910 
    iprot.readStructEnd()
19911 
 
19912 
  def write(self, oprot):
19913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19915 
      return
19916 
    oprot.writeStructBegin('getAsinItems_args')
19917 
    oprot.writeFieldStop()
19918 
    oprot.writeStructEnd()
19919 
 
19920 
  def validate(self):
19921 
    return
19922 
 
19923 
 
19924 
  def __repr__(self):
19925 
    L = ['%s=%r' % (key, value)
19926 
      for key, value in self.__dict__.iteritems()]
19927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19928 
 
19929 
  def __eq__(self, other):
19930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19931 
 
19932 
  def __ne__(self, other):
19933 
    return not (self == other)
19934 
 
19935 
class getAsinItems_result:
19936 
  """
19937 
  Attributes:
19938 
   - success
19939 
  """
19940 
 
19941 
  thrift_spec = (
19942 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
19943 
  )
19944 
 
19945 
  def __init__(self, success=None,):
19946 
    self.success = success
19947 
 
19948 
  def read(self, iprot):
19949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19951 
      return
19952 
    iprot.readStructBegin()
19953 
    while True:
19954 
      (fname, ftype, fid) = iprot.readFieldBegin()
19955 
      if ftype == TType.STOP:
19956 
        break
19957 
      if fid == 0:
19958 
        if ftype == TType.LIST:
19959 
          self.success = []
8619 kshitij.so 19960 
          (_etype426, _size423) = iprot.readListBegin()
19961 
          for _i427 in xrange(_size423):
19962 
            _elem428 = Item()
19963 
            _elem428.read(iprot)
19964 
            self.success.append(_elem428)
7291 vikram.rag 19965 
          iprot.readListEnd()
19966 
        else:
19967 
          iprot.skip(ftype)
19968 
      else:
19969 
        iprot.skip(ftype)
19970 
      iprot.readFieldEnd()
19971 
    iprot.readStructEnd()
19972 
 
19973 
  def write(self, oprot):
19974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19976 
      return
19977 
    oprot.writeStructBegin('getAsinItems_result')
19978 
    if self.success is not None:
19979 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19980 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 19981 
      for iter429 in self.success:
19982 
        iter429.write(oprot)
7291 vikram.rag 19983 
      oprot.writeListEnd()
19984 
      oprot.writeFieldEnd()
19985 
    oprot.writeFieldStop()
19986 
    oprot.writeStructEnd()
19987 
 
19988 
  def validate(self):
19989 
    return
19990 
 
19991 
 
19992 
  def __repr__(self):
19993 
    L = ['%s=%r' % (key, value)
19994 
      for key, value in self.__dict__.iteritems()]
19995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19996 
 
19997 
  def __eq__(self, other):
19998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19999 
 
20000 
  def __ne__(self, other):
20001 
    return not (self == other)
20002 
 
20003 
class getAllFbaListedItems_args:
20004 
 
20005 
  thrift_spec = (
20006 
  )
20007 
 
20008 
  def read(self, iprot):
20009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20011 
      return
20012 
    iprot.readStructBegin()
20013 
    while True:
20014 
      (fname, ftype, fid) = iprot.readFieldBegin()
20015 
      if ftype == TType.STOP:
20016 
        break
20017 
      else:
20018 
        iprot.skip(ftype)
20019 
      iprot.readFieldEnd()
20020 
    iprot.readStructEnd()
20021 
 
20022 
  def write(self, oprot):
20023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20025 
      return
20026 
    oprot.writeStructBegin('getAllFbaListedItems_args')
20027 
    oprot.writeFieldStop()
20028 
    oprot.writeStructEnd()
20029 
 
20030 
  def validate(self):
20031 
    return
20032 
 
20033 
 
20034 
  def __repr__(self):
20035 
    L = ['%s=%r' % (key, value)
20036 
      for key, value in self.__dict__.iteritems()]
20037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20038 
 
20039 
  def __eq__(self, other):
20040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20041 
 
20042 
  def __ne__(self, other):
20043 
    return not (self == other)
20044 
 
20045 
class getAllFbaListedItems_result:
20046 
  """
20047 
  Attributes:
20048 
   - success
20049 
  """
20050 
 
20051 
  thrift_spec = (
20052 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20053 
  )
20054 
 
20055 
  def __init__(self, success=None,):
20056 
    self.success = success
20057 
 
20058 
  def read(self, iprot):
20059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20061 
      return
20062 
    iprot.readStructBegin()
20063 
    while True:
20064 
      (fname, ftype, fid) = iprot.readFieldBegin()
20065 
      if ftype == TType.STOP:
20066 
        break
20067 
      if fid == 0:
20068 
        if ftype == TType.LIST:
20069 
          self.success = []
8619 kshitij.so 20070 
          (_etype433, _size430) = iprot.readListBegin()
20071 
          for _i434 in xrange(_size430):
20072 
            _elem435 = Amazonlisted()
20073 
            _elem435.read(iprot)
20074 
            self.success.append(_elem435)
7291 vikram.rag 20075 
          iprot.readListEnd()
20076 
        else:
20077 
          iprot.skip(ftype)
20078 
      else:
20079 
        iprot.skip(ftype)
20080 
      iprot.readFieldEnd()
20081 
    iprot.readStructEnd()
20082 
 
20083 
  def write(self, oprot):
20084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20086 
      return
20087 
    oprot.writeStructBegin('getAllFbaListedItems_result')
20088 
    if self.success is not None:
20089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20090 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 20091 
      for iter436 in self.success:
20092 
        iter436.write(oprot)
7291 vikram.rag 20093 
      oprot.writeListEnd()
20094 
      oprot.writeFieldEnd()
20095 
    oprot.writeFieldStop()
20096 
    oprot.writeStructEnd()
20097 
 
20098 
  def validate(self):
20099 
    return
20100 
 
20101 
 
20102 
  def __repr__(self):
20103 
    L = ['%s=%r' % (key, value)
20104 
      for key, value in self.__dict__.iteritems()]
20105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20106 
 
20107 
  def __eq__(self, other):
20108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20109 
 
20110 
  def __ne__(self, other):
20111 
    return not (self == other)
20112 
 
20113 
class getAllNonFbaListedItems_args:
20114 
 
20115 
  thrift_spec = (
20116 
  )
20117 
 
20118 
  def read(self, iprot):
20119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20121 
      return
20122 
    iprot.readStructBegin()
20123 
    while True:
20124 
      (fname, ftype, fid) = iprot.readFieldBegin()
20125 
      if ftype == TType.STOP:
20126 
        break
20127 
      else:
20128 
        iprot.skip(ftype)
20129 
      iprot.readFieldEnd()
20130 
    iprot.readStructEnd()
20131 
 
20132 
  def write(self, oprot):
20133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20135 
      return
20136 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
20137 
    oprot.writeFieldStop()
20138 
    oprot.writeStructEnd()
20139 
 
20140 
  def validate(self):
20141 
    return
20142 
 
20143 
 
20144 
  def __repr__(self):
20145 
    L = ['%s=%r' % (key, value)
20146 
      for key, value in self.__dict__.iteritems()]
20147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20148 
 
20149 
  def __eq__(self, other):
20150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20151 
 
20152 
  def __ne__(self, other):
20153 
    return not (self == other)
20154 
 
20155 
class getAllNonFbaListedItems_result:
20156 
  """
20157 
  Attributes:
20158 
   - success
20159 
  """
20160 
 
20161 
  thrift_spec = (
20162 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
20163 
  )
20164 
 
20165 
  def __init__(self, success=None,):
20166 
    self.success = success
20167 
 
20168 
  def read(self, iprot):
20169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20171 
      return
20172 
    iprot.readStructBegin()
20173 
    while True:
20174 
      (fname, ftype, fid) = iprot.readFieldBegin()
20175 
      if ftype == TType.STOP:
20176 
        break
20177 
      if fid == 0:
20178 
        if ftype == TType.LIST:
20179 
          self.success = []
8619 kshitij.so 20180 
          (_etype440, _size437) = iprot.readListBegin()
20181 
          for _i441 in xrange(_size437):
20182 
            _elem442 = Amazonlisted()
20183 
            _elem442.read(iprot)
20184 
            self.success.append(_elem442)
7291 vikram.rag 20185 
          iprot.readListEnd()
20186 
        else:
20187 
          iprot.skip(ftype)
20188 
      else:
20189 
        iprot.skip(ftype)
20190 
      iprot.readFieldEnd()
20191 
    iprot.readStructEnd()
20192 
 
20193 
  def write(self, oprot):
20194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20196 
      return
20197 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
20198 
    if self.success is not None:
20199 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20200 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 20201 
      for iter443 in self.success:
20202 
        iter443.write(oprot)
7291 vikram.rag 20203 
      oprot.writeListEnd()
20204 
      oprot.writeFieldEnd()
20205 
    oprot.writeFieldStop()
20206 
    oprot.writeStructEnd()
20207 
 
20208 
  def validate(self):
20209 
    return
20210 
 
20211 
 
20212 
  def __repr__(self):
20213 
    L = ['%s=%r' % (key, value)
20214 
      for key, value in self.__dict__.iteritems()]
20215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20216 
 
20217 
  def __eq__(self, other):
20218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20219 
 
20220 
  def __ne__(self, other):
20221 
    return not (self == other)
7460 kshitij.so 20222 
 
20223 
class updateItemInventory_args:
20224 
  """
20225 
  Attributes:
20226 
   - itemId
20227 
   - holdInventory
20228 
   - defaultInventory
20229 
  """
20230 
 
20231 
  thrift_spec = (
20232 
    None, # 0
20233 
    (1, TType.I64, 'itemId', None, None, ), # 1
20234 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
20235 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
20236 
  )
20237 
 
20238 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
20239 
    self.itemId = itemId
20240 
    self.holdInventory = holdInventory
20241 
    self.defaultInventory = defaultInventory
20242 
 
20243 
  def read(self, iprot):
20244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20246 
      return
20247 
    iprot.readStructBegin()
20248 
    while True:
20249 
      (fname, ftype, fid) = iprot.readFieldBegin()
20250 
      if ftype == TType.STOP:
20251 
        break
20252 
      if fid == 1:
20253 
        if ftype == TType.I64:
20254 
          self.itemId = iprot.readI64();
20255 
        else:
20256 
          iprot.skip(ftype)
20257 
      elif fid == 2:
20258 
        if ftype == TType.I64:
20259 
          self.holdInventory = iprot.readI64();
20260 
        else:
20261 
          iprot.skip(ftype)
20262 
      elif fid == 3:
20263 
        if ftype == TType.I64:
20264 
          self.defaultInventory = iprot.readI64();
20265 
        else:
20266 
          iprot.skip(ftype)
20267 
      else:
20268 
        iprot.skip(ftype)
20269 
      iprot.readFieldEnd()
20270 
    iprot.readStructEnd()
20271 
 
20272 
  def write(self, oprot):
20273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20275 
      return
20276 
    oprot.writeStructBegin('updateItemInventory_args')
20277 
    if self.itemId is not None:
20278 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20279 
      oprot.writeI64(self.itemId)
20280 
      oprot.writeFieldEnd()
20281 
    if self.holdInventory is not None:
20282 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
20283 
      oprot.writeI64(self.holdInventory)
20284 
      oprot.writeFieldEnd()
20285 
    if self.defaultInventory is not None:
20286 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
20287 
      oprot.writeI64(self.defaultInventory)
20288 
      oprot.writeFieldEnd()
20289 
    oprot.writeFieldStop()
20290 
    oprot.writeStructEnd()
20291 
 
20292 
  def validate(self):
20293 
    return
20294 
 
20295 
 
20296 
  def __repr__(self):
20297 
    L = ['%s=%r' % (key, value)
20298 
      for key, value in self.__dict__.iteritems()]
20299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20300 
 
20301 
  def __eq__(self, other):
20302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20303 
 
20304 
  def __ne__(self, other):
20305 
    return not (self == other)
20306 
 
20307 
class updateItemInventory_result:
20308 
  """
20309 
  Attributes:
20310 
   - success
20311 
  """
20312 
 
20313 
  thrift_spec = (
20314 
    (0, TType.BOOL, 'success', None, None, ), # 0
20315 
  )
20316 
 
20317 
  def __init__(self, success=None,):
20318 
    self.success = success
20319 
 
20320 
  def read(self, iprot):
20321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20323 
      return
20324 
    iprot.readStructBegin()
20325 
    while True:
20326 
      (fname, ftype, fid) = iprot.readFieldBegin()
20327 
      if ftype == TType.STOP:
20328 
        break
20329 
      if fid == 0:
20330 
        if ftype == TType.BOOL:
20331 
          self.success = iprot.readBool();
20332 
        else:
20333 
          iprot.skip(ftype)
20334 
      else:
20335 
        iprot.skip(ftype)
20336 
      iprot.readFieldEnd()
20337 
    iprot.readStructEnd()
20338 
 
20339 
  def write(self, oprot):
20340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20342 
      return
20343 
    oprot.writeStructBegin('updateItemInventory_result')
20344 
    if self.success is not None:
20345 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20346 
      oprot.writeBool(self.success)
20347 
      oprot.writeFieldEnd()
20348 
    oprot.writeFieldStop()
20349 
    oprot.writeStructEnd()
20350 
 
20351 
  def validate(self):
20352 
    return
20353 
 
20354 
 
20355 
  def __repr__(self):
20356 
    L = ['%s=%r' % (key, value)
20357 
      for key, value in self.__dict__.iteritems()]
20358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20359 
 
20360 
  def __eq__(self, other):
20361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20362 
 
20363 
  def __ne__(self, other):
20364 
    return not (self == other)
7770 kshitij.so 20365 
 
20366 
class updateTimestampForAmazonFeeds_args:
20367 
  """
20368 
  Attributes:
20369 
   - type
20370 
   - sku
20371 
   - timestamp
20372 
  """
20373 
 
20374 
  thrift_spec = (
20375 
    None, # 0
20376 
    (1, TType.STRING, 'type', None, None, ), # 1
20377 
    (2, TType.LIST, 'sku', (TType.I64,None), None, ), # 2
20378 
    (3, TType.I64, 'timestamp', None, None, ), # 3
20379 
  )
20380 
 
20381 
  def __init__(self, type=None, sku=None, timestamp=None,):
20382 
    self.type = type
20383 
    self.sku = sku
20384 
    self.timestamp = timestamp
20385 
 
20386 
  def read(self, iprot):
20387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20389 
      return
20390 
    iprot.readStructBegin()
20391 
    while True:
20392 
      (fname, ftype, fid) = iprot.readFieldBegin()
20393 
      if ftype == TType.STOP:
20394 
        break
20395 
      if fid == 1:
20396 
        if ftype == TType.STRING:
20397 
          self.type = iprot.readString();
20398 
        else:
20399 
          iprot.skip(ftype)
20400 
      elif fid == 2:
20401 
        if ftype == TType.LIST:
20402 
          self.sku = []
8619 kshitij.so 20403 
          (_etype447, _size444) = iprot.readListBegin()
20404 
          for _i448 in xrange(_size444):
20405 
            _elem449 = iprot.readI64();
20406 
            self.sku.append(_elem449)
7770 kshitij.so 20407 
          iprot.readListEnd()
20408 
        else:
20409 
          iprot.skip(ftype)
20410 
      elif fid == 3:
20411 
        if ftype == TType.I64:
20412 
          self.timestamp = iprot.readI64();
20413 
        else:
20414 
          iprot.skip(ftype)
20415 
      else:
20416 
        iprot.skip(ftype)
20417 
      iprot.readFieldEnd()
20418 
    iprot.readStructEnd()
20419 
 
20420 
  def write(self, oprot):
20421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20423 
      return
20424 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_args')
20425 
    if self.type is not None:
20426 
      oprot.writeFieldBegin('type', TType.STRING, 1)
20427 
      oprot.writeString(self.type)
20428 
      oprot.writeFieldEnd()
20429 
    if self.sku is not None:
20430 
      oprot.writeFieldBegin('sku', TType.LIST, 2)
20431 
      oprot.writeListBegin(TType.I64, len(self.sku))
8619 kshitij.so 20432 
      for iter450 in self.sku:
20433 
        oprot.writeI64(iter450)
7770 kshitij.so 20434 
      oprot.writeListEnd()
20435 
      oprot.writeFieldEnd()
20436 
    if self.timestamp is not None:
20437 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
20438 
      oprot.writeI64(self.timestamp)
20439 
      oprot.writeFieldEnd()
20440 
    oprot.writeFieldStop()
20441 
    oprot.writeStructEnd()
20442 
 
20443 
  def validate(self):
20444 
    return
20445 
 
20446 
 
20447 
  def __repr__(self):
20448 
    L = ['%s=%r' % (key, value)
20449 
      for key, value in self.__dict__.iteritems()]
20450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20451 
 
20452 
  def __eq__(self, other):
20453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20454 
 
20455 
  def __ne__(self, other):
20456 
    return not (self == other)
20457 
 
20458 
class updateTimestampForAmazonFeeds_result:
20459 
  """
20460 
  Attributes:
20461 
   - success
20462 
  """
20463 
 
20464 
  thrift_spec = (
20465 
    (0, TType.BOOL, 'success', None, None, ), # 0
20466 
  )
20467 
 
20468 
  def __init__(self, success=None,):
20469 
    self.success = success
20470 
 
20471 
  def read(self, iprot):
20472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20474 
      return
20475 
    iprot.readStructBegin()
20476 
    while True:
20477 
      (fname, ftype, fid) = iprot.readFieldBegin()
20478 
      if ftype == TType.STOP:
20479 
        break
20480 
      if fid == 0:
20481 
        if ftype == TType.BOOL:
20482 
          self.success = iprot.readBool();
20483 
        else:
20484 
          iprot.skip(ftype)
20485 
      else:
20486 
        iprot.skip(ftype)
20487 
      iprot.readFieldEnd()
20488 
    iprot.readStructEnd()
20489 
 
20490 
  def write(self, oprot):
20491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20493 
      return
20494 
    oprot.writeStructBegin('updateTimestampForAmazonFeeds_result')
20495 
    if self.success is not None:
20496 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20497 
      oprot.writeBool(self.success)
20498 
      oprot.writeFieldEnd()
20499 
    oprot.writeFieldStop()
20500 
    oprot.writeStructEnd()
20501 
 
20502 
  def validate(self):
20503 
    return
20504 
 
20505 
 
20506 
  def __repr__(self):
20507 
    L = ['%s=%r' % (key, value)
20508 
      for key, value in self.__dict__.iteritems()]
20509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20510 
 
20511 
  def __eq__(self, other):
20512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20513 
 
20514 
  def __ne__(self, other):
20515 
    return not (self == other)
7897 amar.kumar 20516 
 
20517 
class getAllParentCategories_args:
20518 
 
20519 
  thrift_spec = (
20520 
  )
20521 
 
20522 
  def read(self, iprot):
20523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20525 
      return
20526 
    iprot.readStructBegin()
20527 
    while True:
20528 
      (fname, ftype, fid) = iprot.readFieldBegin()
20529 
      if ftype == TType.STOP:
20530 
        break
20531 
      else:
20532 
        iprot.skip(ftype)
20533 
      iprot.readFieldEnd()
20534 
    iprot.readStructEnd()
20535 
 
20536 
  def write(self, oprot):
20537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20539 
      return
20540 
    oprot.writeStructBegin('getAllParentCategories_args')
20541 
    oprot.writeFieldStop()
20542 
    oprot.writeStructEnd()
20543 
 
20544 
  def validate(self):
20545 
    return
20546 
 
20547 
 
20548 
  def __repr__(self):
20549 
    L = ['%s=%r' % (key, value)
20550 
      for key, value in self.__dict__.iteritems()]
20551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20552 
 
20553 
  def __eq__(self, other):
20554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20555 
 
20556 
  def __ne__(self, other):
20557 
    return not (self == other)
20558 
 
20559 
class getAllParentCategories_result:
20560 
  """
20561 
  Attributes:
20562 
   - success
20563 
  """
20564 
 
20565 
  thrift_spec = (
20566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
20567 
  )
20568 
 
20569 
  def __init__(self, success=None,):
20570 
    self.success = success
20571 
 
20572 
  def read(self, iprot):
20573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20575 
      return
20576 
    iprot.readStructBegin()
20577 
    while True:
20578 
      (fname, ftype, fid) = iprot.readFieldBegin()
20579 
      if ftype == TType.STOP:
20580 
        break
20581 
      if fid == 0:
20582 
        if ftype == TType.LIST:
20583 
          self.success = []
8619 kshitij.so 20584 
          (_etype454, _size451) = iprot.readListBegin()
20585 
          for _i455 in xrange(_size451):
20586 
            _elem456 = Category()
20587 
            _elem456.read(iprot)
20588 
            self.success.append(_elem456)
7897 amar.kumar 20589 
          iprot.readListEnd()
20590 
        else:
20591 
          iprot.skip(ftype)
20592 
      else:
20593 
        iprot.skip(ftype)
20594 
      iprot.readFieldEnd()
20595 
    iprot.readStructEnd()
20596 
 
20597 
  def write(self, oprot):
20598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20600 
      return
20601 
    oprot.writeStructBegin('getAllParentCategories_result')
20602 
    if self.success is not None:
20603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 20605 
      for iter457 in self.success:
20606 
        iter457.write(oprot)
7897 amar.kumar 20607 
      oprot.writeListEnd()
20608 
      oprot.writeFieldEnd()
20609 
    oprot.writeFieldStop()
20610 
    oprot.writeStructEnd()
20611 
 
20612 
  def validate(self):
20613 
    return
20614 
 
20615 
 
20616 
  def __repr__(self):
20617 
    L = ['%s=%r' % (key, value)
20618 
      for key, value in self.__dict__.iteritems()]
20619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20620 
 
20621 
  def __eq__(self, other):
20622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20623 
 
20624 
  def __ne__(self, other):
20625 
    return not (self == other)
7977 kshitij.so 20626 
 
20627 
class addPageViewEvent_args:
20628 
  """
20629 
  Attributes:
20630 
   - pageViewEvents
20631 
  """
20632 
 
20633 
  thrift_spec = (
20634 
    None, # 0
20635 
    (1, TType.STRUCT, 'pageViewEvents', (PageViewEvents, PageViewEvents.thrift_spec), None, ), # 1
20636 
  )
20637 
 
20638 
  def __init__(self, pageViewEvents=None,):
20639 
    self.pageViewEvents = pageViewEvents
20640 
 
20641 
  def read(self, iprot):
20642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20644 
      return
20645 
    iprot.readStructBegin()
20646 
    while True:
20647 
      (fname, ftype, fid) = iprot.readFieldBegin()
20648 
      if ftype == TType.STOP:
20649 
        break
20650 
      if fid == 1:
20651 
        if ftype == TType.STRUCT:
20652 
          self.pageViewEvents = PageViewEvents()
20653 
          self.pageViewEvents.read(iprot)
20654 
        else:
20655 
          iprot.skip(ftype)
20656 
      else:
20657 
        iprot.skip(ftype)
20658 
      iprot.readFieldEnd()
20659 
    iprot.readStructEnd()
20660 
 
20661 
  def write(self, oprot):
20662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20664 
      return
20665 
    oprot.writeStructBegin('addPageViewEvent_args')
20666 
    if self.pageViewEvents is not None:
20667 
      oprot.writeFieldBegin('pageViewEvents', TType.STRUCT, 1)
20668 
      self.pageViewEvents.write(oprot)
20669 
      oprot.writeFieldEnd()
20670 
    oprot.writeFieldStop()
20671 
    oprot.writeStructEnd()
20672 
 
20673 
  def validate(self):
20674 
    return
20675 
 
20676 
 
20677 
  def __repr__(self):
20678 
    L = ['%s=%r' % (key, value)
20679 
      for key, value in self.__dict__.iteritems()]
20680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20681 
 
20682 
  def __eq__(self, other):
20683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20684 
 
20685 
  def __ne__(self, other):
20686 
    return not (self == other)
20687 
 
20688 
class addPageViewEvent_result:
20689 
 
20690 
  thrift_spec = (
20691 
  )
20692 
 
20693 
  def read(self, iprot):
20694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20696 
      return
20697 
    iprot.readStructBegin()
20698 
    while True:
20699 
      (fname, ftype, fid) = iprot.readFieldBegin()
20700 
      if ftype == TType.STOP:
20701 
        break
20702 
      else:
20703 
        iprot.skip(ftype)
20704 
      iprot.readFieldEnd()
20705 
    iprot.readStructEnd()
20706 
 
20707 
  def write(self, oprot):
20708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20710 
      return
20711 
    oprot.writeStructBegin('addPageViewEvent_result')
20712 
    oprot.writeFieldStop()
20713 
    oprot.writeStructEnd()
20714 
 
20715 
  def validate(self):
20716 
    return
20717 
 
20718 
 
20719 
  def __repr__(self):
20720 
    L = ['%s=%r' % (key, value)
20721 
      for key, value in self.__dict__.iteritems()]
20722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20723 
 
20724 
  def __eq__(self, other):
20725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20726 
 
20727 
  def __ne__(self, other):
20728 
    return not (self == other)
20729 
 
20730 
class addCartEvent_args:
20731 
  """
20732 
  Attributes:
20733 
   - cartEvents
20734 
  """
20735 
 
20736 
  thrift_spec = (
20737 
    None, # 0
20738 
    (1, TType.STRUCT, 'cartEvents', (CartEvents, CartEvents.thrift_spec), None, ), # 1
20739 
  )
20740 
 
20741 
  def __init__(self, cartEvents=None,):
20742 
    self.cartEvents = cartEvents
20743 
 
20744 
  def read(self, iprot):
20745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20747 
      return
20748 
    iprot.readStructBegin()
20749 
    while True:
20750 
      (fname, ftype, fid) = iprot.readFieldBegin()
20751 
      if ftype == TType.STOP:
20752 
        break
20753 
      if fid == 1:
20754 
        if ftype == TType.STRUCT:
20755 
          self.cartEvents = CartEvents()
20756 
          self.cartEvents.read(iprot)
20757 
        else:
20758 
          iprot.skip(ftype)
20759 
      else:
20760 
        iprot.skip(ftype)
20761 
      iprot.readFieldEnd()
20762 
    iprot.readStructEnd()
20763 
 
20764 
  def write(self, oprot):
20765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20767 
      return
20768 
    oprot.writeStructBegin('addCartEvent_args')
20769 
    if self.cartEvents is not None:
20770 
      oprot.writeFieldBegin('cartEvents', TType.STRUCT, 1)
20771 
      self.cartEvents.write(oprot)
20772 
      oprot.writeFieldEnd()
20773 
    oprot.writeFieldStop()
20774 
    oprot.writeStructEnd()
20775 
 
20776 
  def validate(self):
20777 
    return
20778 
 
20779 
 
20780 
  def __repr__(self):
20781 
    L = ['%s=%r' % (key, value)
20782 
      for key, value in self.__dict__.iteritems()]
20783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20784 
 
20785 
  def __eq__(self, other):
20786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20787 
 
20788 
  def __ne__(self, other):
20789 
    return not (self == other)
20790 
 
20791 
class addCartEvent_result:
20792 
 
20793 
  thrift_spec = (
20794 
  )
20795 
 
20796 
  def read(self, iprot):
20797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20799 
      return
20800 
    iprot.readStructBegin()
20801 
    while True:
20802 
      (fname, ftype, fid) = iprot.readFieldBegin()
20803 
      if ftype == TType.STOP:
20804 
        break
20805 
      else:
20806 
        iprot.skip(ftype)
20807 
      iprot.readFieldEnd()
20808 
    iprot.readStructEnd()
20809 
 
20810 
  def write(self, oprot):
20811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20813 
      return
20814 
    oprot.writeStructBegin('addCartEvent_result')
20815 
    oprot.writeFieldStop()
20816 
    oprot.writeStructEnd()
20817 
 
20818 
  def validate(self):
20819 
    return
20820 
 
20821 
 
20822 
  def __repr__(self):
20823 
    L = ['%s=%r' % (key, value)
20824 
      for key, value in self.__dict__.iteritems()]
20825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20826 
 
20827 
  def __eq__(self, other):
20828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20829 
 
20830 
  def __ne__(self, other):
20831 
    return not (self == other)
8139 kshitij.so 20832 
 
8182 amar.kumar 20833 
class addEbayItem_args:
20834 
  """
20835 
  Attributes:
20836 
   - ebayItem
20837 
  """
20838 
 
20839 
  thrift_spec = (
20840 
    None, # 0
20841 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
20842 
  )
20843 
 
20844 
  def __init__(self, ebayItem=None,):
20845 
    self.ebayItem = ebayItem
20846 
 
20847 
  def read(self, iprot):
20848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20850 
      return
20851 
    iprot.readStructBegin()
20852 
    while True:
20853 
      (fname, ftype, fid) = iprot.readFieldBegin()
20854 
      if ftype == TType.STOP:
20855 
        break
20856 
      if fid == 1:
20857 
        if ftype == TType.STRUCT:
20858 
          self.ebayItem = EbayItem()
20859 
          self.ebayItem.read(iprot)
20860 
        else:
20861 
          iprot.skip(ftype)
20862 
      else:
20863 
        iprot.skip(ftype)
20864 
      iprot.readFieldEnd()
20865 
    iprot.readStructEnd()
20866 
 
20867 
  def write(self, oprot):
20868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20870 
      return
20871 
    oprot.writeStructBegin('addEbayItem_args')
20872 
    if self.ebayItem is not None:
20873 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
20874 
      self.ebayItem.write(oprot)
20875 
      oprot.writeFieldEnd()
20876 
    oprot.writeFieldStop()
20877 
    oprot.writeStructEnd()
20878 
 
20879 
  def validate(self):
20880 
    return
20881 
 
20882 
 
20883 
  def __repr__(self):
20884 
    L = ['%s=%r' % (key, value)
20885 
      for key, value in self.__dict__.iteritems()]
20886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20887 
 
20888 
  def __eq__(self, other):
20889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20890 
 
20891 
  def __ne__(self, other):
20892 
    return not (self == other)
20893 
 
20894 
class addEbayItem_result:
20895 
 
20896 
  thrift_spec = (
20897 
  )
20898 
 
20899 
  def read(self, iprot):
20900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20902 
      return
20903 
    iprot.readStructBegin()
20904 
    while True:
20905 
      (fname, ftype, fid) = iprot.readFieldBegin()
20906 
      if ftype == TType.STOP:
20907 
        break
20908 
      else:
20909 
        iprot.skip(ftype)
20910 
      iprot.readFieldEnd()
20911 
    iprot.readStructEnd()
20912 
 
20913 
  def write(self, oprot):
20914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20916 
      return
20917 
    oprot.writeStructBegin('addEbayItem_result')
20918 
    oprot.writeFieldStop()
20919 
    oprot.writeStructEnd()
20920 
 
20921 
  def validate(self):
20922 
    return
20923 
 
20924 
 
20925 
  def __repr__(self):
20926 
    L = ['%s=%r' % (key, value)
20927 
      for key, value in self.__dict__.iteritems()]
20928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20929 
 
20930 
  def __eq__(self, other):
20931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20932 
 
20933 
  def __ne__(self, other):
20934 
    return not (self == other)
20935 
 
20936 
class getEbayItem_args:
20937 
  """
20938 
  Attributes:
20939 
   - listingId
20940 
  """
20941 
 
20942 
  thrift_spec = (
20943 
    None, # 0
20944 
    (1, TType.STRING, 'listingId', None, None, ), # 1
20945 
  )
20946 
 
20947 
  def __init__(self, listingId=None,):
20948 
    self.listingId = listingId
20949 
 
20950 
  def read(self, iprot):
20951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20953 
      return
20954 
    iprot.readStructBegin()
20955 
    while True:
20956 
      (fname, ftype, fid) = iprot.readFieldBegin()
20957 
      if ftype == TType.STOP:
20958 
        break
20959 
      if fid == 1:
20960 
        if ftype == TType.STRING:
20961 
          self.listingId = iprot.readString();
20962 
        else:
20963 
          iprot.skip(ftype)
20964 
      else:
20965 
        iprot.skip(ftype)
20966 
      iprot.readFieldEnd()
20967 
    iprot.readStructEnd()
20968 
 
20969 
  def write(self, oprot):
20970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20972 
      return
20973 
    oprot.writeStructBegin('getEbayItem_args')
20974 
    if self.listingId is not None:
20975 
      oprot.writeFieldBegin('listingId', TType.STRING, 1)
20976 
      oprot.writeString(self.listingId)
20977 
      oprot.writeFieldEnd()
20978 
    oprot.writeFieldStop()
20979 
    oprot.writeStructEnd()
20980 
 
20981 
  def validate(self):
20982 
    return
20983 
 
20984 
 
20985 
  def __repr__(self):
20986 
    L = ['%s=%r' % (key, value)
20987 
      for key, value in self.__dict__.iteritems()]
20988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20989 
 
20990 
  def __eq__(self, other):
20991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20992 
 
20993 
  def __ne__(self, other):
20994 
    return not (self == other)
20995 
 
20996 
class getEbayItem_result:
20997 
  """
20998 
  Attributes:
20999 
   - success
21000 
  """
21001 
 
21002 
  thrift_spec = (
21003 
    (0, TType.STRUCT, 'success', (EbayItem, EbayItem.thrift_spec), None, ), # 0
21004 
  )
21005 
 
21006 
  def __init__(self, success=None,):
21007 
    self.success = success
21008 
 
21009 
  def read(self, iprot):
21010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21012 
      return
21013 
    iprot.readStructBegin()
21014 
    while True:
21015 
      (fname, ftype, fid) = iprot.readFieldBegin()
21016 
      if ftype == TType.STOP:
21017 
        break
21018 
      if fid == 0:
21019 
        if ftype == TType.STRUCT:
21020 
          self.success = EbayItem()
21021 
          self.success.read(iprot)
21022 
        else:
21023 
          iprot.skip(ftype)
21024 
      else:
21025 
        iprot.skip(ftype)
21026 
      iprot.readFieldEnd()
21027 
    iprot.readStructEnd()
21028 
 
21029 
  def write(self, oprot):
21030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21032 
      return
21033 
    oprot.writeStructBegin('getEbayItem_result')
21034 
    if self.success is not None:
21035 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21036 
      self.success.write(oprot)
21037 
      oprot.writeFieldEnd()
21038 
    oprot.writeFieldStop()
21039 
    oprot.writeStructEnd()
21040 
 
21041 
  def validate(self):
21042 
    return
21043 
 
21044 
 
21045 
  def __repr__(self):
21046 
    L = ['%s=%r' % (key, value)
21047 
      for key, value in self.__dict__.iteritems()]
21048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21049 
 
21050 
  def __eq__(self, other):
21051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21052 
 
21053 
  def __ne__(self, other):
21054 
    return not (self == other)
21055 
 
21056 
class updateEbayItem_args:
21057 
  """
21058 
  Attributes:
21059 
   - ebayItem
21060 
  """
21061 
 
21062 
  thrift_spec = (
21063 
    None, # 0
21064 
    (1, TType.STRUCT, 'ebayItem', (EbayItem, EbayItem.thrift_spec), None, ), # 1
21065 
  )
21066 
 
21067 
  def __init__(self, ebayItem=None,):
21068 
    self.ebayItem = ebayItem
21069 
 
21070 
  def read(self, iprot):
21071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21073 
      return
21074 
    iprot.readStructBegin()
21075 
    while True:
21076 
      (fname, ftype, fid) = iprot.readFieldBegin()
21077 
      if ftype == TType.STOP:
21078 
        break
21079 
      if fid == 1:
21080 
        if ftype == TType.STRUCT:
21081 
          self.ebayItem = EbayItem()
21082 
          self.ebayItem.read(iprot)
21083 
        else:
21084 
          iprot.skip(ftype)
21085 
      else:
21086 
        iprot.skip(ftype)
21087 
      iprot.readFieldEnd()
21088 
    iprot.readStructEnd()
21089 
 
21090 
  def write(self, oprot):
21091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21093 
      return
21094 
    oprot.writeStructBegin('updateEbayItem_args')
21095 
    if self.ebayItem is not None:
21096 
      oprot.writeFieldBegin('ebayItem', TType.STRUCT, 1)
21097 
      self.ebayItem.write(oprot)
21098 
      oprot.writeFieldEnd()
21099 
    oprot.writeFieldStop()
21100 
    oprot.writeStructEnd()
21101 
 
21102 
  def validate(self):
21103 
    return
21104 
 
21105 
 
21106 
  def __repr__(self):
21107 
    L = ['%s=%r' % (key, value)
21108 
      for key, value in self.__dict__.iteritems()]
21109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21110 
 
21111 
  def __eq__(self, other):
21112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21113 
 
21114 
  def __ne__(self, other):
21115 
    return not (self == other)
21116 
 
21117 
class updateEbayItem_result:
21118 
 
21119 
  thrift_spec = (
21120 
  )
21121 
 
21122 
  def read(self, iprot):
21123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21125 
      return
21126 
    iprot.readStructBegin()
21127 
    while True:
21128 
      (fname, ftype, fid) = iprot.readFieldBegin()
21129 
      if ftype == TType.STOP:
21130 
        break
21131 
      else:
21132 
        iprot.skip(ftype)
21133 
      iprot.readFieldEnd()
21134 
    iprot.readStructEnd()
21135 
 
21136 
  def write(self, oprot):
21137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21139 
      return
21140 
    oprot.writeStructBegin('updateEbayItem_result')
21141 
    oprot.writeFieldStop()
21142 
    oprot.writeStructEnd()
21143 
 
21144 
  def validate(self):
21145 
    return
21146 
 
21147 
 
21148 
  def __repr__(self):
21149 
    L = ['%s=%r' % (key, value)
21150 
      for key, value in self.__dict__.iteritems()]
21151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21152 
 
21153 
  def __eq__(self, other):
21154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21155 
 
21156 
  def __ne__(self, other):
21157 
    return not (self == other)
21158 
 
8139 kshitij.so 21159 
class getAmazonListedItems_args:
21160 
  """
21161 
  Attributes:
21162 
   - offset
21163 
   - limit
21164 
  """
21165 
 
21166 
  thrift_spec = (
21167 
    None, # 0
21168 
    (1, TType.I64, 'offset', None, None, ), # 1
21169 
    (2, TType.I64, 'limit', None, None, ), # 2
21170 
  )
21171 
 
21172 
  def __init__(self, offset=None, limit=None,):
21173 
    self.offset = offset
21174 
    self.limit = limit
21175 
 
21176 
  def read(self, iprot):
21177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21179 
      return
21180 
    iprot.readStructBegin()
21181 
    while True:
21182 
      (fname, ftype, fid) = iprot.readFieldBegin()
21183 
      if ftype == TType.STOP:
21184 
        break
21185 
      if fid == 1:
21186 
        if ftype == TType.I64:
21187 
          self.offset = iprot.readI64();
21188 
        else:
21189 
          iprot.skip(ftype)
21190 
      elif fid == 2:
21191 
        if ftype == TType.I64:
21192 
          self.limit = iprot.readI64();
21193 
        else:
21194 
          iprot.skip(ftype)
21195 
      else:
21196 
        iprot.skip(ftype)
21197 
      iprot.readFieldEnd()
21198 
    iprot.readStructEnd()
21199 
 
21200 
  def write(self, oprot):
21201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21203 
      return
21204 
    oprot.writeStructBegin('getAmazonListedItems_args')
21205 
    if self.offset is not None:
21206 
      oprot.writeFieldBegin('offset', TType.I64, 1)
21207 
      oprot.writeI64(self.offset)
21208 
      oprot.writeFieldEnd()
21209 
    if self.limit is not None:
21210 
      oprot.writeFieldBegin('limit', TType.I64, 2)
21211 
      oprot.writeI64(self.limit)
21212 
      oprot.writeFieldEnd()
21213 
    oprot.writeFieldStop()
21214 
    oprot.writeStructEnd()
21215 
 
21216 
  def validate(self):
21217 
    return
21218 
 
21219 
 
21220 
  def __repr__(self):
21221 
    L = ['%s=%r' % (key, value)
21222 
      for key, value in self.__dict__.iteritems()]
21223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21224 
 
21225 
  def __eq__(self, other):
21226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21227 
 
21228 
  def __ne__(self, other):
21229 
    return not (self == other)
21230 
 
21231 
class getAmazonListedItems_result:
21232 
  """
21233 
  Attributes:
21234 
   - success
21235 
  """
21236 
 
21237 
  thrift_spec = (
21238 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21239 
  )
21240 
 
21241 
  def __init__(self, success=None,):
21242 
    self.success = success
21243 
 
21244 
  def read(self, iprot):
21245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21247 
      return
21248 
    iprot.readStructBegin()
21249 
    while True:
21250 
      (fname, ftype, fid) = iprot.readFieldBegin()
21251 
      if ftype == TType.STOP:
21252 
        break
21253 
      if fid == 0:
21254 
        if ftype == TType.LIST:
21255 
          self.success = []
8619 kshitij.so 21256 
          (_etype461, _size458) = iprot.readListBegin()
21257 
          for _i462 in xrange(_size458):
21258 
            _elem463 = Amazonlisted()
21259 
            _elem463.read(iprot)
21260 
            self.success.append(_elem463)
8139 kshitij.so 21261 
          iprot.readListEnd()
21262 
        else:
21263 
          iprot.skip(ftype)
21264 
      else:
21265 
        iprot.skip(ftype)
21266 
      iprot.readFieldEnd()
21267 
    iprot.readStructEnd()
21268 
 
21269 
  def write(self, oprot):
21270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21272 
      return
21273 
    oprot.writeStructBegin('getAmazonListedItems_result')
21274 
    if self.success is not None:
21275 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21276 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21277 
      for iter464 in self.success:
21278 
        iter464.write(oprot)
8139 kshitij.so 21279 
      oprot.writeListEnd()
21280 
      oprot.writeFieldEnd()
21281 
    oprot.writeFieldStop()
21282 
    oprot.writeStructEnd()
21283 
 
21284 
  def validate(self):
21285 
    return
21286 
 
21287 
 
21288 
  def __repr__(self):
21289 
    L = ['%s=%r' % (key, value)
21290 
      for key, value in self.__dict__.iteritems()]
21291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21292 
 
21293 
  def __eq__(self, other):
21294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21295 
 
21296 
  def __ne__(self, other):
21297 
    return not (self == other)
8168 kshitij.so 21298 
 
21299 
class updateAmazonAttributesInBulk_args:
21300 
  """
21301 
  Attributes:
21302 
   - amazonlisted
21303 
  """
21304 
 
21305 
  thrift_spec = (
21306 
    None, # 0
21307 
    (1, TType.MAP, 'amazonlisted', (TType.I64,None,TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 1
21308 
  )
21309 
 
21310 
  def __init__(self, amazonlisted=None,):
21311 
    self.amazonlisted = amazonlisted
21312 
 
21313 
  def read(self, iprot):
21314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21316 
      return
21317 
    iprot.readStructBegin()
21318 
    while True:
21319 
      (fname, ftype, fid) = iprot.readFieldBegin()
21320 
      if ftype == TType.STOP:
21321 
        break
21322 
      if fid == 1:
21323 
        if ftype == TType.MAP:
21324 
          self.amazonlisted = {}
8619 kshitij.so 21325 
          (_ktype466, _vtype467, _size465 ) = iprot.readMapBegin()
21326 
          for _i469 in xrange(_size465):
21327 
            _key470 = iprot.readI64();
21328 
            _val471 = Amazonlisted()
21329 
            _val471.read(iprot)
21330 
            self.amazonlisted[_key470] = _val471
8168 kshitij.so 21331 
          iprot.readMapEnd()
21332 
        else:
21333 
          iprot.skip(ftype)
21334 
      else:
21335 
        iprot.skip(ftype)
21336 
      iprot.readFieldEnd()
21337 
    iprot.readStructEnd()
21338 
 
21339 
  def write(self, oprot):
21340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21342 
      return
21343 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_args')
21344 
    if self.amazonlisted is not None:
21345 
      oprot.writeFieldBegin('amazonlisted', TType.MAP, 1)
21346 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.amazonlisted))
8619 kshitij.so 21347 
      for kiter472,viter473 in self.amazonlisted.items():
21348 
        oprot.writeI64(kiter472)
21349 
        viter473.write(oprot)
8168 kshitij.so 21350 
      oprot.writeMapEnd()
21351 
      oprot.writeFieldEnd()
21352 
    oprot.writeFieldStop()
21353 
    oprot.writeStructEnd()
21354 
 
21355 
  def validate(self):
21356 
    return
21357 
 
21358 
 
21359 
  def __repr__(self):
21360 
    L = ['%s=%r' % (key, value)
21361 
      for key, value in self.__dict__.iteritems()]
21362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21363 
 
21364 
  def __eq__(self, other):
21365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21366 
 
21367 
  def __ne__(self, other):
21368 
    return not (self == other)
21369 
 
21370 
class updateAmazonAttributesInBulk_result:
21371 
  """
21372 
  Attributes:
21373 
   - success
21374 
  """
21375 
 
21376 
  thrift_spec = (
21377 
    (0, TType.BOOL, 'success', None, None, ), # 0
21378 
  )
21379 
 
21380 
  def __init__(self, success=None,):
21381 
    self.success = success
21382 
 
21383 
  def read(self, iprot):
21384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21386 
      return
21387 
    iprot.readStructBegin()
21388 
    while True:
21389 
      (fname, ftype, fid) = iprot.readFieldBegin()
21390 
      if ftype == TType.STOP:
21391 
        break
21392 
      if fid == 0:
21393 
        if ftype == TType.BOOL:
21394 
          self.success = iprot.readBool();
21395 
        else:
21396 
          iprot.skip(ftype)
21397 
      else:
21398 
        iprot.skip(ftype)
21399 
      iprot.readFieldEnd()
21400 
    iprot.readStructEnd()
21401 
 
21402 
  def write(self, oprot):
21403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21405 
      return
21406 
    oprot.writeStructBegin('updateAmazonAttributesInBulk_result')
21407 
    if self.success is not None:
21408 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21409 
      oprot.writeBool(self.success)
21410 
      oprot.writeFieldEnd()
21411 
    oprot.writeFieldStop()
21412 
    oprot.writeStructEnd()
21413 
 
21414 
  def validate(self):
21415 
    return
21416 
 
21417 
 
21418 
  def __repr__(self):
21419 
    L = ['%s=%r' % (key, value)
21420 
      for key, value in self.__dict__.iteritems()]
21421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21422 
 
21423 
  def __eq__(self, other):
21424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21425 
 
21426 
  def __ne__(self, other):
21427 
    return not (self == other)
8379 vikram.rag 21428 
 
21429 
class getAllItemstoListOnFba_args:
21430 
 
21431 
  thrift_spec = (
21432 
  )
21433 
 
21434 
  def read(self, iprot):
21435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21437 
      return
21438 
    iprot.readStructBegin()
21439 
    while True:
21440 
      (fname, ftype, fid) = iprot.readFieldBegin()
21441 
      if ftype == TType.STOP:
21442 
        break
21443 
      else:
21444 
        iprot.skip(ftype)
21445 
      iprot.readFieldEnd()
21446 
    iprot.readStructEnd()
21447 
 
21448 
  def write(self, oprot):
21449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21451 
      return
21452 
    oprot.writeStructBegin('getAllItemstoListOnFba_args')
21453 
    oprot.writeFieldStop()
21454 
    oprot.writeStructEnd()
21455 
 
21456 
  def validate(self):
21457 
    return
21458 
 
21459 
 
21460 
  def __repr__(self):
21461 
    L = ['%s=%r' % (key, value)
21462 
      for key, value in self.__dict__.iteritems()]
21463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21464 
 
21465 
  def __eq__(self, other):
21466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21467 
 
21468 
  def __ne__(self, other):
21469 
    return not (self == other)
21470 
 
21471 
class getAllItemstoListOnFba_result:
21472 
  """
21473 
  Attributes:
21474 
   - success
21475 
  """
21476 
 
21477 
  thrift_spec = (
21478 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21479 
  )
21480 
 
21481 
  def __init__(self, success=None,):
21482 
    self.success = success
21483 
 
21484 
  def read(self, iprot):
21485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21487 
      return
21488 
    iprot.readStructBegin()
21489 
    while True:
21490 
      (fname, ftype, fid) = iprot.readFieldBegin()
21491 
      if ftype == TType.STOP:
21492 
        break
21493 
      if fid == 0:
21494 
        if ftype == TType.LIST:
21495 
          self.success = []
8619 kshitij.so 21496 
          (_etype477, _size474) = iprot.readListBegin()
21497 
          for _i478 in xrange(_size474):
21498 
            _elem479 = Amazonlisted()
21499 
            _elem479.read(iprot)
21500 
            self.success.append(_elem479)
8379 vikram.rag 21501 
          iprot.readListEnd()
21502 
        else:
21503 
          iprot.skip(ftype)
21504 
      else:
21505 
        iprot.skip(ftype)
21506 
      iprot.readFieldEnd()
21507 
    iprot.readStructEnd()
21508 
 
21509 
  def write(self, oprot):
21510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21512 
      return
21513 
    oprot.writeStructBegin('getAllItemstoListOnFba_result')
21514 
    if self.success is not None:
21515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21517 
      for iter480 in self.success:
21518 
        iter480.write(oprot)
8379 vikram.rag 21519 
      oprot.writeListEnd()
21520 
      oprot.writeFieldEnd()
21521 
    oprot.writeFieldStop()
21522 
    oprot.writeStructEnd()
21523 
 
21524 
  def validate(self):
21525 
    return
21526 
 
21527 
 
21528 
  def __repr__(self):
21529 
    L = ['%s=%r' % (key, value)
21530 
      for key, value in self.__dict__.iteritems()]
21531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21532 
 
21533 
  def __eq__(self, other):
21534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21535 
 
21536 
  def __ne__(self, other):
21537 
    return not (self == other)
21538 
 
21539 
class getAllItemstoListOnNonFba_args:
21540 
 
21541 
  thrift_spec = (
21542 
  )
21543 
 
21544 
  def read(self, iprot):
21545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21547 
      return
21548 
    iprot.readStructBegin()
21549 
    while True:
21550 
      (fname, ftype, fid) = iprot.readFieldBegin()
21551 
      if ftype == TType.STOP:
21552 
        break
21553 
      else:
21554 
        iprot.skip(ftype)
21555 
      iprot.readFieldEnd()
21556 
    iprot.readStructEnd()
21557 
 
21558 
  def write(self, oprot):
21559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21561 
      return
21562 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_args')
21563 
    oprot.writeFieldStop()
21564 
    oprot.writeStructEnd()
21565 
 
21566 
  def validate(self):
21567 
    return
21568 
 
21569 
 
21570 
  def __repr__(self):
21571 
    L = ['%s=%r' % (key, value)
21572 
      for key, value in self.__dict__.iteritems()]
21573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21574 
 
21575 
  def __eq__(self, other):
21576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21577 
 
21578 
  def __ne__(self, other):
21579 
    return not (self == other)
21580 
 
21581 
class getAllItemstoListOnNonFba_result:
21582 
  """
21583 
  Attributes:
21584 
   - success
21585 
  """
21586 
 
21587 
  thrift_spec = (
21588 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
21589 
  )
21590 
 
21591 
  def __init__(self, success=None,):
21592 
    self.success = success
21593 
 
21594 
  def read(self, iprot):
21595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21597 
      return
21598 
    iprot.readStructBegin()
21599 
    while True:
21600 
      (fname, ftype, fid) = iprot.readFieldBegin()
21601 
      if ftype == TType.STOP:
21602 
        break
21603 
      if fid == 0:
21604 
        if ftype == TType.LIST:
21605 
          self.success = []
8619 kshitij.so 21606 
          (_etype484, _size481) = iprot.readListBegin()
21607 
          for _i485 in xrange(_size481):
21608 
            _elem486 = Amazonlisted()
21609 
            _elem486.read(iprot)
21610 
            self.success.append(_elem486)
8379 vikram.rag 21611 
          iprot.readListEnd()
21612 
        else:
21613 
          iprot.skip(ftype)
21614 
      else:
21615 
        iprot.skip(ftype)
21616 
      iprot.readFieldEnd()
21617 
    iprot.readStructEnd()
21618 
 
21619 
  def write(self, oprot):
21620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21622 
      return
21623 
    oprot.writeStructBegin('getAllItemstoListOnNonFba_result')
21624 
    if self.success is not None:
21625 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21626 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21627 
      for iter487 in self.success:
21628 
        iter487.write(oprot)
8379 vikram.rag 21629 
      oprot.writeListEnd()
21630 
      oprot.writeFieldEnd()
21631 
    oprot.writeFieldStop()
21632 
    oprot.writeStructEnd()
21633 
 
21634 
  def validate(self):
21635 
    return
21636 
 
21637 
 
21638 
  def __repr__(self):
21639 
    L = ['%s=%r' % (key, value)
21640 
      for key, value in self.__dict__.iteritems()]
21641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21642 
 
21643 
  def __eq__(self, other):
21644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21645 
 
21646 
  def __ne__(self, other):
21647 
    return not (self == other)
8616 vikram.rag 21648 
 
21649 
class getAllSnapdealListedActiveItems_args:
21650 
 
21651 
  thrift_spec = (
21652 
  )
21653 
 
21654 
  def read(self, iprot):
21655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21657 
      return
21658 
    iprot.readStructBegin()
21659 
    while True:
21660 
      (fname, ftype, fid) = iprot.readFieldBegin()
21661 
      if ftype == TType.STOP:
21662 
        break
21663 
      else:
21664 
        iprot.skip(ftype)
21665 
      iprot.readFieldEnd()
21666 
    iprot.readStructEnd()
21667 
 
21668 
  def write(self, oprot):
21669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21671 
      return
21672 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_args')
21673 
    oprot.writeFieldStop()
21674 
    oprot.writeStructEnd()
21675 
 
21676 
  def validate(self):
21677 
    return
21678 
 
21679 
 
21680 
  def __repr__(self):
21681 
    L = ['%s=%r' % (key, value)
21682 
      for key, value in self.__dict__.iteritems()]
21683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21684 
 
21685 
  def __eq__(self, other):
21686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21687 
 
21688 
  def __ne__(self, other):
21689 
    return not (self == other)
21690 
 
21691 
class getAllSnapdealListedActiveItems_result:
21692 
  """
21693 
  Attributes:
21694 
   - success
21695 
  """
21696 
 
21697 
  thrift_spec = (
21698 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
21699 
  )
21700 
 
21701 
  def __init__(self, success=None,):
21702 
    self.success = success
21703 
 
21704 
  def read(self, iprot):
21705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21707 
      return
21708 
    iprot.readStructBegin()
21709 
    while True:
21710 
      (fname, ftype, fid) = iprot.readFieldBegin()
21711 
      if ftype == TType.STOP:
21712 
        break
21713 
      if fid == 0:
21714 
        if ftype == TType.LIST:
21715 
          self.success = []
8619 kshitij.so 21716 
          (_etype491, _size488) = iprot.readListBegin()
21717 
          for _i492 in xrange(_size488):
21718 
            _elem493 = Item()
21719 
            _elem493.read(iprot)
21720 
            self.success.append(_elem493)
8616 vikram.rag 21721 
          iprot.readListEnd()
21722 
        else:
21723 
          iprot.skip(ftype)
21724 
      else:
21725 
        iprot.skip(ftype)
21726 
      iprot.readFieldEnd()
21727 
    iprot.readStructEnd()
21728 
 
21729 
  def write(self, oprot):
21730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21732 
      return
21733 
    oprot.writeStructBegin('getAllSnapdealListedActiveItems_result')
21734 
    if self.success is not None:
21735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21736 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8619 kshitij.so 21737 
      for iter494 in self.success:
21738 
        iter494.write(oprot)
8616 vikram.rag 21739 
      oprot.writeListEnd()
21740 
      oprot.writeFieldEnd()
21741 
    oprot.writeFieldStop()
21742 
    oprot.writeStructEnd()
21743 
 
21744 
  def validate(self):
21745 
    return
21746 
 
21747 
 
21748 
  def __repr__(self):
21749 
    L = ['%s=%r' % (key, value)
21750 
      for key, value in self.__dict__.iteritems()]
21751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21752 
 
21753 
  def __eq__(self, other):
21754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21755 
 
21756 
  def __ne__(self, other):
21757 
    return not (self == other)
8619 kshitij.so 21758 
 
21759 
class updateAsin_args:
21760 
  """
21761 
  Attributes:
21762 
   - item
21763 
  """
21764 
 
21765 
  thrift_spec = (
21766 
    None, # 0
21767 
    (1, TType.MAP, 'item', (TType.I64,None,TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 1
21768 
  )
21769 
 
21770 
  def __init__(self, item=None,):
21771 
    self.item = item
21772 
 
21773 
  def read(self, iprot):
21774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21776 
      return
21777 
    iprot.readStructBegin()
21778 
    while True:
21779 
      (fname, ftype, fid) = iprot.readFieldBegin()
21780 
      if ftype == TType.STOP:
21781 
        break
21782 
      if fid == 1:
21783 
        if ftype == TType.MAP:
21784 
          self.item = {}
21785 
          (_ktype496, _vtype497, _size495 ) = iprot.readMapBegin()
21786 
          for _i499 in xrange(_size495):
21787 
            _key500 = iprot.readI64();
21788 
            _val501 = Item()
21789 
            _val501.read(iprot)
21790 
            self.item[_key500] = _val501
21791 
          iprot.readMapEnd()
21792 
        else:
21793 
          iprot.skip(ftype)
21794 
      else:
21795 
        iprot.skip(ftype)
21796 
      iprot.readFieldEnd()
21797 
    iprot.readStructEnd()
21798 
 
21799 
  def write(self, oprot):
21800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21802 
      return
21803 
    oprot.writeStructBegin('updateAsin_args')
21804 
    if self.item is not None:
21805 
      oprot.writeFieldBegin('item', TType.MAP, 1)
21806 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.item))
21807 
      for kiter502,viter503 in self.item.items():
21808 
        oprot.writeI64(kiter502)
21809 
        viter503.write(oprot)
21810 
      oprot.writeMapEnd()
21811 
      oprot.writeFieldEnd()
21812 
    oprot.writeFieldStop()
21813 
    oprot.writeStructEnd()
21814 
 
21815 
  def validate(self):
21816 
    return
21817 
 
21818 
 
21819 
  def __repr__(self):
21820 
    L = ['%s=%r' % (key, value)
21821 
      for key, value in self.__dict__.iteritems()]
21822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21823 
 
21824 
  def __eq__(self, other):
21825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21826 
 
21827 
  def __ne__(self, other):
21828 
    return not (self == other)
21829 
 
21830 
class updateAsin_result:
21831 
 
21832 
  thrift_spec = (
21833 
  )
21834 
 
21835 
  def read(self, iprot):
21836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21838 
      return
21839 
    iprot.readStructBegin()
21840 
    while True:
21841 
      (fname, ftype, fid) = iprot.readFieldBegin()
21842 
      if ftype == TType.STOP:
21843 
        break
21844 
      else:
21845 
        iprot.skip(ftype)
21846 
      iprot.readFieldEnd()
21847 
    iprot.readStructEnd()
21848 
 
21849 
  def write(self, oprot):
21850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21852 
      return
21853 
    oprot.writeStructBegin('updateAsin_result')
21854 
    oprot.writeFieldStop()
21855 
    oprot.writeStructEnd()
21856 
 
21857 
  def validate(self):
21858 
    return
21859 
 
21860 
 
21861 
  def __repr__(self):
21862 
    L = ['%s=%r' % (key, value)
21863 
      for key, value in self.__dict__.iteritems()]
21864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21865 
 
21866 
  def __eq__(self, other):
21867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21868 
 
21869 
  def __ne__(self, other):
21870 
    return not (self == other)
8739 vikram.rag 21871 
 
21872 
class addOrUpdateSnapdealItem_args:
21873 
  """
21874 
  Attributes:
21875 
   - snapdealitem
21876 
  """
21877 
 
21878 
  thrift_spec = None
21879 
  def __init__(self, snapdealitem=None,):
21880 
    self.snapdealitem = snapdealitem
21881 
 
21882 
  def read(self, iprot):
21883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21885 
      return
21886 
    iprot.readStructBegin()
21887 
    while True:
21888 
      (fname, ftype, fid) = iprot.readFieldBegin()
21889 
      if ftype == TType.STOP:
21890 
        break
21891 
      if fid == -1:
21892 
        if ftype == TType.STRUCT:
21893 
          self.snapdealitem = SnapdealItem()
21894 
          self.snapdealitem.read(iprot)
21895 
        else:
21896 
          iprot.skip(ftype)
21897 
      else:
21898 
        iprot.skip(ftype)
21899 
      iprot.readFieldEnd()
21900 
    iprot.readStructEnd()
21901 
 
21902 
  def write(self, oprot):
21903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21905 
      return
21906 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_args')
21907 
    if self.snapdealitem is not None:
21908 
      oprot.writeFieldBegin('snapdealitem', TType.STRUCT, -1)
21909 
      self.snapdealitem.write(oprot)
21910 
      oprot.writeFieldEnd()
21911 
    oprot.writeFieldStop()
21912 
    oprot.writeStructEnd()
21913 
 
21914 
  def validate(self):
21915 
    return
21916 
 
21917 
 
21918 
  def __repr__(self):
21919 
    L = ['%s=%r' % (key, value)
21920 
      for key, value in self.__dict__.iteritems()]
21921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21922 
 
21923 
  def __eq__(self, other):
21924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21925 
 
21926 
  def __ne__(self, other):
21927 
    return not (self == other)
21928 
 
21929 
class addOrUpdateSnapdealItem_result:
21930 
  """
21931 
  Attributes:
21932 
   - success
21933 
  """
21934 
 
21935 
  thrift_spec = (
21936 
    (0, TType.BOOL, 'success', None, None, ), # 0
21937 
  )
21938 
 
21939 
  def __init__(self, success=None,):
21940 
    self.success = success
21941 
 
21942 
  def read(self, iprot):
21943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21945 
      return
21946 
    iprot.readStructBegin()
21947 
    while True:
21948 
      (fname, ftype, fid) = iprot.readFieldBegin()
21949 
      if ftype == TType.STOP:
21950 
        break
21951 
      if fid == 0:
21952 
        if ftype == TType.BOOL:
21953 
          self.success = iprot.readBool();
21954 
        else:
21955 
          iprot.skip(ftype)
21956 
      else:
21957 
        iprot.skip(ftype)
21958 
      iprot.readFieldEnd()
21959 
    iprot.readStructEnd()
21960 
 
21961 
  def write(self, oprot):
21962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21964 
      return
21965 
    oprot.writeStructBegin('addOrUpdateSnapdealItem_result')
21966 
    if self.success is not None:
21967 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21968 
      oprot.writeBool(self.success)
21969 
      oprot.writeFieldEnd()
21970 
    oprot.writeFieldStop()
21971 
    oprot.writeStructEnd()
21972 
 
21973 
  def validate(self):
21974 
    return
21975 
 
21976 
 
21977 
  def __repr__(self):
21978 
    L = ['%s=%r' % (key, value)
21979 
      for key, value in self.__dict__.iteritems()]
21980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21981 
 
21982 
  def __eq__(self, other):
21983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21984 
 
21985 
  def __ne__(self, other):
21986 
    return not (self == other)
21987 
 
21988 
class getSnapdealItem_args:
21989 
  """
21990 
  Attributes:
21991 
   - item_id
21992 
  """
21993 
 
21994 
  thrift_spec = (
21995 
    None, # 0
21996 
    (1, TType.I64, 'item_id', None, None, ), # 1
21997 
  )
21998 
 
21999 
  def __init__(self, item_id=None,):
22000 
    self.item_id = item_id
22001 
 
22002 
  def read(self, iprot):
22003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22005 
      return
22006 
    iprot.readStructBegin()
22007 
    while True:
22008 
      (fname, ftype, fid) = iprot.readFieldBegin()
22009 
      if ftype == TType.STOP:
22010 
        break
22011 
      if fid == 1:
22012 
        if ftype == TType.I64:
22013 
          self.item_id = iprot.readI64();
22014 
        else:
22015 
          iprot.skip(ftype)
22016 
      else:
22017 
        iprot.skip(ftype)
22018 
      iprot.readFieldEnd()
22019 
    iprot.readStructEnd()
22020 
 
22021 
  def write(self, oprot):
22022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22024 
      return
22025 
    oprot.writeStructBegin('getSnapdealItem_args')
22026 
    if self.item_id is not None:
22027 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
22028 
      oprot.writeI64(self.item_id)
22029 
      oprot.writeFieldEnd()
22030 
    oprot.writeFieldStop()
22031 
    oprot.writeStructEnd()
22032 
 
22033 
  def validate(self):
22034 
    return
22035 
 
22036 
 
22037 
  def __repr__(self):
22038 
    L = ['%s=%r' % (key, value)
22039 
      for key, value in self.__dict__.iteritems()]
22040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22041 
 
22042 
  def __eq__(self, other):
22043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22044 
 
22045 
  def __ne__(self, other):
22046 
    return not (self == other)
22047 
 
22048 
class getSnapdealItem_result:
22049 
  """
22050 
  Attributes:
22051 
   - success
22052 
  """
22053 
 
22054 
  thrift_spec = (
22055 
    (0, TType.STRUCT, 'success', (SnapdealItem, SnapdealItem.thrift_spec), None, ), # 0
22056 
  )
22057 
 
22058 
  def __init__(self, success=None,):
22059 
    self.success = success
22060 
 
22061 
  def read(self, iprot):
22062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22064 
      return
22065 
    iprot.readStructBegin()
22066 
    while True:
22067 
      (fname, ftype, fid) = iprot.readFieldBegin()
22068 
      if ftype == TType.STOP:
22069 
        break
22070 
      if fid == 0:
22071 
        if ftype == TType.STRUCT:
22072 
          self.success = SnapdealItem()
22073 
          self.success.read(iprot)
22074 
        else:
22075 
          iprot.skip(ftype)
22076 
      else:
22077 
        iprot.skip(ftype)
22078 
      iprot.readFieldEnd()
22079 
    iprot.readStructEnd()
22080 
 
22081 
  def write(self, oprot):
22082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22084 
      return
22085 
    oprot.writeStructBegin('getSnapdealItem_result')
22086 
    if self.success is not None:
22087 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22088 
      self.success.write(oprot)
22089 
      oprot.writeFieldEnd()
22090 
    oprot.writeFieldStop()
22091 
    oprot.writeStructEnd()
22092 
 
22093 
  def validate(self):
22094 
    return
22095 
 
22096 
 
22097 
  def __repr__(self):
22098 
    L = ['%s=%r' % (key, value)
22099 
      for key, value in self.__dict__.iteritems()]
22100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22101 
 
22102 
  def __eq__(self, other):
22103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22104 
 
22105 
  def __ne__(self, other):
22106 
    return not (self == other)
22107 
 
22108 
class getAllSnapdealItems_args:
22109 
 
22110 
  thrift_spec = (
22111 
  )
22112 
 
22113 
  def read(self, iprot):
22114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22116 
      return
22117 
    iprot.readStructBegin()
22118 
    while True:
22119 
      (fname, ftype, fid) = iprot.readFieldBegin()
22120 
      if ftype == TType.STOP:
22121 
        break
22122 
      else:
22123 
        iprot.skip(ftype)
22124 
      iprot.readFieldEnd()
22125 
    iprot.readStructEnd()
22126 
 
22127 
  def write(self, oprot):
22128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22130 
      return
22131 
    oprot.writeStructBegin('getAllSnapdealItems_args')
22132 
    oprot.writeFieldStop()
22133 
    oprot.writeStructEnd()
22134 
 
22135 
  def validate(self):
22136 
    return
22137 
 
22138 
 
22139 
  def __repr__(self):
22140 
    L = ['%s=%r' % (key, value)
22141 
      for key, value in self.__dict__.iteritems()]
22142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22143 
 
22144 
  def __eq__(self, other):
22145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22146 
 
22147 
  def __ne__(self, other):
22148 
    return not (self == other)
22149 
 
22150 
class getAllSnapdealItems_result:
22151 
  """
22152 
  Attributes:
22153 
   - success
22154 
  """
22155 
 
22156 
  thrift_spec = (
22157 
    (0, TType.LIST, 'success', (TType.STRUCT,(SnapdealItem, SnapdealItem.thrift_spec)), None, ), # 0
22158 
  )
22159 
 
22160 
  def __init__(self, success=None,):
22161 
    self.success = success
22162 
 
22163 
  def read(self, iprot):
22164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22166 
      return
22167 
    iprot.readStructBegin()
22168 
    while True:
22169 
      (fname, ftype, fid) = iprot.readFieldBegin()
22170 
      if ftype == TType.STOP:
22171 
        break
22172 
      if fid == 0:
22173 
        if ftype == TType.LIST:
22174 
          self.success = []
22175 
          (_etype507, _size504) = iprot.readListBegin()
22176 
          for _i508 in xrange(_size504):
22177 
            _elem509 = SnapdealItem()
22178 
            _elem509.read(iprot)
22179 
            self.success.append(_elem509)
22180 
          iprot.readListEnd()
22181 
        else:
22182 
          iprot.skip(ftype)
22183 
      else:
22184 
        iprot.skip(ftype)
22185 
      iprot.readFieldEnd()
22186 
    iprot.readStructEnd()
22187 
 
22188 
  def write(self, oprot):
22189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22191 
      return
22192 
    oprot.writeStructBegin('getAllSnapdealItems_result')
22193 
    if self.success is not None:
22194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22195 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
22196 
      for iter510 in self.success:
22197 
        iter510.write(oprot)
22198 
      oprot.writeListEnd()
22199 
      oprot.writeFieldEnd()
22200 
    oprot.writeFieldStop()
22201 
    oprot.writeStructEnd()
22202 
 
22203 
  def validate(self):
22204 
    return
22205 
 
22206 
 
22207 
  def __repr__(self):
22208 
    L = ['%s=%r' % (key, value)
22209 
      for key, value in self.__dict__.iteritems()]
22210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22211 
 
22212 
  def __eq__(self, other):
22213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22214 
 
22215 
  def __ne__(self, other):
22216 
    return not (self == other)